From a8dd4b5db758aae65b8a7f20918882b304f44cc0 Mon Sep 17 00:00:00 2001 From: antter Date: Wed, 17 Nov 2021 21:53:22 +0000 Subject: [PATCH] finalized unexpectedness score notebook --- .../metrics/unexpected_test_failures.ipynb | 972 ++++++++++++++++++ 1 file changed, 972 insertions(+) create mode 100644 notebooks/data-sources/TestGrid/metrics/unexpected_test_failures.ipynb diff --git a/notebooks/data-sources/TestGrid/metrics/unexpected_test_failures.ipynb b/notebooks/data-sources/TestGrid/metrics/unexpected_test_failures.ipynb new file mode 100644 index 00000000..52d8765b --- /dev/null +++ b/notebooks/data-sources/TestGrid/metrics/unexpected_test_failures.ipynb @@ -0,0 +1,972 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "986f8173-ec5d-4408-8b16-2870eba609ce", + "metadata": {}, + "source": [ + "# Unexpected Test Failures" + ] + }, + { + "cell_type": "markdown", + "id": "1b6b805a-cb06-48f8-834f-74297b75862a", + "metadata": {}, + "source": [ + "In this notebook we initially set out to predict infrastructure flakes from testgrid data. Usually an infrastructure flake can be categorized by several tests failing unexpectedly at the same time, which would mean that the problem wasn't the tests themselves, but rather the infrastructure they run on. The main challenge came from defining mathematically what it could mean for tests to fail unexpectedly. That became the main goal of this notebook and classifying why the tests failed unexpectedly, whether it be because of infrastructure or other reasons, will require further analysis. In this notebook, every column of testgrid data will be classified with a \"unexpectedness score\" that is really a probability from 0 to 100." + ] + }, + { + "cell_type": "markdown", + "id": "b77c4adb-9d60-455a-bbaf-7ddd004160d3", + "metadata": {}, + "source": [ + "## Load Data" + ] + }, + { + "cell_type": "code", + "execution_count": 117, + "id": "8ea6c93f-2136-4a36-9e72-9bfdfe02c5c8", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 117, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import json\n", + "import gzip\n", + "import os\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib.patches as mpatches\n", + "import seaborn as sns\n", + "import datetime\n", + "import numpy as np\n", + "from matplotlib import colors\n", + "import bisect\n", + "from ipynb.fs.defs.metric_template import CephCommunication\n", + "from ipynb.fs.defs.metric_template import save_to_disk\n", + "from dotenv import load_dotenv, find_dotenv\n", + "import sys\n", + "\n", + "sys.path.append('../../../failure-type-classification')\n", + "\n", + "sys.path.append('../../../failure-type-classification')\n", + "\n", + "from ipynb.fs.defs.failure_type_functions import ( #noqa\n", + " normalize, #noqa\n", + " decode_run_length, #noqa\n", + ")\n", + "\n", + "load_dotenv(find_dotenv())" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "34ab464c-5512-4096-aa81-5f579e30524b", + "metadata": {}, + "outputs": [], + "source": [ + "## Specify variables\n", + "METRIC_NAME = \"unexpected_runs\"\n", + "# Specify the path for input grid data,\n", + "INPUT_DATA_PATH = \"../../../../data/raw/testgrid_810.json.gz\"\n", + "\n", + "# Specify the path for output metric data\n", + "OUTPUT_DATA_PATH = f\"../../../../data/processed/metrics/{METRIC_NAME}\"\n", + "\n", + "# Specify whether or not we are running this as a notebook or part of an automation pipeline.\n", + "AUTOMATION = os.getenv(\"IN_AUTOMATION\")\n", + "\n", + "## CEPH Bucket variables\n", + "## Create a .env file on your local with the correct configs,\n", + "s3_endpoint_url = os.getenv(\"S3_ENDPOINT\")\n", + "s3_access_key = os.getenv(\"S3_ACCESS_KEY\")\n", + "s3_secret_key = os.getenv(\"S3_SECRET_KEY\")\n", + "s3_bucket = os.getenv(\"S3_BUCKET\")\n", + "s3_input_data_path = \"raw_data\"\n", + "metric_path = f\"ai4ci/testgrid/metrics/{METRIC_NAME}\"" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "3ba80b38-21e9-4f7b-aee3-0095b4259e74", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "## Import data\n", + "timestamp = datetime.datetime.today()\n", + "\n", + "if AUTOMATION:\n", + " filename = f\"testgrid_{timestamp.day}{timestamp.month}.json\"\n", + " cc = CephCommunication(s3_endpoint_url, s3_access_key, s3_secret_key, s3_bucket)\n", + " s3_object = cc.s3_resource.Object(s3_bucket, f\"{s3_input_data_path}/{filename}\")\n", + " file_content = s3_object.get()[\"Body\"].read().decode(\"utf-8\")\n", + " testgrid_data = json.loads(file_content)\n", + "\n", + "else:\n", + " with gzip.open(INPUT_DATA_PATH, \"rb\") as read_file:\n", + " testgrid_data = json.load(read_file)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "00ae3a7e-9298-4ff5-bd8f-60b1ee7950f8", + "metadata": {}, + "outputs": [], + "source": [ + "all_dashboards = list(testgrid_data.keys())\n", + "\n", + "all_jobs = {key: list(testgrid_data[key].keys()) for key in all_dashboards}" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "1ef6920c-cb47-4e00-bf35-1217632e8d6e", + "metadata": {}, + "outputs": [], + "source": [ + "# for data exploration\n", + "\n", + "def get_random_grid():\n", + " \"\"\"Call this function and get a totally random grid.\"\"\"\n", + " first = np.random.choice(all_dashboards)\n", + " second = np.random.choice(all_jobs[first])\n", + " grid = testgrid_data[first][second]['grid']\n", + " x = np.array(list(pd.DataFrame(grid).statuses.apply(decode_run_length)))\n", + " x = pd.DataFrame(x).apply(lambda x: [normalize(y) for y in x])\n", + " return first, second, x" + ] + }, + { + "cell_type": "markdown", + "id": "085d9dc3-458a-431a-b142-1f8c6a0a2bef", + "metadata": {}, + "source": [ + "## Visualizing" + ] + }, + { + "cell_type": "markdown", + "id": "625f023d-208b-4a2b-bba4-0eb66d0b43f5", + "metadata": {}, + "source": [ + "Below we visualize some improbable failures. We define a metric (probability of failure) that is just the sample probability of failure, $\\overline{X}$. If the probability of failure is < 0.05 and it fails, we mark it in yellow." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "178c7aff-a995-4c8a-ae01-179436875a92", + "metadata": {}, + "outputs": [], + "source": [ + "def naive_prob_failure(row):\n", + " \"\"\"Input a row and get the probability that test fails, given that it is run.\"\"\"\n", + " row = row.values\n", + " row = row[row != 0]\n", + " return 1 - (row.mean() + 1)/2" + ] + }, + { + "cell_type": "code", + "execution_count": 99, + "id": "d415c229-8a40-4409-bcba-84a743fa7bf1", + "metadata": {}, + "outputs": [], + "source": [ + "def get_grid(x):\n", + " \"\"\"Plot the grid with not run tests in white, improb\n", + " able failed tests in yellow, other failed tests in red, and passed in green.\"\"\"\n", + " plt.figure(figsize=(10, 5))\n", + " y = x[:50].copy()\n", + " for i, row in y.iterrows():\n", + " pf = naive_prob_failure(row)\n", + " if pf <= 0.05:\n", + " row[row == -1] = 0.5\n", + " y.loc[i] = row\n", + " cmap = colors.ListedColormap(['red', 'white', 'yellow', 'green'])\n", + " boundaries = [-1.2, -0.2, 0.2, 0.7, 1.2]\n", + " norm = colors.BoundaryNorm(boundaries, cmap.N, clip=True)\n", + " sns.heatmap(y[:50], fmt=\"\", cmap=cmap, cbar=False, norm = norm)\n", + " plt.ylabel(\"Tests\")\n", + " plt.xlabel(\"Run\")\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 101, + "id": "3258601c-ae52-4fe6-a15f-08b82cb2895e", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "dashboard, job, x = get_random_grid()\n", + "get_grid(x)" + ] + }, + { + "cell_type": "markdown", + "id": "1669cb1c-ae87-43c1-aa68-e0c2f2566fca", + "metadata": {}, + "source": [ + "## Unexpected Failure Classification" + ] + }, + { + "cell_type": "markdown", + "id": "fa1efee6-fb4c-4686-9837-ebd676e06ceb", + "metadata": {}, + "source": [ + "First we will walk through the process with visualizations to motivate our methods before defining an overall function to calculate an \"unexpectedness score\"." + ] + }, + { + "cell_type": "code", + "execution_count": 102, + "id": "3a71e3f1-3a1f-4799-8b3f-5489dad8dcd2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Proportion of NA values 0.0\n" + ] + } + ], + "source": [ + "def preprocess(x):\n", + " \"\"\"Preprocess the data to make our methods work.\"\"\"\n", + " # unsure why we have NA values; safest bet to fix is to assume test didn't run\n", + " x = x.fillna(0)\n", + " print('Proportion of NA values', x.isna().to_numpy().sum()/(x.shape[0]*x.shape[1]))\n", + " # if we have all the same values, there is no real info (for our methods)\n", + " x = x[~(x.apply(np.std, axis = 1) == 0)]\n", + " return x\n", + "\n", + "\n", + "x = preprocess(x)" + ] + }, + { + "cell_type": "markdown", + "id": "f5ec74bb-0efd-435a-8b45-1a00445d7750", + "metadata": {}, + "source": [ + "Now we define a column score. We earlier defined the row score as the sample probability of a test failing. Rows correspond to tests and columns refer to time. For the column score, we take all the tests that failed at that time, and take the sums of the entropies of the failed scores. Entropy is just the negative of the log of the row score. It just makes probabilities work in a more linear fashion. Usually if you accumulate multiple probabilities you would multiply them together but that would make a lot of numbers really small and hard to understand so we apply the log. There are reasons for this being called \"entropy\" that could be read [here](https://en.wikipedia.org/wiki/Information_theory). So if a run has 3 tests fail where two tests had a $\\frac25$ probability of failing and a one test had a $\\frac13$ probability of failing our column score will be $-2\\log\\frac25 - \\log\\frac13$." + ] + }, + { + "cell_type": "code", + "execution_count": 103, + "id": "968ce931-73a7-4f0b-873d-33e0e41a4781", + "metadata": {}, + "outputs": [], + "source": [ + "def column_scores(x):\n", + " # defined as the sum of the log of probability to fail of the failed tests\n", + " row_scores = x.apply(naive_prob_failure, axis = 1).values\n", + " return x.apply(lambda x: column_score(x, row_scores))\n", + "\n", + "\n", + "def column_score(column, row_scores):\n", + " return np.sum(-np.log(row_scores[column == -1]))" + ] + }, + { + "cell_type": "markdown", + "id": "27bb49d0-01f7-464e-bef6-44c28e72efb9", + "metadata": {}, + "source": [ + "Now let's visualize what our column scores look like next to the grid itself." + ] + }, + { + "cell_type": "code", + "execution_count": 104, + "id": "46df01ac-793a-43bb-a4d2-e46136720cbb", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAl4AAAFICAYAAACBRvCdAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAq/klEQVR4nO3debhsVX3n//eHUQGZRHEARUGaNipXvSJOQSUaYvyJnZAYpwYVbTVRg3Ycop3LNTEBtDWaRPt3VRQjRtGA0gYQnKOReZJJQEQFEZwQCU7At//Y+0hx7qk6dc+9e1eduu/X89Rzdu29v7VWVe2qs2rttdc3VYUkSZK6t8mkKyBJkrSxsOElSZLUExtekiRJPbHhJUmS1BMbXpIkST2x4SVJktST3hteSe6S5MwkFyS5OMnqvusgSZI0Cel7Hq8kAbauqpuTbA58BXhVVZ3ea0UkSZJ6tlnfBVbT0ru5vbt5e1us9ecsr2PK6iy6T63y5ZQkqUND/xlPZIxXkk2TnA/cAJxWVWdMoh6SJEl9mkjDq6puq6oVwC7APkkeMol6SJIk9WmiVzVW1Y3AF4AD5m9L8pIkZyc5e82aNb3XTZIkaUPrfYxXknsAv66qG5PcFXgKcOT8/apqDTDX4nJQkiRJWvYmcVXjw4BjgE1petyOq6o3LxK2tEpmgbFtPT/fBesw30J1WmrchjS/DuOWN07cNLw3G9JSXyutny5f96Ueo+N8djekaf0e6Kr8YZbLZ265fPf1Xc9xy1s+/xuHVrT3htcS2fAaN25DsuE1vkn/c9pY2fCa3u+BrsofZrl85pbLd58Nr+HWs+HlzPWSJEk9seElSZLUk0nN47V9kk8kuSzJpUkeM4l6SJIk9an3qxpb7wROqaqDkmwBbDWhekiSJPVmEtNJbAf8NnAIQFX9CvhVJ2UdvsDKeSl1xk2fMz8Vz9hpd8YY5LdQmp+lXvSwQVMGLXWA4ry4Bet0+AJhCzzUOK/7gq9fh2mRxnm/xnkfYLx6jvv8Nsp0UV0Oot1Ax/+yN+nnM+nyN7Tl8nz6rue45U3D67eedZjEqcYHAD8APpDkvCTvS7L1BOohSZLUq0k0vDYDHgG8p6oeDvwn8Pr5OzlzvSRJmjWTGON1DXDNQGLsT7BAw8uZ6yVJ0qzpvcerqr4PfDfJf2lX7Q9c0nc9JEmS+jaRmeuTrADeB2wBXAW8oKp+MnT/1VmrkvMHCY87mHmpllrehhw8PU7cOHXYkOUtdZB335Z6EcVSH38Sr8HMDZyXpOVr6D+BiUwnUVXnAysnUbYkSdKkOHO9JElST2x4SZIk9WRSKYMOS3JxkouS/EuSu0yiHpIkSX3qveGV5L7AK4GVVfUQYFPgT/quhyRJUt96v6qxbXidDuwN3AR8EnhXVZ06ImyJ+XMWuKhgGtINSJKkWTb0qsZJzON1LfA24DvAdcBPF2l0SZIkzYRJnGrcATiQJmfjfYCtkzxvgf1MGSRJkmbKJE41/hFwQFW9qL3/34F9q+rlI8I81ShJkpaL6TnVSHOKcd8kWyUJTcqgSydQD0mSpF71PnN9VZ2R5BPAucCtwHnckQx7QUtO47IBH2up6vAF6rDAurXiNmDKoL7Nf84LPd+lvi7StFtqGq1p/UxMOh3WtL4u0iij/odPKmXQKmDVJMqWJEmaFGeulyRJ6okNL0mSpJ501vBKcnSSG5JcNLBuxySnJbmi/btDV+VLkiRNm86mk0jy28DNwIfa1EAkOQr4cVUdkeT1wA5V9boxHm75zgHhlBaSJG1s+p9Ooqq+DPx43uoDgWPa5WOAZ3ZVviRJ0rTpe4zXzlV1Xbv8fWDnnsuXJEmamIkNrq/mHOfQc26mDJIkSbOm73m8rk9y76q6Lsm9gRuG7VhVa7hjYlUHRUmSpGWv7x6vE4GD2+WDgU/1XL4kSdLEdHlV478ATwR2Aq6nman+k8BxwP2AbwN/XFXzB+Cv/Virs9H1eC2cbuDOF0lkdT91kTS+paYMmlaTThkkLUe1qoZ+UDo71VhVzx6yaf+uypQkSZpmzlwvSZLUExtekiRJPek7ZdBbk1yW5MIkJyTZvqvyJUmSpk2X00l8EPhH4EMD604D3lBVtyY5EngDME7KoJmy9MGq8wftdjvItQ6fV9rhC+0l8LWaRfPfU1j6++oAdc3ZkMfVLBn3dVnr4pUF0vJ1/Xqu7/d9rymDqurUqrq1vXs6sEtX5UuSJE2bSY7xeiFw8gTLlyRJ6tVEGl5J3gjcChw7Yp/fpAzi7P7qJkmS1JXeG15JDgGeDjy3RszeWlVrqmplVa1kZW/VkyRJ6kyvuRqTHAC8Ftivqm7ps2xJkqRJ66zhNZgyKMk1NCmD3gBsCZyW5kqE06vqpV3VYVp5RZO0cfEzv2F5ZWD3pvY1XuAqxuWm75RB7++qPEmSpGnnzPWSJEk9seElSZLUk15TBg1se02SSrJTV+VLkiRNmy57vD4IHDB/ZZJdgacC3+mw7KlWq+pOt6lVdefbuGGr7nzbKCzxtdIUm/+ersf7umw+88vFBnxverdc6t53Pcctb6H9+n4917O8XlMGtd5BM6XElB5tkiRJ3eh1jFeSA4Frq+qCPsuVJEmaBr01vJJsBfwl8Fdj7m/KIEmSNFP67PHaHXgAcEGSq4FdgHOT3GuhnU0ZJEmSZk1vKYOq6uvAPefut42vlVX1w77qIEmSNEkZkad6/R54IGUQcD2wqqreP7D9asZveDkQf9YslPZhWq/ukSRp3QzNbdRZw2sDWxaV1Dqw4SVJml1DG17OXC9JktST3meuT/KKJJcluTjJUV2VL0mSNG16nbk+yZOAA4G9q+q3gLd1WL4kSdJU6XSMV5LdgE9X1UPa+8cBa6rqs+v0OKszU4N/5qcMyeq1TwWPk1ZkobgNaZx6quFrNXsW+gyO874u9bO7UHqtrF70oTo3jcf2Ut+babBc6t53Pcctb7n8b6xVNTVjvPYEnpDkjCRfSvKonsuXJEmamN7m8Roob0dgX+BRwHFJHljL5NJKSZKk9dF3j9c1wPHVOBO4nWaer7WYMkiSJM2avhtenwSeBJBkT2ALYMEJVE0ZJEmSZk1npxoHZ65Pcg2wCjgaOLqdYuJXwMGeZpQkSRsLZ66XpGlgNgdplkzNVY2SJEkbLRtekiRJPek1ZVCSFUlOT3J+e8XiPl2VL0mSNG16TRkEHAWsrqoVwF+19yVJkjYKnTW8qurLwI/nrwa2bZe3A77XVfmStKxUrX1Tc9HB/Ju0jPU9c/2fA59J8jaaRt9jey5fkiRpYvoeXP8y4LCq2hU4DHh/z+VLkiRNTN8Nr4OB49vljwNDB9cPpgxas2ZNL5WTJEnqUt+nGr8H7Ad8EXgycMWwHatqDTDX4nKwgyRJWvY6m7l+MGUQcD1NyqBvAO+kafD9Anh5VZ2z6GOtzkw1vGrVnZ9OVq89WHT+PgtZKE7SZM3aZ3ec76u+1aq112V1//VYiuVc92k0iddzfpkLlVeraugHpbMer6p69pBNj+yqTEmSpGnmzPWSJEk9seElSZLUky5TBu2a5AtJLklycZJXtet3THJakivavzt0VQdJkqRp0mWP163Aa6rqwcC+wJ8meTDweuBzVfUg4HPtfUmSpJnX5eD664Dr2uWfJbkUuC9wIM3VjgDH0Ewt8bqu6iFJkqbbuFcnrn3V8OSvsl1XvYzxSrIb8HDgDGDntlEG8H1g5z7qIEmSNGmdN7ySbAP8K/DnVXXT4LZqJhGbqTm6JEmShum04ZVkc5pG17FVNZcq6Pok92633xu4YUjsb1IGcXaXtZQkSepHl1c1hiYJ9qVV9faBTSfS5Gyk/fupheKrak1VrayqlazsqpaSJEn96bLH63HA84EnJzm/vT0NOAJ4SpIrgN9p70uSNJ4scFsulnPdl6gOX/u2lqW+LpN4PdezvC6vavwKw6u0f1flSpIkTStnrpckSeqJDS9JkqSeTCJl0FuTXJbkwiQnJNm+qzpIkiRNk0mkDDoNeEhVPQy4HHhDh3WQJEmaGr2nDKqqUwd2Ox04qKs6SJJmTw6fdA3Ww0JThi+QGmeWjPV+LfV1mcTrOb/MdSxvEimDBr0QOLmPOkiSJE3axFIGJXkjzenIY4fEOXO9JEmaKZNIGUSSQ4CnA89t8zWuxZnrJUnSrOlsjNewlEFJDgBeC+xXVbd0Vb4kSdK06azhxR0pg76e5Px23V8C7wK2BE5r2macXlUv7bAekiRJU2ESKYNO6qpMSZKkaebM9ZIkST2x4SVJktST3lMGDWx/TZJKslNXdZAkSZomXQ6un0sZdG6SuwHnJDmtqi5JsivwVOA7HZYvSZI0VXpPGQRcAryDZkqJT3VVviRJWppatfa6zHhqo770njIoyYHAtVV1QR9lS5IkTYteUwbRnH78S+CvxogzZZAkSZopfacM2h14AHBBkquBXYBzk9xrfqwpgyRJ0qzpNWVQVX0duOfAPlcDK6vqh13VQ5IkaVr0njKoqpy5XpKkKeZA+u5MImXQ4D67dVW+JEnStHHmekmSpJ7Y8JIkSerJRFIGJXlFksva9Ud1VQdJkqRp0nvKIGBn4EBg76r6ZZJ7jnwUSZKkGTGJlEEvBo6oql+2227oqg6SJEnTpPeUQcCewBOSnJHkS0ke1UcdJEmSJq3XlEFVdRNNL9uOwL7AXwDHtZOtzo8zZZAkSZopfacMArgGOL4aZwK3AzvNjzVlkCRJmjVdXtW4Vsqg1ieBJ7X77AlsAZgySJIkzbx1GlyfZAdg16q6cIzdF0wZBBwNHJ3kIuBXwMFVVetSD0mSpOVo0YZXki8Cz2j3PQe4IclXq+rVo+IWSRn0vHWspyRJ0rI3zqnG7dpB8X8AfKiqHg38TrfVkiRJmj3jNLw2S3Jv4I+BT3dcH0mSpJk1TsNrNfAZ4MqqOivJA4ErFgsaljIoyYokpyc5v50uYp/1ewqSJEnLwziD66+rqofN3amqq5K8fVRAa1jKoKOA1VV1cpKntfefuIS6S5IkLSvj9Hj9w5jr7qSqrquqc9vlnwFzKYMK2LbdbTvge+NVVZIkaXkb2uOV5DHAY4F7JBm8gnFbYNN1KWReyqA/Bz6T5G00Db/HrluVJUmSlqdRPV5bANvQNM7uNnC7CTho3AIWSBn0MuCwqtoVOIxmktWF4kwZJEmSZsrQHq+q+hLwpSQfrKpvAyTZBNimbUAtakjKoIOBV7XLHwfeN6T8NcAagKyOE6xKkqRlb5wxXn+XZNskWwMXAZck+YvFgkakDPoesF+7/GTGuEJSkiRpFoxzVeODq+qmJM8FTgZeTzOD/VsXiRuWMujFwDuTbAb8AnjJUiouSZK03IzT8Nq8PWX4TOAfq+rXyeKn/hZJGfTI8asoSZI0G8Y51fj/A1cDWwNfTnJ/mgH2kiRJWgeL9nhV1buAdw2s+naSJ3VXJUmSpNm0aI9Xkp2TvD/Jye39B9NcmbhY3F2SnJnkgjZl0Op2/QOSnJHkyiQfS7LFej8LSZKkZWCcU40fpMnVeJ/2/uU0k6Au5pfAk6tqb2AFcECSfYEjgXdU1R7AT4AXrVuVJUmSlqehDa/2qkOAnarqOOB2gKq6FbhtsQeuxs3t3c3bW9FMIfGJdv0xNIP2JUmSZt6oHq8z27//meTuNI0m2l6rn47z4Ek2baeSuAE4DfgmcGPbeAO4hiZ/oyRJ0swbNbh+biqIVwMnArsn+SpwD8ZMGVRVtwErkmwPnADsNW7FkryEuTm+ng6sHDdSkiRpOo1qeA0mxz4BOImmMfZL4HeAC8ctpKpuTPIF4DHA9kk2a3u9dgGuHRJjyiBJkjRTRp1q3JQmSfbdaObw2qxdt1W7bqQk92h7ukhyV+ApwKXAF7ijx+xg4FNLrLskSdKyMqrH67qqevN6PPa9gWOSbErTwDuuqj6d5BLgo0n+BjiPJp+jJEnSzBtnjNeSVNWFwMMXWH8VsM/6PLYkSdJyNOpU4/691UKSJGkjMLThVVU/Xp8HHjFz/bFJvpHkoiRHtwm4JUmSZt44M9cv1bCZ64+lmVbiocBdgUM7rIMkSdLUWDRJ9lJVVQFrzVxfVSfN7ZPkTJopJSRJkmZelz1ea81cX1VnDGzbHHg+cEqXdZAkSZoWnTa8quq2qlpB06u1T5KHDGx+N/Dlqvr3LusgSZI0LTpteM2pqhtpJk49ACDJKprUQ68eFpPkJUnOTnI2Z/dRS0mSpG511vAaMnP9ZUkOBX4XeHZV3T4svqrWVNXKqlppnkZJkjQLOhtcz/CZ628Fvg18LQnA8es5Q74kSdKy0OVVjcNmru+ysSdJkjS1ehnjJUmSJBtekiRJvelycP2CKYMGtr8ryc3D4iVJkmZNl+Ot5lIG3dxOlvqVJCdX1elJVgI7dFi2JEnS1Omsx6saa6UMaq9yfCvw2q7KliRJmkaTSBn0Z8CJVXVdl2VLkiRNm06ndqiq24AV7USqJyT5beCPgCd2Wa4kSdI06jtl0JOAPYArk1wNbJXkyoViTBkkSZJmTd8pg86pqntV1W5VtRtwS1XtsVC8KYMkSdKs6T1lUIflSZIkTbXeUwbN22ebrsqXJEmaNs5cL0mS1BMbXpIkST3pPWVQGm9JcnmSS5O8sqs6SJIkTZPeUwYB/xXYFdirqm5Pcs8O6yBJkjQ1uhxcX8BaKYOAlwHPqarb2/1u6KoOkiRJ02QSKYN2B57VTo56cpIHdVkHSZKkadFpw6uqbquqFcAuwD5JHgJsCfyiqlYC7wWO7rIOkiRJ06LvlEEHANcAx7ebTgAetlCMKYMkSdKs6Ttl0GXAJ2lyNgLsB1y+ULwpgyRJ0qzpPWVQkq8AxyY5jGbw/aEd1kGSJK2jWrX2umZSKK2v3lMGtacdf7+rciVJkqaVM9dLkiT1xIaXJElSTyaRMmj/JOcmOT/JV5Ls0VUdJEmSpkmXPV5zKYP2BlYAByTZF3gP8Nx2fq+PAG/qsA6SJElTYxIpgwrYtl2/HfC9ruogSZLWnVcwDre+r02X00nQTiVxDrAH8E9VdUaSQ4GTkvwcuAnYt8s6SJIkTYtJpAw6DHhaVe0CfAB4+0KxzlwvSZJmTd8pg34P2LtNlg3wMeCxQ2KcuV6SJM2UvlMGXQpsl2TPdre5dZIkSTNvEimDXgz8a5LbgZ8AL+ywDpIkTY2NcdB6l+mHluPrOYmUQScAJ3RVriRJ0rRy5npJkqSe2PCSJEnqSecNrySbJjkvyafb+w9IckaSK5N8LMkWXddBkiRpGvTR4/Uq7nzl4pHAO6pqD5rB9S/qoQ6SJEkT1/XM9bsAvw+8BXh1kgBPBp7T7nIMcDhN/kZJkjRjluOVh13qusfr74HXAre39+8O3FhVt7b3rwHu23EdJEmSpkKXE6g+Hbihqs5ZYrwpgyRJ0kzp8lTj44BnJHkacBdgW+CdwPZJNmt7vXYBrl0ouKrWAGsAsjrVYT0lSZJ60VmPV1W9oap2qardgD8BPl9Vz6XJ2XhQu9vBwKe6qoMkSdI0mcQ8Xq+jGWh/Jc2Yr/dPoA6SJEm96/SqxjlV9UXgi+3yVcA+fZQrSZI0TZy5XpIkqSc2vCRJknoyiZRBxyb5RpKLkhydZPOu6yBJkjQNJpEy6FhgL+ChwF2BQ3uogyRJ0sR12vAaSBn0vrl1VXVStYAzaebykiRJmnl9pwz6jfYU4/OBUzqugyRJ0lSYZMqgdwNfrqp/HxJvyiBJkjRTuuzxmksZdDXwUeDJST4MkGQVcA/g1cOCq2pNVa2sqpWs7LCWkiRJPek7ZdDzkhwK/C7w7Kpa6xSkJEnSrOpl5vp5/g/wbeBrSQCOr6o3T6AekiRpGatVa6/L6v7rsS4mkTJoEo09SZKkiXPmekmSpJ7Y8JIkSepJ7ymDBta/K8nNXZcvSZI0LfoYbzWXMmjbuRVJVgI79FC2JEmaUdM+kH4hvacMSrIp8FaaGe0lSZI2GpNIGfRnwIlVdV3HZUuSJE2VXlMGJbkP8EfAP4wRb8ogSZI0U7oc4zWXMuhpwF1oxnhdDPwSuLKdPHWrJFdW1R7zg6tqDbAGIKtTHdZTkiSpF32nDNqhqu5VVbu1629ZqNElSZI0i5zHS5IkqSe9pwyat36bPsqXJEmaBvZ4SZIk9cSGlyRJUk96TxmUxluSXJ7k0iSv7LoOkiRJ02ASKYMOAXYF9qqq25Pcs4c6SJIkTVzvKYOAlwFvrqrbAarqhi7rIEmSNC0mkTJod+BZ7az0Jyd5UMd1kCRJmgq9pgxqbQn8oqpWAu8Fjh4Sb8ogSZI0U7rs8ZpLGXQ18FHgyUk+DFwDHN/ucwLwsIWCq2pNVa2sqpWs7LCWkiRJPek7ZdDzgE8CT2p32w+4vKs6SJIkTZNeZq6f5wjg2CSHATcDh06gDpIkSb3rPWVQVd1Ic6WjJEnSRsWZ6yVJknoyiZnr909ybpLzk3wlyR5d10GSJGka9NHjNTdz/Zz3AM+tqhXAR4A39VAHSZKkiet0jNfAzPVvAV7dri7uSB+0HfC9LusgSZKmW1aPu1+6rUgPuh5c//c0M9ffbWDdocBJSX4O3ATs23EdJEmSpsIkZq4/DHhaVe0CfAB4e1d1kCRJmiZd9njNzVz/NOAuwLZJ/g3Yq6rOaPf5GHDKQsFJXgK8BICng7PXS5Kk5a7XmeuBA4HtkuzZ7vYU7jzwfjDelEGSJGmm9DpzfVXdmuTFwL8muR34CfDCPusgSZI0KZOYuf4EmuTYkiRJGxVnrpckSeqJDS9JkqSedD2B6tXAz4DbgFuramWSHWmuZtwNuBr446r6SZf1kCRJmgZ99Hg9qapWVNXctYmvBz5XVQ8CPtfelyRJmnmTONV4IHBMu3wM8MwJ1EGSJKl3XTe8Cjg1yTnthKgAO1fVde3y94GdO66DJEnSVOh6OonHV9W1Se4JnJbkssGNVVVJquM6SJIkTYVOe7yq6tr27w00c3ftA1yf5N4A7d8bFopN8pIkZyc5m7O7rKUkSVI/ukySvXWSu80tA08FLgJOBA5udzsY+NRC8aYMkiRJs6bLU407AyckmSvnI1V1SpKzgOOSvAj4NvDHHdZBkiRpanTW8Kqqq4C9F1j/I2D/rsqVJEmaVs5cL0mS1BMbXpIkST2ZRMqgtwL/H/Ar4JvAC6rqxi7rIUmSNA0mkTLoNOAhVfUw4HLgDT3UQZIkaeK6nkB1LVV16sDd04GD+q6DxlOr7jy3bVZnQjWZfr5Ws2f+ewq+r9NiOb83y6Xufddz3PIW2m+cuA1pfb/vJ5EyaNALgZM7roMkSdJU6D1lUFV9GSDJG4FbgWM7roMkSdJUmETKIJIcAjwdeG5VLdhvaMogSZI0a3pPGZTkAOC1wDOq6pZh8aYMkiRJs2YSKYOuBLakOfUIcHpVvbTDekiSJE2FSaQM2qOrMiVJkqaZM9dLkiT1xIaXJElST2x4SZIk9cSGlyRJUl+qatncgJfMctxyqqtxxvURt5zqapxx0xy3nOo683FLfQMncQPOnuW45VRX44zrI2451dU446Y5bjnVddbjPNUoSZLUExtekiRJPVluDa81Mx43iTKNM26a4yZRpnHGzWLcJMo0bgFpz1NKkiSpY8utx0uSJGnZsuElSZLUExtekiRJPdls0hUYJclewIHAfdtV1wInVtWli8TtA1RVnZXkwcABwGVVddKImEcDl1bVTUnuCrweeARwCfC3VfXTEbEPBP4A2BW4Dbgc+EhV3TTmU91oJLlnVd0w6XpoedgYjpckd6+qH026HloePF6Wv6nt8UryOuCjQIAz21uAf0ny+hFxq4B3Ae9J8nfAPwJbA69P8sYRRR4N3NIuvxPYDjiyXfeBEeW9Evg/wF2ARwFb0jTATk/yxMWe53KX5OQR23acd7s7cGaSHZLsOCLu3CRvSrL7OtZlsyT/I8kpSS5sbycneWmSzUfEbZXktUn+IsldkhyS5MQkRyXZZkTcnyXZqV3eI8mXk9yY5IwkDx0Rt0mSFyb5tyQXtM/3o4sdL0k2bZ/fXyd53LxtbxoR97CB5c3b1/bEJH+bZKsRcQ9McnSSv0myTZL3JrkoyceT7DaqriMec5qOl+2SHJHksiQ/TvKjJJe267YfEXevJO9J8k9J7p7k8CRfT3JcknsvUuYRA8fMyiRXAWck+XaS/UbEbZPkzUkuTvLTJD9IcnqSQxYpb9skf5fkn5M8Z962d4+IO2Bgebsk728/Tx9JsvOIuJVJvpDkw0l2TXJaW9+zkjx8VF1HPOY6XTmW5PIx9jk+yfNGfb6HxPV6zPR9vGxooz638/bbbGB5m/a5jhU75PH2Wsf9Xz7GPg9bbJ+xLXUG3K5vNL1Gmy+wfgvgihFxXwc2BbYCbgK2bdffFbhwRNylA8vnztt2/mLltctbAV9sl+8HnLfIc9wW+Dvgn4HnzNv27hFxBwwsbwe8H7gQ+Aiw84i4lcAXgA/TNA5PA34KnAU8fETcI4bcHglcNyLuduBb826/bv9eNSLuW8DbgO/QNLgPA+4zxjHzL8B7gH2BXdrbvu26j42IOw7438C7gc/RNNafALwV+OcRcRcPLP8b8N/a5ScCXx0R9wHgcODxwN8DbwaeAnwWeMWIuPe17/GfA+cAbx92zM6LO3dg+X8DHwT2A94BfGhE3JeBl9H0/l4EvKY9bl4EfH4GjpfPAK8D7jWw7l7tulNHxJ0CvKJ9XS5s99+1XfepRcr8+sDyF4BHtct7MmIWbOBTwCHtMf1q4H8BDwKOoemRHxb3r8ARwDOBE9v7W67jMfM+4G+A+7ev7SdHxJ0J/B7wbOC7wEHt+v2Br42I23HI7e7ANSPifkbzPX9Tu/wzmrMOPwNuGhF3LfAJ4Mc0n///BmwxbcdM38dLG/tQ4PT2/VsD7DD4/o6Ie9PA8oNp/od/C7gaePSIuEOAH7X7/x5wFc338HeBZy/2ngx5zO+M2PbqebfXAD+cuz8i7jbgCuCvgQcvpV6/eaz1Ce7yBlwG3H+B9fcHvjEi7ryFltv754+I+zjwgnb5A8DKdnlP4KwRcV/nji+yHQY/DMBFizzH5fKleBvw+faDP//28xFxr6H5wnnowLpvjfHeDz6/J9A0iL7fljc0NxZw+RK3nd/+TVtOBu6Paqx/Y2D5rHnbRsVdOO/+6e3fLRn4ATAqjmaYwBrg+DbuvBFxg5+J82l/0Izx/AbjvjNs2zI+XkZ9j4z7HTP/dTl/kbpeCmw2+L4PbPv6iLgL5t0/q/27Cc0wipHH9sD9NwJfpWnQjPsdM/8xhj7H9TxmruLOje65+78aEfcu4EMM/OAc85g5r/27LfB84CTgBzTf/U+dlmOm7+Ol3ecrNMNztgf+J3AxsPsY7+HgMfNvwO+1y/sA/zEi7uvATsADaBrQc2XtzOjvp3cNuf0DoxvdPwM+BvwVsKq9/WRuedR7CDwEeAtwJXABTUN6t8WOt7Uea10D+rq1b/yVwMk0/2DW0HwpX8lAj88CcWcAW80dZAPrt2P0F812ND0B32wf49ftB/9LwN4j4l5F8wvmvTSNxbnG2z2ALy/yHM+fd39avxQvAh40ZNt3F3mOu9A0at8O3I0RPRcLPb+BdZu2x8QHRsSdDvzRvPd9E+BZwBnjvA/A0fO2XTAi7i3tMfNA4C9peqLuD7wA+PSIuHO448vlEYPHCXDJiLi1vjDbL4uvMroX+CqaX/R/yLyG3SLP7xyaHx6PovlFOPdjZA9GfyEul+PlVOC13Pmf9s40vRGfHRF3wcDy38zbNvR1abe/oi33yTS9nu+k6X1czeje1f8AHt8uPwP4zMC2Uf/wLx38PLTrDqH5Z/rtEXHXcEdvwFW0P0YWe47A14Cntp/DbwPPbNfvx+gemiuA+y3xmHkkTUP/lTSf96UeM3cHXsro3txej5kNdLwcOO7xMr+u7f0nte/Pvgu9bgu9pqzd6XHeiLjzB5a/tw6vzc+AlwAHL3D74Yi4+9F8xxzJHW2FdT5maBqUb28/K0Mblgs+1rrs3Pet/RDtS/MP4w/b5U0XidlyyPqdGPglPSJ+W2Dv9sM89LTdvJjfAg4C9lrH57dcvhQPAv7LkG3PHPO5PoOmYfT9Mfb96BKPl91ofsncQNNtfXm7/DHgASPi3gdss8D63YGvLFLmITQN9R+2XwSXAH8LbDci5sk0p8WuoPlF/+h2/T2Ao0bEfZgFfnQAhwK/HhH3QZpf8nO3ndv19wI+NyJuf+Ab7XH6eJoe2Sva13To+76MjpcdaL58L6P5xfvj9rkeCew4Iu7NQ46XPYBPjFHuE9tj8jyaX/sn0fwDWWtoxUDMw2h6rH9C0yOx58Ax88oRcUcBv7PA+gMY3VhfNe92j4FjZtTp6b1pTsedDOxF01C4keY77bEj4v6UIT9wGXH6fWCfTWgaXv/OvH/eQ/Yf+aN4jGPm0vZ46fyYGThezh04Xv7HIsfL3ks5Xtp9LmDe91d7/F0B/GhE3I00Z27+L03v4VYD24ae/Wlj5sZjf55mOMTj2uPuMyPiPj/smGK8Xs8DaX60HsR4Da/zhqwPsN+6HEfOXD9BSY6iGRfw2XnrDwD+oaoeNCRu1bxV766qHyS5F80/7v8+JG5vmi/i22lOS76M5tfBtcCLq+o/RtR1L5qrS8+oqpsH61pVp4wTR3M6Yfequmhd4taxvEcDRdNzuRfwGJpepKFXtLZxC10J+w3gpBrxIZkX91tt3KVjlPcY4NZahytvhzzOh4a93x3FfRp4RlXdvg4xj6f5dXhRVZ26DnFPoPlRcOY6xo1VXnusXFZVP01zkcHclcwXM+JK5qzfFdCDseta5mBdXzdOmWku/jmhqr47rE5TErclTc/096rqs+2FAI+ladSsqapfD4nbAviTgbjn0/QGvQ1474i4JZXXxu7Ona9i/wZjXMWeJV793sb94RLKG6znretQ3nNoGiKnz1t/P+B/VdWLh8TtN2/VuVX1s/ZijIOq6p+GxG1L0/AumsbXATQ/aL8D/HVVXTckbkfgF1V1y0Lbx5Fka5qexEdX1W8vsu9zquojSy3rTo9lw2s6JXlBVX1gGuLaL9M/pflSWgG8qqo+1W47t6oesYHjXgH82RLiVtGMYduM5sKBfYAv0gxc/0xVvWXMuEfTjA9a17illjdu3InzV9GcBvg8QFU9Y8w4aHrduoo7s6r2aZdfTHMMnEDT2/p/q+qIMeNeDnxyCXHjlncxTS/Lre2Vc/9J06u3f7v+D8aMu4VmoPbIuEmUmeSnbRnfpLn45ONV9YNh9Ztg3LE0n4etaHpOtqEZv7g/zf+pg8eM25rmvV/XuHHLeyXwdJoLT55G02t5I82p/JdX1Rc3cNyrgN/vqzz1ZF26x7z1d2PEVRl9x9F0b2/TLu8GnE3TGILR5+4nEbeUK1qXS9x5NKcbn0jTE/RE4Lp2eb9pihtYPos7TlNtzegBwX3HLfVK5iXFTaLM9j3chKYR+n6aU0Cn0PR0322K4i5s/24GXM8dV4ovdgFI33FLuop9ucS1+2xHc9HXZTSnUn9E8yP4CGD7aYlb5DmcPM1xUz2B6qxLcuGwTTQDNqcijmYc2s0AVXV1mvmmPpHk/m3stMTdWlW3Abck+Wa1XepV9fMko06NLZe4R9JczPFG4C+q6vwkP6+qL42ImUTcJkl2oPkHnGp7PKrqP5PcOkVxFw309F6QZGVVnZ1kT5qLazZ03CTKrGpOC58KnJpmPru5K5vfRjPmZxriNmlPG25N01DYjuaf8JbA0Dn4JhAHTWPttnbfbQCq6jsZMVfgMos7jqZX+4lV9X1o5iGjaTwfR9Oo7iPukFFxSRY880HzP2LFsCfXd9xCbHhN1s7A79IMgBwUmqtSpiXu+iQrqup8gKq6OcnTaSadHTpR6ATifpVkq2rO+T/yN08u2Y5mXNuyjmv/ob0jycfbv9czxme47ziaf2Ln0BxXleTeVXVdmskqRzWc+447FHhnmslnfwh8Lcl3aaZaObSDuEmUeafnX83YpROBEzNi8twJxL2fpsdjU5qG/sfTTBa6L81E2tMS9z7grCRn0ExdciRAknvQNNyWexw00yMcObiibRAdmeSFPcYdkeQFI+LOopl1YKHP+PZTFLe2pXSredswN5oP/+OHbPvIFMXtwsCEgfO2PW6K4pZ0RetyiVtg/99nkckQpyFuIH4rRlxdOqk4lnAl8/rE9Vkm7dVsS3jteo1rY+9DO/EtzT+yg4B9pjBuqVexL5e4pU6Z0Xfckqat6TtuoZuD6yVJEgDtafvX00y3cM929fU0PZdHVNX8MyaTijuIZgznNxbY9syq+uQ0xC34WDa8JEnSYjJFV9sv5zgbXpIkaVFJvlNV9zNu/eIcXC9JkoDlc7X9colbiA0vSZI0Z7lcbb9c4tZiw0uSJM35NM0E1ufP35Dki8atc9xaHOMlSZLUk00mXQFJkqSNhQ0vSZKknjjGS9JMSnIbTbLgzYBvAc+vqhsnWilJGz17vCTNqp9X1YqqeghNfro/nXSFJMmGl6SNwdeA+0JzBVKSle3yTkmubpcPSXJ8klOSXJHkqMlVV9KssuElaaYl2RTYnyb322JWAM8CHgo8K8muHVZN0kbIhpekWXXXJOcD36eZ/PC0MWI+V1U/rapfAJcA9++wfpI2Qja8JM2qn1fVCprGU7hjjNet3PHdd5d5Mb8cWL4NL0CStIHZ8JI006rqFuCVwGuSbAZcDTyy3XzQpOolaeNkw0vSzKuq84ALgWcDbwNeluQ8YKeJVkzSRseUQZIkST2xx0uSJKknNrwkSZJ6YsNLkiSpJza8JEmSemLDS5IkqSc2vCRJknpiw0uSJKknNrwkSZJ68v8A0BXDZYZsifYAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "get_grid(x)" + ] + }, + { + "cell_type": "code", + "execution_count": 105, + "id": "e6a9cb65-06a6-4e46-89f5-c2a39df5f2ba", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "col_scores = column_scores(x)\n", + "\n", + "plt.figure(figsize=(10, 5))\n", + "plt.bar(x = x.columns, height = col_scores, color = 'r')\n", + "plt.ylabel(\"Score\")\n", + "plt.xlabel(\"Days\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "84add652-4199-4483-884a-3ad3fa767df3", + "metadata": {}, + "source": [ + "Interestingly, the one flake we think we see at around day 13 has a score that is not as large as serveral of the other days. It is important to keep in mind that we are only seeing the first 50 tests that had a failure for visibility purposes, and there are hundreds more that extend theoretically very far below this graph." + ] + }, + { + "cell_type": "markdown", + "id": "ea26bbe7-c547-4d1a-93c2-a4f6a24ded5d", + "metadata": {}, + "source": [ + "Now that we have these scores, we need to decide what a high score would be. We do this by performing a monte carlo simulation to get an approximate idea of the distribution. With every test there is a porbability associated with it, and a score. To generate a random column we simply add $-\\log p$ to the score with a probability of $p$. We do this for every test and return the resulting total score." + ] + }, + { + "cell_type": "code", + "execution_count": 106, + "id": "15aa17f3-79f5-42fc-8481-121df72cbada", + "metadata": {}, + "outputs": [], + "source": [ + "def random_trial(row_scores):\n", + " row_scores = row_scores[row_scores != 0]\n", + " scores_scores = -np.log(row_scores)\n", + " tot = 0\n", + " for a, b in zip(row_scores, scores_scores):\n", + " tot += b * np.random.binomial(1, p = a)\n", + " return tot" + ] + }, + { + "cell_type": "code", + "execution_count": 107, + "id": "d88192e6-2de7-4995-aa94-5f9b3faa1f2f", + "metadata": {}, + "outputs": [], + "source": [ + "# this is a large number of simulations and can be adjusted later\n", + "n_sims = 10000\n", + "\n", + "row_scores = x.apply(naive_prob_failure, axis = 1).values\n", + "out = [random_trial(row_scores) for i in range(n_sims)]" + ] + }, + { + "cell_type": "code", + "execution_count": 109, + "id": "109a3992-19db-437f-9fe4-67721993a655", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 109, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "sns.histplot(out)" + ] + }, + { + "cell_type": "markdown", + "id": "52fda8ba-d6cd-4447-9b3b-3b74fd8d0a08", + "metadata": {}, + "source": [ + "We can see our distribution is fairly smooth, which happens when we have enough tests that have any probability of failing. We will also output the true distribution of scores to compare." + ] + }, + { + "cell_type": "code", + "execution_count": 110, + "id": "de14103d-3f09-47a4-9eb5-d096064432cb", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 110, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "sns.histplot(column_scores(x), stat = 'probability', color = 'r', bins = 20)" + ] + }, + { + "cell_type": "markdown", + "id": "5ce9840c-c457-4510-a932-0f2843157ca2", + "metadata": {}, + "source": [ + "We see these look nothing alike. Randomly running simulations does not accurately imitate what the testgrid data looks like, but rather exposes where the unexpectedness is too high to have been a result of a couple random failures." + ] + }, + { + "cell_type": "markdown", + "id": "e9cf953f-e2fb-4954-8e0b-7d7985b326d0", + "metadata": {}, + "source": [ + "We classify a couple levels of significance: 10%, 5%, and 1%. We see if the true scores are in the top x% of the simulated distribution." + ] + }, + { + "cell_type": "code", + "execution_count": 111, + "id": "ceaab32f-20c7-4072-97af-a5b48c6c27fe", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.05 significance: 8.050703381470303\n", + "0.01 significance: 9.933434628904084\n", + "0.001 significance: 13.616500113152597\n" + ] + } + ], + "source": [ + "out = sorted(out)\n", + "\n", + "n = len(out)\n", + "\n", + "idx1 = int(0.90*n)\n", + "idx2 = int(0.95*n)\n", + "idx3 = int(0.99*n)\n", + "\n", + "print(f'0.05 significance: {out[idx1]}')\n", + "print(f'0.01 significance: {out[idx2]}')\n", + "print(f'0.001 significance: {out[idx3]}')" + ] + }, + { + "cell_type": "markdown", + "id": "2d5bd073-891f-40e2-b0e6-79010dd94e6c", + "metadata": {}, + "source": [ + "We visualize these cutoffs below." + ] + }, + { + "cell_type": "code", + "execution_count": 121, + "id": "6540ff59-806a-4c40-8bbf-3e507e401be1", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "col_scores = column_scores(x)\n", + "\n", + "plt.figure(figsize=(10, 5))\n", + "plt.bar(x = x.columns, height = col_scores, color = 'b')\n", + "plt.ylabel(\"Score\")\n", + "plt.xlabel(\"Days\")\n", + "x1 = 0\n", + "x2 = len(col_scores)\n", + "\n", + "plt.plot([x1, x2], [out[idx1],out[idx1]], color='g', linestyle='-', linewidth=2)\n", + "plt.plot([x1, x2], [out[idx2],out[idx2]], color='y', linestyle='-', linewidth=2)\n", + "plt.plot([x1, x2], [out[idx3],out[idx3]], color='r', linestyle='-', linewidth=2)\n", + "\n", + "green_patch = mpatches.Patch(color='green', label='5% significnace')\n", + "yellow_patch = mpatches.Patch(color='yellow', label='1% significance')\n", + "red_patch = mpatches.Patch(color='red', label='0.1% significance')\n", + "\n", + "plt.legend(handles=[green_patch, yellow_patch, red_patch])\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "d139e386-cd02-4e34-bb83-eb2453bca3c6", + "metadata": {}, + "source": [ + "In this case the scores were so anomolous that the significance levels didn't end up making a big difference." + ] + }, + { + "cell_type": "markdown", + "id": "d1317863-f152-4564-8ce5-75a3bfdc8305", + "metadata": {}, + "source": [ + "We define the final score as being the percentile of where our actual data lies on the simulated distribution. Thus, the highest, most anomolous score is 1 (being greater than any simulated score), and the lowest is 0. Below we define the main function that will assign a probability to every column of testgrid data." + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "id": "2c9bae40-64d0-48c5-b77b-22c519a2a247", + "metadata": {}, + "outputs": [], + "source": [ + "def score_grid(grid):\n", + " grid = preprocess(grid)\n", + " # get col_scores\n", + " col_scores = column_scores(grid)\n", + " n_sims = 1000\n", + " row_scores = grid.apply(naive_prob_failure, axis = 1).values\n", + " out = sorted([random_trial(row_scores) for i in range(n_sims)])\n", + " ret = []\n", + " for col_score in col_scores:\n", + " ret_val = bisect.bisect_left(out, col_score)\n", + " ret.append(ret_val/1000)\n", + " return ret" + ] + }, + { + "cell_type": "markdown", + "id": "d2041229-11a9-46da-a56f-44d4018fe513", + "metadata": {}, + "source": [ + "## Analysis of Scores" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3bb9bb28-fe02-40a1-9c2a-0a5a62f9fe7e", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "all_grids = []\n", + "data = []\n", + "for i in all_dashboards:\n", + " for j in all_jobs[i]:\n", + " all_grids.append((i, j))\n", + "for n, (i,j) in enumerate(all_grids):\n", + " if n % 100 == 0:\n", + " print(n)\n", + " x = testgrid_data[i][j]['grid']\n", + " x = np.array(list(pd.DataFrame(x).statuses.apply(decode_run_length)))\n", + " x = pd.DataFrame(x).apply(lambda x: [normalize(y) for y in x])\n", + " for idx, val in enumerate(score_grid(x)):\n", + " data.append([i, j, idx, val])" + ] + }, + { + "cell_type": "code", + "execution_count": 80, + "id": "3a17742b-b8f4-4a79-9d2c-47201ce00e19", + "metadata": {}, + "outputs": [], + "source": [ + "scores_df = pd.DataFrame(data, columns = ['dashboard', 'job', 'column', 'score'])" + ] + }, + { + "cell_type": "code", + "execution_count": 83, + "id": "92e5ace0-7842-4e31-8551-aa48a39c2601", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
dashboardjobcolumnscore
38411\"redhat-openshift-ocp-release-4.7-informing\"release-openshift-ocp-installer-e2e-gcp-serial...611.000
41419\"redhat-openshift-ocp-release-4.7-informing\"release-openshift-origin-installer-old-rhcos-e...10.078
47293\"redhat-osde2e-stage-moa\"osde2e-stage-moa-e2e-default930.049
27374\"redhat-openshift-ocp-release-4.5-informing\"release-openshift-origin-installer-old-rhcos-e...1160.000
5784\"redhat-openshift-ocp-release-4.3-blocking\"release-openshift-ocp-installer-e2e-aws-serial...20.000
\n", + "
" + ], + "text/plain": [ + " dashboard \\\n", + "38411 \"redhat-openshift-ocp-release-4.7-informing\" \n", + "41419 \"redhat-openshift-ocp-release-4.7-informing\" \n", + "47293 \"redhat-osde2e-stage-moa\" \n", + "27374 \"redhat-openshift-ocp-release-4.5-informing\" \n", + "5784 \"redhat-openshift-ocp-release-4.3-blocking\" \n", + "\n", + " job column score \n", + "38411 release-openshift-ocp-installer-e2e-gcp-serial... 61 1.000 \n", + "41419 release-openshift-origin-installer-old-rhcos-e... 1 0.078 \n", + "47293 osde2e-stage-moa-e2e-default 93 0.049 \n", + "27374 release-openshift-origin-installer-old-rhcos-e... 116 0.000 \n", + "5784 release-openshift-ocp-installer-e2e-aws-serial... 2 0.000 " + ] + }, + "execution_count": 83, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "scores_df.sample(5)" + ] + }, + { + "cell_type": "code", + "execution_count": 93, + "id": "5c1a7f41-49e7-493f-a130-2aebd1a4eb87", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAk0AAAGwCAYAAAC0HlECAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAA9hAAAPYQGoP6dpAAArT0lEQVR4nO3de1xVdb7/8TeggJUbvHErwtt4QU3zRmRWJkdUpsmpJjWPxxwvU6GnZNJ0NGWskx3L2xjpw2nMzuOhY9kpp1EGRUwdFTVJ8u4ZE48WbrQMtqICwvr9MT/2aafiF9rsvcHX8/FYj4d7rc9e67O+EPvdum0/y7IsAQAAoEr+3m4AAACgLiA0AQAAGCA0AQAAGCA0AQAAGCA0AQAAGCA0AQAAGCA0AQAAGGjg7Qbqi4qKCuXn56tx48by8/PzdjsAAMCAZVm6cOGCoqKi5O9f9bEkQpOb5OfnKzo62tttAACAGjh9+rTuuuuuKmsITW7SuHFjSf8cdJvN5uVuAACACYfDoejoaOfneFUITW5SeUrOZrMRmgAAqGNMLq3hQnAAAAADhCYAAAADhCYAAAADhCYAAAADhCYAAAADhCYAAAADhCYAAAADhCYAAAADhCYAAAADhCYAAAADhCYAAAADhCYAAAADhCYAAAADhCYAAAADhCYAAAADDbzdAMy0j+2sM/n5VdZERkXp2OGDHuoIAIBbC6GpjjiTn6/Bc9dXWZM+JclD3QAAcOvh9BwAAIABQhMAAIABQhMAAIABQhMAAIABQhMAAIABQhMAAIABQhMAAIABQhMAAIABQhMAAIABQhMAAIABQhMAAIABQhMAAIABQhMAAIABQhMAAIABQhMAAIABQhMAAIABQhMAAIABQhMAAIABQhMAAIABQhMAAIABQhMAAIABQhMAAIABQhMAAIABQhMAAIABQhMAAIABQhMAAIABQhMAAIABQhMAAIABQhMAAIABQhMAAIABQhMAAIABQhMAAIABQhMAAIABQhMAAIABQhMAAIABQhMAAIABQhMAAIABQhMAAIABQhMAAIABQhMAAIABQhMAAIABr4amOXPmqFevXmrcuLHCwsI0ZMgQHTt2zKXmypUrSk5OVrNmzXTHHXfoiSeeUEFBgUvNqVOnlJSUpNtuu01hYWGaPHmyrl696lKzZcsWde/eXUFBQWrbtq1WrFhxTT9paWlq2bKlgoODFRcXpz179rh9nwEAQN3k1dC0detWJScna9euXcrMzFRZWZkGDBig4uJiZ82kSZP017/+VWvWrNHWrVuVn5+vxx9/3Lm8vLxcSUlJKi0t1c6dO/X+++9rxYoVmjlzprMmLy9PSUlJ6tevn3Jzc/Xiiy9q7Nix2rBhg7Pmgw8+UEpKimbNmqUvvvhCXbt2VWJios6ePeuZwQAAAD7Nz7Isy9tNVDp37pzCwsK0detWPfjggyoqKlKLFi20atUqPfnkk5Kko0ePqmPHjsrOztZ9992nv/3tb/r5z3+u/Px8hYeHS5KWLl2ql19+WefOnVNgYKBefvllrV+/XgcPHnRua9iwYSosLFRGRoYkKS4uTr169dLbb78tSaqoqFB0dLQmTpyoqVOnXtNrSUmJSkpKnK8dDoeio6NVVFQkm83m9rGxhTbV4Lnrq6xJn5IkR+F5t28bAID6yuFwKCQkxOjz26euaSoqKpIkNW3aVJKUk5OjsrIyJSQkOGs6dOigu+++W9nZ2ZKk7OxsdenSxRmYJCkxMVEOh0OHDh1y1vxwHZU1lesoLS1VTk6OS42/v78SEhKcNT82Z84chYSEOKfo6OifuvsAAMCH+Uxoqqio0Isvvqg+ffqoc+fOkiS73a7AwECFhoa61IaHh8tutztrfhiYKpdXLquqxuFw6PLly/r2229VXl5+3ZrKdfzYtGnTVFRU5JxOnz5dsx0HAAB1QgNvN1ApOTlZBw8e1Pbt273dipGgoCAFBQV5uw0AAOAhPnGkacKECVq3bp0+++wz3XXXXc75ERERKi0tVWFhoUt9QUGBIiIinDU/vpuu8vXNamw2mxo1aqTmzZsrICDgujWV6wAAALc2r4Ymy7I0YcIEffLJJ9q8ebNatWrlsrxHjx5q2LChsrKynPOOHTumU6dOKT4+XpIUHx+vAwcOuNzllpmZKZvNptjYWGfND9dRWVO5jsDAQPXo0cOlpqKiQllZWc4aAABwa/Pq6bnk5GStWrVKf/nLX9S4cWPn9UMhISFq1KiRQkJCNGbMGKWkpKhp06ay2WyaOHGi4uPjdd9990mSBgwYoNjYWI0cOVJz586V3W7XjBkzlJyc7Dx99uyzz+rtt9/WlClT9Otf/1qbN2/Whx9+qPXr/+9utJSUFI0aNUo9e/ZU7969tXDhQhUXF2v06NGeHxgAAOBzvBqalixZIkl6+OGHXea/9957euaZZyRJCxYskL+/v5544gmVlJQoMTFR77zzjrM2ICBA69at03PPPaf4+HjdfvvtGjVqlGbPnu2sadWqldavX69JkyZp0aJFuuuuu/Tuu+8qMTHRWTN06FCdO3dOM2fOlN1uV7du3ZSRkXHNxeEAAODW5FPPaarLqvOch5rgOU0AALhfnX1OEwAAgK8iNAEAABggNAEAABggNAEAABggNAEAABggNAEAABggNAEAABggNAEAABggNAEAABggNAEAABggNAEAABggNAEAABggNAEAABggNAEAABggNAEAABggNAEAABggNAEAABggNAEAABggNAEAABggNAEAABggNAEAABggNAEAABggNAEAABggNAEAABggNAEAABggNAEAABggNAEAABggNAEAABggNAEAABggNAEAABggNAEAABggNAEAABggNAEAABggNAEAABggNAEAABggNAEAABggNAEAABggNAEAABggNAEAABggNAEAABggNAEAABggNAEAABggNAEAABggNAEAABggNAEAABggNAEAABggNAEAABggNAEAABggNAEAABggNAEAABggNAEAABggNAEAABggNAEAABggNAEAABggNAEAABggNAEAABggNAEAABggNAEAABggNAEAABggNAEAABggNAEAABggNAEAABggNAEAABggNAEAABggNAEAABjwamjatm2bHn30UUVFRcnPz09r1651Wf7MM8/Iz8/PZRo4cKBLzfnz5zVixAjZbDaFhoZqzJgxunjxokvN/v371bdvXwUHBys6Olpz5869ppc1a9aoQ4cOCg4OVpcuXZSenu72/QUAAHWXV0NTcXGxunbtqrS0tBvWDBw4UGfOnHFOf/7zn12WjxgxQocOHVJmZqbWrVunbdu2afz48c7lDodDAwYMUExMjHJycvTmm28qNTVVy5Ytc9bs3LlTw4cP15gxY7Rv3z4NGTJEQ4YM0cGDB92/0wAAoE5q4M2NDxo0SIMGDaqyJigoSBEREdddduTIEWVkZOjzzz9Xz549JUmLFy/W4MGD9dZbbykqKkorV65UaWmpli9frsDAQHXq1Em5ubmaP3++M1wtWrRIAwcO1OTJkyVJr776qjIzM/X2229r6dKlbtxjAABQV/n8NU1btmxRWFiY2rdvr+eee07fffedc1l2drZCQ0OdgUmSEhIS5O/vr927dztrHnzwQQUGBjprEhMTdezYMX3//ffOmoSEBJftJiYmKjs7+4Z9lZSUyOFwuEwAAKD+8unQNHDgQP3Xf/2XsrKy9J//+Z/aunWrBg0apPLyckmS3W5XWFiYy3saNGigpk2bym63O2vCw8Ndaipf36ymcvn1zJkzRyEhIc4pOjr6p+0sAADwaV49PXczw4YNc/67S5cuuueee9SmTRtt2bJF/fv392Jn0rRp05SSkuJ87XA4CE4AANRjPn2k6cdat26t5s2b6/jx45KkiIgInT171qXm6tWrOn/+vPM6qIiICBUUFLjUVL6+Wc2NrqWS/nmtlc1mc5kAAED9VadC09dff63vvvtOkZGRkqT4+HgVFhYqJyfHWbN582ZVVFQoLi7OWbNt2zaVlZU5azIzM9W+fXs1adLEWZOVleWyrczMTMXHx9f2LgEAgDrCq6Hp4sWLys3NVW5uriQpLy9Pubm5OnXqlC5evKjJkydr165dOnnypLKysvTYY4+pbdu2SkxMlCR17NhRAwcO1Lhx47Rnzx7t2LFDEyZM0LBhwxQVFSVJevrppxUYGKgxY8bo0KFD+uCDD7Ro0SKXU2svvPCCMjIyNG/ePB09elSpqanau3evJkyY4PExAQAAvsmroWnv3r269957de+990qSUlJSdO+992rmzJkKCAjQ/v379Ytf/ELt2rXTmDFj1KNHD/39739XUFCQcx0rV65Uhw4d1L9/fw0ePFgPPPCAyzOYQkJCtHHjRuXl5alHjx767W9/q5kzZ7o8y+n+++/XqlWrtGzZMnXt2lUfffSR1q5dq86dO3tuMAAAgE/zsyzL8nYT9YHD4VBISIiKiopq5fomW2hTDZ67vsqa9ClJchSed/u2AQCor6rz+V2nrmkCAADwFkITAACAAUITAACAAUITAACAAUITAACAAUITAACAAUITAACAAUITAACAAUITAACAAUITAACAAUITAACAAUITAACAAUITAACAAUITAACAAUITAACAAUITAACAAUITAACAAUITAACAAUITAACAgRqFptatW+u77767Zn5hYaFat279k5sCAADwNTUKTSdPnlR5efk180tKSvTNN9/85KYAAAB8TYPqFH/66afOf2/YsEEhISHO1+Xl5crKylLLli3d1hwAAICvqFZoGjJkiCTJz89Po0aNclnWsGFDtWzZUvPmzXNbcwAAAL6iWqGpoqJCktSqVSt9/vnnat68ea00BQAA4GuqFZoq5eXlubsPAAAAn1aj0CRJWVlZysrK0tmzZ51HoCotX778JzcGAADgS2oUmn7/+99r9uzZ6tmzpyIjI+Xn5+fuvgAAAHxKjULT0qVLtWLFCo0cOdLd/QAAAPikGj2nqbS0VPfff7+7ewEAAPBZNQpNY8eO1apVq9zdCwAAgM+q0em5K1euaNmyZdq0aZPuueceNWzY0GX5/Pnz3dIcAACAr6hRaNq/f7+6desmSTp48KDLMi4KBwAA9VGNQtNnn33m7j4AAAB8Wo2uaQIAALjV1OhIU79+/ao8Dbd58+YaNwQAAOCLahSaKq9nqlRWVqbc3FwdPHjwmi/yBQAAqA9qFJoWLFhw3fmpqam6ePHiT2oIAADAF7n1mqZ//dd/5XvnAABAveTW0JSdna3g4GB3rhIAAMAn1Oj03OOPP+7y2rIsnTlzRnv37tUrr7zilsYAAAB8SY1CU0hIiMtrf39/tW/fXrNnz9aAAQPc0hgAAIAvqVFoeu+999zdBwAAgE+rUWiqlJOToyNHjkiSOnXqpHvvvdctTQEAAPiaGoWms2fPatiwYdqyZYtCQ0MlSYWFherXr59Wr16tFi1auLNHAAAAr6vR3XMTJ07UhQsXdOjQIZ0/f17nz5/XwYMH5XA49O///u/u7hEAAMDranSkKSMjQ5s2bVLHjh2d82JjY5WWlsaF4AAAoF6q0ZGmiooKNWzY8Jr5DRs2VEVFxU9uCgAAwNfUKDQ98sgjeuGFF5Sfn++c980332jSpEnq37+/25oDAADwFTUKTW+//bYcDodatmypNm3aqE2bNmrVqpUcDocWL17s7h4BAAC8rkbXNEVHR+uLL77Qpk2bdPToUUlSx44dlZCQ4NbmAAAAfEW1jjRt3rxZsbGxcjgc8vPz07/8y79o4sSJmjhxonr16qVOnTrp73//e231CgAA4DXVCk0LFy7UuHHjZLPZrlkWEhKi3/zmN5o/f77bmgMAAPAV1QpNX375pQYOHHjD5QMGDFBOTs5PbgoAAMDXVCs0FRQUXPdRA5UaNGigc+fO/eSmAAAAfE21QtOdd96pgwcP3nD5/v37FRkZ+ZObAgAA8DXVCk2DBw/WK6+8oitXrlyz7PLly5o1a5Z+/vOfu605AAAAX1GtRw7MmDFDH3/8sdq1a6cJEyaoffv2kqSjR48qLS1N5eXlmj59eq00CgAA4E3VCk3h4eHauXOnnnvuOU2bNk2WZUmS/Pz8lJiYqLS0NIWHh9dKowAAAN5U7YdbxsTEKD09Xd9//72OHz8uy7L0s5/9TE2aNKmN/gAAAHxCjZ4ILklNmjRRr1693NkLAACAz6rRd88BAADcaghNAAAABghNAAAABghNAAAABghNAAAABrwamrZt26ZHH31UUVFR8vPz09q1a12WW5almTNnKjIyUo0aNVJCQoL+8Y9/uNScP39eI0aMkM1mU2hoqMaMGaOLFy+61Ozfv199+/ZVcHCwoqOjNXfu3Gt6WbNmjTp06KDg4GB16dJF6enpbt9fAABQd3k1NBUXF6tr165KS0u77vK5c+fqD3/4g5YuXardu3fr9ttvV2JiosvXuIwYMUKHDh1SZmam1q1bp23btmn8+PHO5Q6HQwMGDFBMTIxycnL05ptvKjU1VcuWLXPW7Ny5U8OHD9eYMWO0b98+DRkyREOGDKnye/YAAMCtxc+qfKy3l/n5+emTTz7RkCFDJP3zKFNUVJR++9vf6qWXXpIkFRUVKTw8XCtWrNCwYcN05MgRxcbG6vPPP1fPnj0lSRkZGRo8eLC+/vprRUVFacmSJZo+fbrsdrsCAwMlSVOnTtXatWt19OhRSdLQoUNVXFysdevWOfu577771K1bNy1dutSof4fDoZCQEBUVFclms7lrWJxsoU01eO76KmvSpyTJUXje7dsGAKC+qs7nt89e05SXlye73a6EhATnvJCQEMXFxSk7O1uSlJ2drdDQUGdgkqSEhAT5+/tr9+7dzpoHH3zQGZgkKTExUceOHdP333/vrPnhdiprKrdzPSUlJXI4HC4TAACov3w2NNntdkm65rvswsPDncvsdrvCwsJcljdo0EBNmzZ1qbneOn64jRvVVC6/njlz5igkJMQ5RUdHV3cXAQBAHeKzocnXTZs2TUVFRc7p9OnT3m4JAADUIp8NTREREZKkgoICl/kFBQXOZRERETp79qzL8qtXr+r8+fMuNddbxw+3caOayuXXExQUJJvN5jIBAID6y2dDU6tWrRQREaGsrCznPIfDod27dys+Pl6SFB8fr8LCQuXk5DhrNm/erIqKCsXFxTlrtm3bprKyMmdNZmam2rdvryZNmjhrfridyprK7QAAAHg1NF28eFG5ubnKzc2V9M+Lv3Nzc3Xq1Cn5+fnpxRdf1GuvvaZPP/1UBw4c0L/9278pKirKeYddx44dNXDgQI0bN0579uzRjh07NGHCBA0bNkxRUVGSpKefflqBgYEaM2aMDh06pA8++ECLFi1SSkqKs48XXnhBGRkZmjdvno4eParU1FTt3btXEyZM8PSQAAAAH9XAmxvfu3ev+vXr53xdGWRGjRqlFStWaMqUKSouLtb48eNVWFioBx54QBkZGQoODna+Z+XKlZowYYL69+8vf39/PfHEE/rDH/7gXB4SEqKNGzcqOTlZPXr0UPPmzTVz5kyXZzndf//9WrVqlWbMmKHf/e53+tnPfqa1a9eqc+fOHhgFAABQF/jMc5rqOp7TBABA3VMvntMEAADgSwhNAAAABghNAAAABghNAAAABghNAAAABghNAAAABghNAAAABghNAAAABghNAAAABghNAAAABghNAAAABghNAAAABghNAAAABghNAAAABghNAAAABghNAAAABghNAAAABghNAAAABghNAAAABghNAAAABghNAAAABghNAAAABghNAAAABghNAAAABghNAAAABghNAAAABghNAAAABghNAAAABghNAAAABghNAAAABghNAAAABghNAAAABghNAAAABghNAAAABghNAAAABghNAAAABghNAAAABghNAAAABghNAAAABghNAAAABghNAAAABghNAAAABghNAAAABghNAAAABghNAAAABghNAAAABghNAAAABghNAAAABghNAAAABghNAAAABghNAAAABghNAAAABghNAAAABghNAAAABghNAAAABghNAAAABghNAAAABghNAAAABghNAAAABghNAAAABghNAAAABhp4uwH4nvaxnXUmP/+mdZFRUTp2+KAHOgIAwPsITbjGmfx8DZ67/qZ16VOSPNANAAC+gdNzAAAABghNAAAABghNAAAABnw6NKWmpsrPz89l6tChg3P5lStXlJycrGbNmumOO+7QE088oYKCApd1nDp1SklJSbrtttsUFhamyZMn6+rVqy41W7ZsUffu3RUUFKS2bdtqxYoVntg9AABQh/h0aJKkTp066cyZM85p+/btzmWTJk3SX//6V61Zs0Zbt25Vfn6+Hn/8cefy8vJyJSUlqbS0VDt37tT777+vFStWaObMmc6avLw8JSUlqV+/fsrNzdWLL76osWPHasOGDR7dTwAA4Nt8/u65Bg0aKCIi4pr5RUVF+tOf/qRVq1bpkUcekSS999576tixo3bt2qX77rtPGzdu1OHDh7Vp0yaFh4erW7duevXVV/Xyyy8rNTVVgYGBWrp0qVq1aqV58+ZJkjp27Kjt27drwYIFSkxMvGFfJSUlKikpcb52OBxu3nMAAOBLfP5I0z/+8Q9FRUWpdevWGjFihE6dOiVJysnJUVlZmRISEpy1HTp00N13363s7GxJUnZ2trp06aLw8HBnTWJiohwOhw4dOuSs+eE6Kmsq13Ejc+bMUUhIiHOKjo52y/4CAADf5NOhKS4uTitWrFBGRoaWLFmivLw89e3bVxcuXJDdbldgYKBCQ0Nd3hMeHi673S5JstvtLoGpcnnlsqpqHA6HLl++fMPepk2bpqKiIud0+vTpn7q7AADAh/n06blBgwY5/33PPfcoLi5OMTEx+vDDD9WoUSMvdiYFBQUpKCjIqz0AAADP8ekjTT8WGhqqdu3a6fjx44qIiFBpaakKCwtdagoKCpzXQEVERFxzN13l65vV2Gw2rwczAADgO+pUaLp48aK++uorRUZGqkePHmrYsKGysrKcy48dO6ZTp04pPj5ekhQfH68DBw7o7NmzzprMzEzZbDbFxsY6a364jsqaynUAAABIPh6aXnrpJW3dulUnT57Uzp079ctf/lIBAQEaPny4QkJCNGbMGKWkpOizzz5TTk6ORo8erfj4eN13332SpAEDBig2NlYjR47Ul19+qQ0bNmjGjBlKTk52nlp79tlndeLECU2ZMkVHjx7VO++8ow8//FCTJk3y5q4DAAAf49PXNH399dcaPny4vvvuO7Vo0UIPPPCAdu3apRYtWkiSFixYIH9/fz3xxBMqKSlRYmKi3nnnHef7AwICtG7dOj333HOKj4/X7bffrlGjRmn27NnOmlatWmn9+vWaNGmSFi1apLvuukvvvvtulY8bAAAAtx6fDk2rV6+ucnlwcLDS0tKUlpZ2w5qYmBilp6dXuZ6HH35Y+/btq1GPAADg1uDTp+cAAAB8BaEJAADAAKEJAADAAKEJAADAAKEJAADAAKEJAADAAKEJAADAAKEJAADAAKEJAADAAKEJAADAAKEJAADAAKEJAADAAKEJAADAAKEJAADAAKEJAADAAKEJAADAAKEJAADAAKEJAADAAKEJAADAAKEJAADAAKEJAADAAKEJAADAAKEJAADAAKEJAADAAKEJAADAAKEJAADAAKEJAADAAKEJAADAAKEJAADAQANvNwAAAOqm9rGddSY/v8qayKgoHTt88Cevx3RdtYnQBAAAauRMfr4Gz11fZU36lCS3rMd0XbWJ03MAAAAGONJ0izE5BFp86ZKHugEAoO4gNN1iTA6Bfpj8sGeaAQCgDuH0HAAAgAFCEwAAgAFCEwAAgAFCEwAAgAFCEwAAgAFCEwAAgAFCEwAAgAFCEwAAgAFCEwAAgAFCEwAAgAFCEwAAgAFCEwAAgAG+sBcAAFyjfWxnncnPr7Km+NIlD3XjGwhNAADgGmfy8zV47voqaz5MftgzzfgITs8BAAAYIDQBAAAYIDQBAAAYIDQBAAAY4ELweqT48mXZQptWXXOL3ekAAIC7EJrqEauigjsdAACoJYQmAABQa+rTWRBCEwAAqDX16SwIoQkAUG+YPMU6MipKxw4f9FBHqE8ITQCAesPkKdbpU5I81A3qGx45AAAAYIAjTQBqxOQ0iMSpEAD1B6EJQI2YnAaRfO9UCGEPQE0RmlBjJreR8sEDX1NXwx7ch79dqClCE2rM5DZSPnjgSSZHkerK82BQe/jbhZoiNMHruEXYjMk4lZSVKahhwyprTMayroYPk6NIdeV5MAB8D6EJXmfyQbdm4iO3/OF000DwywUbq6wxGcviS5f0q7c/u+m2AOBWQmj6kbS0NL355puy2+3q2rWrFi9erN69e3u7rVuepw+n1+ejX55+Oi/Xj8Bd6uoR0Pr89+RWQ2j6gQ8++EApKSlaunSp4uLitHDhQiUmJurYsWMKCwvzdnvwIB6Q5z519foRwp57mN6taHJqua4eAeXvSf1BaPqB+fPna9y4cRo9erQkaenSpVq/fr2WL1+uqVOnerk7+Bo+VOu3uhr2fI3p3Yomp5Z9MRC5C39P6gZC0/9XWlqqnJwcTZs2zTnP399fCQkJys7Ovqa+pKREJSUlztdFRUWSJIfDUSv9WZalssvFPlNjWnfx0iU1DmlSZU3xpUtu6clkW5L5/9HebHsV5eX6l99/WGXNxpm/uunvRPdecSqw26usMe2pPv+euOvn5um+wyMi9MXnu2+6vbrI5HfX5Gci+d7vbl39e+JOvvYzqaxz9xhUrs+yrJsXW7Asy7K++eYbS5K1c+dOl/mTJ0+2evfufU39rFmzLElMTExMTExM9WA6ffr0TbMCR5pqaNq0aUpJSXG+rqio0Pnz59WsWTP5+fm5dVsOh0PR0dE6ffq0bDabW9eN/8M4ewbj7BmMs2cwzp5TW2NtWZYuXLigqKiom9YSmv6/5s2bKyAgQAUFBS7zCwoKFBERcU19UFCQgoKCXOaFhobWZouy2Wz8R+kBjLNnMM6ewTh7BuPsObUx1iEhIUZ1/m7dah0WGBioHj16KCsryzmvoqJCWVlZio+P92JnAADAF3Ck6QdSUlI0atQo9ezZU71799bChQtVXFzsvJsOAADcughNPzB06FCdO3dOM2fOlN1uV7du3ZSRkaHw8HCv9hUUFKRZs2ZdczoQ7sU4ewbj7BmMs2cwzp7jC2PtZ1km99gBAADc2rimCQAAwAChCQAAwAChCQAAwAChCQAAwAChyUekpaWpZcuWCg4OVlxcnPbs2VNl/Zo1a9ShQwcFBwerS5cuSk9P91CndVt1xvmPf/yj+vbtqyZNmqhJkyZKSEi46c8F/1Td3+dKq1evlp+fn4YMGVK7DdYT1R3nwsJCJScnKzIyUkFBQWrXrh1/OwxUd5wXLlyo9u3bq1GjRoqOjtakSZN05coVD3VbN23btk2PPvqooqKi5Ofnp7Vr1970PVu2bFH37t0VFBSktm3basWKFbXeJ9895wNWr15tBQYGWsuXL7cOHTpkjRs3zgoNDbUKCgquW79jxw4rICDAmjt3rnX48GFrxowZVsOGDa0DBw54uPO6pbrj/PTTT1tpaWnWvn37rCNHjljPPPOMFRISYn399dce7rxuqe44V8rLy7PuvPNOq2/fvtZjjz3mmWbrsOqOc0lJidWzZ09r8ODB1vbt2628vDxry5YtVm5uroc7r1uqO84rV660goKCrJUrV1p5eXnWhg0brMjISGvSpEke7rxuSU9Pt6ZPn259/PHHliTrk08+qbL+xIkT1m233WalpKRYhw8fthYvXmwFBARYGRkZtdonockH9O7d20pOTna+Li8vt6Kioqw5c+Zct/6pp56ykpKSXObFxcVZv/nNb2q1z7quuuP8Y1evXrUaN25svf/++7XVYr1Qk3G+evWqdf/991vvvvuuNWrUKEKTgeqO85IlS6zWrVtbpaWlnmqxXqjuOCcnJ1uPPPKIy7yUlBSrT58+tdpnfWISmqZMmWJ16tTJZd7QoUOtxMTEWuzMsjg952WlpaXKyclRQkKCc56/v78SEhKUnZ193fdkZ2e71EtSYmLiDetRs3H+sUuXLqmsrExNmzatrTbrvJqO8+zZsxUWFqYxY8Z4os06rybj/Omnnyo+Pl7JyckKDw9X586d9frrr6u8vNxTbdc5NRnn+++/Xzk5Oc5TeCdOnFB6eroGDx7skZ5vFd76HOSJ4F727bffqry8/JqnjoeHh+vo0aPXfY/dbr9uvd1ur7U+67qajPOPvfzyy4qKirrmP1T8n5qM8/bt2/WnP/1Jubm5HuiwfqjJOJ84cUKbN2/WiBEjlJ6eruPHj+v5559XWVmZZs2a5Ym265yajPPTTz+tb7/9Vg888IAsy9LVq1f17LPP6ne/+50nWr5l3Ohz0OFw6PLly2rUqFGtbJcjTYCBN954Q6tXr9Ynn3yi4OBgb7dTb1y4cEEjR47UH//4RzVv3tzb7dRrFRUVCgsL07Jly9SjRw8NHTpU06dP19KlS73dWr2yZcsWvf7663rnnXf0xRdf6OOPP9b69ev16quvers1uAFHmrysefPmCggIUEFBgcv8goICRUREXPc9ERER1apHzca50ltvvaU33nhDmzZt0j333FObbdZ51R3nr776SidPntSjjz7qnFdRUSFJatCggY4dO6Y2bdrUbtN1UE1+nyMjI9WwYUMFBAQ453Xs2FF2u12lpaUKDAys1Z7ropqM8yuvvKKRI0dq7NixkqQuXbqouLhY48eP1/Tp0+Xvz7EKd7jR56DNZqu1o0wSR5q8LjAwUD169FBWVpZzXkVFhbKyshQfH3/d98THx7vUS1JmZuYN61GzcZakuXPn6tVXX1VGRoZ69uzpiVbrtOqOc4cOHXTgwAHl5uY6p1/84hfq16+fcnNzFR0d7cn264ya/D736dNHx48fd4ZSSfqf//kfRUZGEphuoCbjfOnSpWuCUWVQtfiqV7fx2udgrV5mDiOrV6+2goKCrBUrVliHDx+2xo8fb4WGhlp2u92yLMsaOXKkNXXqVGf9jh07rAYNGlhvvfWWdeTIEWvWrFk8csBAdcf5jTfesAIDA62PPvrIOnPmjHO6cOGCt3ahTqjuOP8Yd8+Zqe44nzp1ymrcuLE1YcIE69ixY9a6deussLAw67XXXvPWLtQJ1R3nWbNmWY0bN7b+/Oc/WydOnLA2btxotWnTxnrqqae8tQt1woULF6x9+/ZZ+/btsyRZ8+fPt/bt22f97//+r2VZljV16lRr5MiRzvrKRw5MnjzZOnLkiJWWlsYjB24lixcvtu6++24rMDDQ6t27t7Vr1y7nsoceesgaNWqUS/2HH35otWvXzgoMDLQ6depkrV+/3sMd103VGeeYmBhL0jXTrFmzPN94HVPd3+cfIjSZq+4479y504qLi7OCgoKs1q1bW//xH/9hXb161cNd1z3VGeeysjIrNTXVatOmjRUcHGxFR0dbzz//vPX99997vvE65LPPPrvu39vKsR01apT10EMPXfOebt26WYGBgVbr1q2t9957r9b79LMsjhcCAADcDNc0AQAAGCA0AQAAGCA0AQAAGCA0AQAAGCA0AQAAGCA0AQAAGCA0AQAAGCA0AQAAGCA0AQAAGCA0AQAAGCA0AYCblJaWersFALWI0ASg3vvoo4/UpUsXNWrUSM2aNVNCQoKKi4slScuXL1enTp0UFBSkyMhITZgwwfm+U6dO6bHHHtMdd9whm82mp556SgUFBc7lqamp6tatm9599121atVKwcHBkqTCwkKNHTtWLVq0kM1m0yOPPKIvv/zSszsNwO0ITQDqtTNnzmj48OH69a9/rSNHjmjLli16/PHHZVmWlixZouTkZI0fP14HDhzQp59+qrZt20qSKioq9Nhjj+n8+fPaunWrMjMzdeLECQ0dOtRl/cePH9d///d/6+OPP1Zubq4k6Ve/+pXOnj2rv/3tb8rJyVH37t3Vv39/nT9/3tO7D8CN/CzLsrzdBADUli+++EI9evTQyZMnFRMT47Lszjvv1OjRo/Xaa69d877MzEwNGjRIeXl5io6OliQdPnxYnTp10p49e9SrVy+lpqbq9ddf1zfffKMWLVpIkrZv366kpCSdPXtWQUFBzvW1bdtWU6ZM0fjx42txbwHUpgbebgAAalPXrl3Vv39/denSRYmJiRowYICefPJJlZWVKT8/X/3797/u+44cOaLo6GhnYJKk2NhYhYaG6siRI+rVq5ckKSYmxhmYJOnLL7/UxYsX1axZM5f1Xb58WV999VUt7CEATyE0AajXAgIClJmZqZ07d2rjxo1avHixpk+frqysLLes//bbb3d5ffHiRUVGRmrLli3X1IaGhrplmwC8g9AEoN7z8/NTnz591KdPH82cOVMxMTHKzMxUy5YtlZWVpX79+l3zno4dO+r06dM6ffq0y+m5wsJCxcbG3nBb3bt3l91uV4MGDdSyZcva2iUAXkBoAlCv7d69W1lZWRowYIDCwsK0e/dunTt3Th07dlRqaqqeffZZhYWFadCgQbpw4YJ27NihiRMnKiEhQV26dNGIESO0cOFCXb16Vc8//7weeugh9ezZ84bbS0hIUHx8vIYMGaK5c+eqXbt2ys/P1/r16/XLX/6yyvcC8G2EJgD1ms1m07Zt27Rw4UI5HA7FxMRo3rx5GjRokCTpypUrWrBggV566SU1b95cTz75pKR/Hp36y1/+ookTJ+rBBx+Uv7+/Bg4cqMWLF1e5PT8/P6Wnp2v69OkaPXq0zp07p4iICD344IMKDw+v9f0FUHu4ew4AAMAAz2kCAAAwQGgCAAAwQGgCAAAwQGgCAAAwQGgCAAAwQGgCAAAwQGgCAAAwQGgCAAAwQGgCAAAwQGgCAAAwQGgCAAAw8P8ASjAYIu1AtKgAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sns.histplot(scores_df['score'])\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "e9909cce-de25-4720-819b-5f80d27569bb", + "metadata": {}, + "source": [ + "We see that the tests can mostly be put into two categories: near 0, and near 1." + ] + }, + { + "cell_type": "code", + "execution_count": 97, + "id": "cced4db3-15a2-4f37-87f0-4688fe5108f6", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Less than 10%: 0.686293476889431\n", + "More than 90%: 0.16101694915254236\n" + ] + } + ], + "source": [ + "n_cols = len(scores_df)\n", + "\n", + "print(f\"Less than 10%: {sum(scores_df['score'] < .1) / n_cols}\")\n", + "print(f\"More than 90%: {sum(scores_df['score'] > .9) / n_cols}\")" + ] + }, + { + "cell_type": "markdown", + "id": "3c7cc31a-e130-4df6-9633-787e1d464452", + "metadata": {}, + "source": [ + "Those two categories make up ~85% of the columns." + ] + }, + { + "cell_type": "markdown", + "id": "daf1ea6e-39ab-4688-a6c6-eaa116e499ee", + "metadata": {}, + "source": [ + "Are runs related to their previous run? We had an intuition that infra flakes show up as waterfall patterns, and the infrastructure continues to be flaky for more than one run. We would like to see if there is correlation between subsequent runs that shows up." + ] + }, + { + "cell_type": "code", + "execution_count": 102, + "id": "b99f3ecc-e63f-4309-be9f-745e8f43481d", + "metadata": {}, + "outputs": [], + "source": [ + "all_data = []\n", + "for i, j in all_grids:\n", + " scores = scores_df[(scores_df['dashboard'] == i) & (scores_df['job'] == j)].score.values\n", + " all_data += list(zip(scores[:-1], scores[1:]))" + ] + }, + { + "cell_type": "code", + "execution_count": 110, + "id": "8c9065fa-57ea-415f-98a6-4e9314d53194", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sns.scatterplot(x = [d[0] for d in all_data], y = [d[1] for d in all_data], alpha = 0.2)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "36d72de6-01fc-4c15-a984-00b5a3de4a98", + "metadata": {}, + "source": [ + "While this is certainly an interesting looking plot. There isn't too much to take away from this in my opinion except that things seem pretty random." + ] + }, + { + "cell_type": "markdown", + "id": "a66c8c11-f3ed-476f-b4b4-87db1b11c9bd", + "metadata": {}, + "source": [ + "We define an unexpected column as having a score >0.9. We wish to look at the histograms of scores coming directly after an unexpected run and an expected run (score <.10)." + ] + }, + { + "cell_type": "code", + "execution_count": 115, + "id": "edbc5ae4-bdaf-40d6-bd8b-feb7731d61bb", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "unexpected_scores = [d[0] for d in all_data if d[1] > 0.9 ]\n", + "expected_scores = [d[0] for d in all_data if d[1] < 0.1]\n", + "\n", + "sns.histplot(unexpected_scores, stat = 'probability', color = 'r', bins = 25, alpha = 0.5)\n", + "sns.histplot(expected_scores, stat = 'probability', color = 'g', bins = 25, alpha = 0.5)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "e35b32d3-83df-4dcb-a67c-f5c4b80cd368", + "metadata": {}, + "source": [ + "We really don't see much difference here either. It would be pretty safe to say a high column score don't affect the next column's score all that much." + ] + }, + { + "cell_type": "markdown", + "id": "9f12fb2e-7f35-42bb-8e59-71f979f7395f", + "metadata": {}, + "source": [ + "## Save to Ceph or Local" + ] + }, + { + "cell_type": "code", + "execution_count": 100, + "id": "84753d11-b8be-4cf1-9845-dd4727e2d586", + "metadata": {}, + "outputs": [], + "source": [ + "filename = f\"{METRIC_NAME}-{timestamp.year}-{timestamp.month}-{timestamp.day}.parquet\"\n", + "\n", + "if AUTOMATION == \"True\":\n", + " cc = CephCommunication(s3_endpoint_url, s3_access_key, s3_secret_key, s3_bucket)\n", + " cc.upload_to_ceph(scores_df, metric_path, filename)\n", + "else:\n", + " save_to_disk(scores_df, OUTPUT_DATA_PATH, filename)" + ] + }, + { + "cell_type": "markdown", + "id": "64391a44-4936-41ab-ab47-53640f38456e", + "metadata": {}, + "source": [ + "## Conclusion" + ] + }, + { + "cell_type": "markdown", + "id": "6ffa7454-2ac6-44c2-bc1b-2dcbb9025ab2", + "metadata": {}, + "source": [ + "We came up with a method to classify the unexpectness of a given number of tests failing during a run. We are going to use this along with other data from the run to try to extract useful information about what makes these runs have such unexpected failures." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.3" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}