From 2a16d7e298e59670cdffa240771e8e253a3f7589 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 | 973 ++++++++++++++++++ 1 file changed, 973 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..34ae22fe --- /dev/null +++ b/notebooks/data-sources/TestGrid/metrics/unexpected_test_failures.ipynb @@ -0,0 +1,973 @@ +{ + "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": 99, + "id": "8ea6c93f-2136-4a36-9e72-9bfdfe02c5c8", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 99, + "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 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", + "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": null, + "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": 6, + "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": 7, + "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": 8, + "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": 9, + "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": 36, + "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.iloc[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(\"Days\")\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 562, + "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": 11, + "id": "3a71e3f1-3a1f-4799-8b3f-5489dad8dcd2", + "metadata": {}, + "outputs": [], + "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", + " # 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. So if a 2 tests fail that had a $\\frac25$ probability of failing and a test fails that had a $\\frac13$ probability of failing our column score will be $-2\\log\\frac25 - \\log\\frac13$." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "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": 572, + "id": "46df01ac-793a-43bb-a4d2-e46136720cbb", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "get_grid(x)" + ] + }, + { + "cell_type": "code", + "execution_count": 596, + "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, 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": 13, + "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": 600, + "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": 601, + "id": "109a3992-19db-437f-9fe4-67721993a655", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/app-root/lib64/python3.8/site-packages/seaborn/distributions.py:2619: FutureWarning: `distplot` is a deprecated function and will be removed in a future version. Please adapt your code to use either `displot` (a figure-level function with similar flexibility) or `histplot` (an axes-level function for histograms).\n", + " warnings.warn(msg, FutureWarning)\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 601, + "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.distplot(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": 615, + "id": "de14103d-3f09-47a4-9eb5-d096064432cb", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 615, + "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": 620, + "id": "ceaab32f-20c7-4072-97af-a5b48c6c27fe", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.05 significance: 36.11580390447193\n", + "0.01 significance: 39.80852213489304\n", + "0.001 significance: 47.53129776754298\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": 621, + "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", + "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", + "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": [ + "Below we define the main function that will assign a probability to every column of testgrid data." + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "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": 79, + "id": "3bb9bb28-fe02-40a1-9c2a-0a5a62f9fe7e", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0\n", + "100\n", + "200\n", + "300\n", + "400\n" + ] + } + ], + "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?" + ] + }, + { + "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 +}