{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ ">### đźš© *Create a free WhyLabs account to get more value out of whylogs!*
\n", ">*Did you know you can store, visualize, and monitor whylogs profiles with the [WhyLabs Observability Platform](https://whylabs.ai/whylogs-free-signup?utm_source=whylogs-Github&utm_medium=whylogs-example&utm_campaign=KS_profiling)? Sign up for a [free WhyLabs account](https://whylabs.ai/whylogs-free-signup?utm_source=whylogs-Github&utm_medium=whylogs-example&utm_campaign=KS_profiling) to leverage the power of whylogs and WhyLabs together!*" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Benchmark - KS Test" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "[![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/whylabs/whylogs/blob/mainline/python/examples/benchmarks/KS_Profiling.ipynb)" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "> This notebook is a complement to the blog post [_Understanding Kolmogorov-Smirnov (KS) Tests for Data Drift on Profiled Data_](https://medium.com/p/5c8317796f78).\n", ">\n", ">Please refer to the blog post for additional context." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We applied whylogs' implementation of KS Test and compared the results when applying the same test to the complete data set. The results allow us to discuss the limitations of data profiling for KS drift detection, and also the pros and cons of the KS algorithm itself for different scenarios." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Experiment Design" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "First, we need the data. For this experiment, we will take two samples of equal size from the following distributions:\n", "\n", "- Normal: Broad class of data. Unskewed and Peaked around the center\n", "\n", "- Pareto: Skewed data with long tail/outliers\n", "\n", "- Uniform: Evenly sampled across its domain\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Drift Injection\n", "\n", "Next, we’ll inject drift into one sample (which we’ll call the target distribution) to compare it to the reference, unaltered, distribution.\n", "\n", "We will inject drift artificially by simply shifting the data according to a parameter. We’ll use as the parameter a ratio of the distribution’s interquartile range.\n", "\n", "The idea is to have 4 different scenarios:\n", "\n", "- No drift\n", "\n", "- Small drift\n", "\n", "- Medium drift\n", "\n", "- Large drift\n", "\n", "The ideal process of detecting/alerting for drifts can be very subjective, depending on the desired sensitivity for your particular application. In this case, we are assuming that the small-drift scenario is small enough for it to be safely ignored. We are also expecting that the medium and large drift scenarios should result in a drift alert since both would be cases for further inspection. \n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Applying the KS test\n", "\n", "As the ground truth, we will use scipy’s implementation of the two-sample KS test, with the complete data from both samples. We will then compare those results with the profiled version of the test. To do so, we’ll use whylogs’ implementation of the same test, which uses only the statistical profile of each sample. \n", "\n", "The distribution metrics contained in the profiles are obtained from a process called data sketching, which adds some degree of randomness to the result. For this reason, the KS test result can be different each time a profile is generated. For this reason, we’ll profile the data 10 times for every scenario, and compare the ground truth to statistics such as the mean, maximum, and minimum of those runs.\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Experiment Variables\n", "\n", "Our main goal is to answer:\n", "\n", "“How does whylogs’ KS implementation compare to scipy’s implementation?”\n", "\n", "However, this answer depends on several different variables. We will run three separate experiments to better understand the effect of each variable: Data Volume, Number of buckets, and Profile Size. The first one relates to the number of samples being tested, whereas the last two relate to whylogs internal, tunable parameters.\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Installing the required packages" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Note: you may need to restart the kernel to use updated packages.\n", "%pip install 'matplotlib' 'numpy' 'seaborn==0.12.1'\n", "%pip install 'scipy==1.7.3' 'whylogs[viz]' 'typing_extensions'" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Parameters and Functions - Experiments and Plots" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In this section, we'll compile all of the parameter and functions required to run the following experiments and plot the results." ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "# For experiment #2, we're running the test with different number of buckets for the KS Test calculation\n", "QUANTILE_LIST = [\n", " list(np.linspace(0,1,5)),\n", " list(np.linspace(0,1,10)),\n", " list(np.linspace(0,1,50)),\n", " list(np.linspace(0,1,100)),\n", "]\n", "\n", "# no drift, small drift, medium drift and large drift\n", "drift_magnitudes = [0,0.05,0.4,0.75]\n", "\n", "sample_sizes = [500,1000,5000,10000,50000]\n", "sample_sizes_labels = ['500','1k', '5k','10k','50k']\n", "random_seed = 22" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "from numpy.random import Generator, PCG64\n", "import pandas as pd\n", "from scipy.stats import iqr\n", "\n", "def generate_data(\n", " distribution: str = \"normal\", generator=None, drift_magnitude: float = 0, size: int = 100000\n", ") -> pd.Series:\n", " \"\"\"Generates a pandas series with samples drawn from a distribution (normal, pareto or uniform). The internal parameters\n", " for each distributions are fixed. You can specify the number of samples you want and also if a drift of a certain magnitude is\n", " to be injected. The drift magnitude is a ratio of the distribution's interquartile range.\n", "\n", " \"\"\"\n", " if generator is None:\n", " generator = Generator(PCG64(12345))\n", "\n", " if distribution == \"normal\":\n", " sample = generator.standard_normal(size)\n", " elif distribution == \"pareto\":\n", " a,m = 7.,2.\n", " sample = (generator.pareto(a, size) + 1) * m\n", " elif distribution == \"uniform\":\n", " sample = generator.uniform(-5,5,size)\n", " else:\n", " raise ValueError(\"Distribution not found.\")\n", " offset = (iqr(sample)) * drift_magnitude\n", " drifted_sample = sample + offset\n", " return pd.Series(drifted_sample)" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "from numpy.random import Generator, PCG64\n", "import numpy as np\n", "import pandas as pd\n", "import whylogs as why\n", "from whylogs.viz.utils.drift_calculations import calculate_drift_values, _compute_ks_test_p_value\n", "from scipy import stats\n", "\n", "def run_ks_experiment(distribution=\"normal\",drift_magnitude=0, quantile_list = QUANTILE_LIST):\n", " \"\"\"Runs KS experiment for given distribution type and drift magnitude. The experiments are run\n", " for multiple sample sizes and number of buckets, 10 times for each combination of parameters.\n", "\n", " Parameters\n", " ----------\n", " distribution : str, optional\n", " distribution type. \"normal\",\"pareto\", or \"uniform\", by default \"normal\"\n", " drift_magnitude : int, optional\n", " drift magnitude, by default 0 (no drift)\n", "\n", " Returns\n", " -------\n", " _type_\n", " Dictionary with statistics such as pvalues for whylogs and scipy's implementation, mean absolute errors,\n", " and error ranges (minimum and maximum) for whylogs KS test.\n", " \"\"\"\n", " # size_list = [1000, 5000, 10000, 50000, 100000]\n", " size_list = sample_sizes\n", " experiment_results = {}\n", " for quant_i,QUANTILES in enumerate(quantile_list):\n", " bars1 = []\n", " heights1 = []\n", " pv_means = []\n", " pv_ranges = []\n", " pv_truths = []\n", " for sample_size in size_list:\n", " rng = Generator(PCG64(random_seed))\n", " ref, target = pd.DataFrame(), pd.DataFrame()\n", " ref[\"col\"] = generate_data(distribution=distribution, generator=rng, drift_magnitude=0, size=sample_size)\n", " target[\"col\"] = generate_data(distribution=distribution, generator=rng, drift_magnitude=drift_magnitude, size=sample_size)\n", " scipy_res = stats.ks_2samp(ref[\"col\"], target[\"col\"], mode='asymp')\n", " scipy_pvalue = scipy_res.pvalue\n", " errors = []\n", " pvalues = []\n", " for i in range(10):\n", " ref_profile = why.log(ref).profile()\n", " target_profile = why.log(target).profile()\n", "\n", " ref_dist = ref_profile._columns[\"col\"]._metrics[\"distribution\"].kll.value\n", " target_dist = target_profile._columns[\"col\"]._metrics[\"distribution\"].kll.value\n", "\n", " res = _compute_ks_test_p_value(reference_distribution=ref_dist, target_distribution=target_dist, quantiles=QUANTILES)\n", " pv = res[\"p_value\"]\n", " error = abs(res[\"p_value\"] - scipy_pvalue)\n", " errors.append(error)\n", " pvalues.append(pv)\n", " mean = sum(errors) / len(errors)\n", " mean_pv = sum(pvalues) / len(pvalues)\n", "\n", " range_pv = [abs(mean_pv-min(pvalues)),abs(mean_pv-max(pvalues))] \n", "\n", " error = [abs(mean-min(errors)),abs(mean-max(errors))]\n", "\n", " pv_truth = scipy_pvalue\n", " pv_truths.append(pv_truth)\n", " bars1.append(mean)\n", " heights1.append(error)\n", "\n", " pv_means.append(mean_pv)\n", " pv_ranges.append(range_pv)\n", "\n", " y_err = [[x[0] for x in heights1],[x[1] for x in heights1]]\n", " pv_rg = [[x[0] for x in pv_ranges],[x[1] for x in pv_ranges]]\n", "\n", " experiment_results[quant_i] = {}\n", " experiment_results[quant_i]['bar'] = bars1\n", " experiment_results[quant_i]['yerr'] = y_err\n", " experiment_results[quant_i]['pv_means'] = pv_means\n", " experiment_results[quant_i]['pv_ranges'] = pv_rg\n", " experiment_results[quant_i]['pv_truths'] = pv_truths\n", " experiment_results[quant_i]['label'] = \"buckets={}\".format(len(QUANTILES))\n", " experiment_results[quant_i]['distribution'] = distribution\n", " return experiment_results\n", "\n", "def run_experiment_on_params(distribution=\"normal\",magnitudes = drift_magnitudes):\n", " \"\"\"\n", " Runs the KS experiment for a list of different drift magnitudes\n", " \"\"\"\n", " exps_results = {}\n", "\n", " for drift_magnitude in magnitudes:\n", " exps_results[drift_magnitude] = run_ks_experiment(distribution=distribution, drift_magnitude=drift_magnitude)\n", "\n", " return exps_results" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "from numpy.random import Generator, PCG64\n", "import numpy as np\n", "import pandas as pd\n", "import seaborn as sns\n", "import matplotlib.pyplot as plt\n", "import matplotlib\n", "def plot_drift(distribution=\"normal\", magnitudes = [0,0.05,0.4,0.75], sample_size = 100000):\n", " \"\"\"Plots 4 histograms in a 2x2 matrix for different drift magnitudes, for the given distribution type\n", " and number of samples.\n", " \"\"\"\n", "\n", " rng = Generator(PCG64(random_seed))\n", " fig, axs = plt.subplots(2,2)\n", " fig.tight_layout(pad=1.5)\n", " for ix,drift_magnitude in enumerate(magnitudes):\n", " x,y = int(ix%2),int(ix/2)\n", "\n", " df = pd.DataFrame()\n", "\n", " df[\"ref\"] = generate_data(distribution=distribution, generator=rng, drift_magnitude=0, size=sample_size)\n", " df[\"target\"] = generate_data(distribution=distribution, generator=rng, drift_magnitude=drift_magnitude, size=sample_size)\n", "\n", "\n", "\n", " # set a grey background (use sns.set_theme() if seaborn version 0.11.0 or above)\n", " sns.set(style=\"darkgrid\")\n", "\n", " sns.histplot(ax=axs[x][y],data=df, x=\"ref\", color=\"skyblue\", label=\"ref\", kde=False)\n", " sns.histplot(ax=axs[x][y],data=df, x=\"target\", color=\"red\", label=\"target\", kde=False)\n", " if ix==2:\n", " axs[x][y].legend(loc=0, prop={'size': 12})\n", " axs[x][y].set_xlabel('Drift Size:{}'.format(drift_magnitude))\n", "\n", " fig.text(.5, -0.05, \"Artificial drift injection for varying drift magnitudes for {} distribution. Number of samples: {}\".format(distribution,sample_size), ha='center',fontsize=10)\n", " plt.show()\n" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "def plot_pvalues(quant_bars_per_drift):\n", " \"\"\"Plots the pvalues for both whylogs and scipy's implementation for\n", " different drift magnitudes. Expects 4 different drift magnitudes to\n", " plot a 2x2 matrix.\n", "\n", " Parameters\n", " ----------\n", " quant_bars_per_drift : dict\n", " Statistics previously collected by KS experiment.\n", " \"\"\"\n", " matplotlib.rc_file_defaults()\n", " fig, axs = plt.subplots(2,2)\n", " fig.tight_layout(pad=1.0)\n", "\n", " for i,key in enumerate(quant_bars_per_drift): \n", " quant_bars = quant_bars_per_drift[key]\n", " # whylogs by default uses 100 buckets, so let's choose that\n", " quant_index = 3\n", " x,y = int(i%2),int(i/2)\n", " pv_means = quant_bars[quant_index]['pv_means']\n", " pv_range = quant_bars[quant_index]['pv_ranges']\n", " pv_truth = quant_bars[quant_index]['pv_truths']\n", "\n", "\n", " r1 = np.arange(len(pv_means))\n", " axs[x][y].set_xticks([r for r in range(len(quant_bars[quant_index]['bar']))], sample_sizes_labels)\n", " axs[x][y].errorbar(r1, pv_means, yerr=pv_range, capsize=7, label=\"whylogs\")\n", " axs[x][y].set_ylabel('pvalue')\n", " axs[x][y].plot(r1,pv_truth, label=\"scipy\")\n", " if i==2:\n", " axs[x][y].legend(loc=1, prop={'size': 12})\n", " axs[x][y].set_xlabel('Drift Size:{}'.format(key))\n", " axs[x][y].set_ylim(bottom=0)\n", "\n", "\n", " fig.text(.5, -0.05, \"KS pvalue comparison between whylogs and scipy. K=1024, 100 buckets, {} distribution\".format(quant_bars[quant_index]['distribution']), ha='center',fontsize=10)\n", " plt.show()" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "import matplotlib.pyplot as plt\n", "\n", "def plot_buckets_experiment(quant_bars_per_drift):\n", " \"\"\"Plots the mean absolute errors for different number of buckets for\n", " different drift magnitudes. Expects 4 different drift magnitudes to\n", " plot a 2x2 matrix. The errors are calculated based on the difference\n", " between whylogs' and scipy's KS implementation.\n", "\n", " Parameters\n", " ----------\n", " quant_bars_per_drift : dict\n", " Statistics previously collected by KS experiment.\n", " \"\"\"\n", " matplotlib.rc_file_defaults()\n", " fig, axs = plt.subplots(2,2)\n", " fig.tight_layout(pad=1.0)\n", " barWidth = 0.17\n", " # this plots 4 subplots in a 2x2 matrix\n", " assert len(quant_bars_per_drift)==4\n", " for i,drift_magnitude in enumerate(quant_bars_per_drift):\n", " quant_bars = quant_bars_per_drift[drift_magnitude]\n", " x,y = int(i%2),int(i/2)\n", "\n", "\n", " for ix,key in enumerate(quant_bars):\n", " r1 = np.arange(len(quant_bars[key]['bar']))\n", " r2 = [x+ix*barWidth for x in r1]\n", " axs[x][y].bar(r2, quant_bars[key]['bar'], width = barWidth, edgecolor = 'black', yerr=quant_bars[key]['yerr'], label=quant_bars[key]['label'])\n", " \n", " # general layout\n", " axs[x][y].tick_params(axis='both', which='major', labelsize=6)\n", " axs[x][y].set_xticks([r+1.5*barWidth for r in range(len(quant_bars[key]['bar']))], sample_sizes_labels)\n", " axs[x][y].set_ylabel('error')\n", " if i==2:\n", " axs[x][y].legend(loc=1, prop={'size': 6})\n", " axs[x][y].set_xlabel('Drift Size:{}'.format(drift_magnitude))\n", " axs[x][y].set_ylim(bottom=0)\n", " fig.text(.5, -0.05, \"KS pvalue mean abs. error according to sample size for {} distribution and varying drift magnitudes. K=1024\".format(quant_bars[key]['distribution']), ha='center',fontsize=10)\n", "\n", "\n", " plt.show()\n" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "from whylogs.core.resolvers import Resolver\n", "from whylogs.core.datatypes import DataType\n", "from typing import Dict, List\n", "from typing_extensions import TypedDict\n", "from whylogs.core.metrics import StandardMetric\n", "from whylogs.core.metrics.metrics import Metric\n", "import whylogs as why\n", "from whylogs.core import DatasetSchema\n", "from whylogs.core import MetricConfig\n", "import io\n", "import pandas as pd\n", "\n", "\n", "class DataFrameSize(TypedDict):\n", " sample_frac: float\n", " number_samples: int\n", " number_bytes: int\n", "\n", "\n", "class MyCustomResolver(Resolver):\n", " \"\"\"Resolver that assigns DistributionMetric to every column (which is ok because we only have one numerical column).\"\"\"\n", "\n", " def resolve(self, name: str, why_type: DataType, column_schema) -> Dict[str, Metric]:\n", " metrics: List[StandardMetric] = [StandardMetric.distribution]\n", "\n", " result: Dict[str, Metric] = {}\n", " for m in metrics:\n", " result[m.name] = m.zero(column_schema.cfg)\n", " return result\n", "\n", "def get_parquet_size(df: pd.DataFrame, frac) -> int:\n", " \"\"\"Get the size in bytes of a serialized pandas DF\n", " in parquet format. This is only used when comparing\n", " profiling vs. sampling results.\n", "\n", " Returns\n", " -------\n", " int\n", " number of bytes of serialized dataframe.\n", " \"\"\"\n", " res = DataFrameSize()\n", " with io.BytesIO() as buffer:\n", " df_sampled = df.sample(frac=frac)\n", " df_sampled.to_parquet(buffer)\n", " number_bytes = buffer.tell()\n", " sample_frac = frac\n", " number_samples = len(df_sampled)\n", " return DataFrameSize(sample_frac=sample_frac,number_bytes=number_bytes,number_samples=number_samples)" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "from numpy.random import Generator, PCG64\n", "import pandas as pd\n", "\n", "def get_kll_size_map(kll_list:list):\n", " \"\"\"\n", " This is just to find the proper number of samples and size in bytes to match sizes between profiles and sampled dataframes.\n", " Distribution type does not affect significantly the output.\n", " \"\"\"\n", " rng = Generator(PCG64(42))\n", " distribution=\"normal\"\n", " sample_size = 100000\n", " drift_magnitude = 0\n", " ref, target = pd.DataFrame(), pd.DataFrame()\n", " ref[\"col\"] = generate_data(distribution=distribution, generator=rng, drift_magnitude=0, size=sample_size)\n", " kllSizeMap = {}\n", " for kll_val in kll_list:\n", " ref_view = why.log(ref, schema=DatasetSchema(default_configs=MetricConfig(kll_k_large=kll_val),resolvers=MyCustomResolver())).profile().view()\n", " ref_size = len(ref_view.serialize())\n", " closest_sample = DataFrameSize()\n", " distance = 10000000\n", " for frac in list(np.linspace(0.0001,0.2,200)):\n", " sample_size = get_parquet_size(ref,frac=frac)\n", " if abs(ref_size-sample_size[\"number_bytes\"]) < distance:\n", " closest_sample = sample_size\n", " distance = abs(ref_size-sample_size[\"number_bytes\"])\n", " kllSizeMap[kll_val] = closest_sample\n", " return kllSizeMap\n", "\n", "kll_list = [256,512,1024,2048,4096]\n", "kllSizeMap = get_kll_size_map(kll_list=kll_list)" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [], "source": [ "from scipy import stats\n", "from whylogs.viz.utils.drift_calculations import calculate_drift_values\n", "\n", "def run_kll_experiment(distribution=\"normal\", magnitudes = [0,0.01,0.05,0.1], kllSizeMap:dict = {}):\n", " \"\"\"Runs experiment on different KLL_K parameters. \n", "\n", " Parameters\n", " ----------\n", " distribution : str, optional\n", " distribution type. normal, pareto or uniform, by default \"normal\"\n", " magnitudes : list, optional\n", " drift magnitudes, by default [0,0.01,0.05,0.1]\n", " kllSizeMap : dict, optional\n", " Relation between profile and sampled df for a given KLL_K, by default {}\n", "\n", " Returns\n", " -------\n", " dict\n", " Statistics such as errors and size in KB for different KLL_K parameters for profile case,\n", " and for dfs sampled on different ratios for sampling case.\n", " \"\"\"\n", " kll_list = [int(key) for key in kllSizeMap]\n", " sample_size = 100000\n", " kll_bars = {}\n", " for drift_magnitude in magnitudes:\n", " rng = Generator(PCG64(random_seed))\n", " kll_bars[drift_magnitude] = {}\n", " ref, target = pd.DataFrame(), pd.DataFrame()\n", " ref[\"col\"] = generate_data(distribution=distribution, generator=rng, drift_magnitude=0, size=sample_size)\n", " target[\"col\"] = generate_data(distribution=distribution, generator=rng, drift_magnitude=drift_magnitude, size=sample_size)\n", "\n", " for kll_val in kll_list:\n", " kll_bars[drift_magnitude][kll_val] = {}\n", " scipy_res = stats.ks_2samp(ref[\"col\"], target[\"col\"], mode='asymp')\n", " scipy_pvalue = scipy_res.pvalue\n", "\n", " profiled_pvalues = []\n", " sampled_pvalues = []\n", " for i in range(10):\n", " ref_profile = why.log(ref, schema=DatasetSchema(default_configs=MetricConfig(kll_k_large=kll_val),resolvers=MyCustomResolver())).profile()\n", " ref_view = ref_profile.view()\n", "\n", " target_profile = why.log(target, schema=DatasetSchema(default_configs=MetricConfig(kll_k_large=kll_val),resolvers=MyCustomResolver())).profile()\n", " target_view = target_profile.view()\n", "\n", " profiled_pvalue = calculate_drift_values(target_view=target_view, reference_view=ref_view)['col']['p_value']\n", "\n", " ref_sampled = ref.sample(frac=kllSizeMap[kll_val]['sample_frac'])\n", " target_sampled = target.sample(frac=kllSizeMap[kll_val]['sample_frac'])\n", "\n", " sampled_pvalue = stats.ks_2samp(ref_sampled[\"col\"], target_sampled[\"col\"],mode='asymp').pvalue\n", "\n", " profiled_pvalues.append(profiled_pvalue)\n", " sampled_pvalues.append(sampled_pvalue)\n", " size_bytes = kllSizeMap[kll_val]['number_bytes']\n", " size_kb = int(size_bytes/1000)\n", " profile_errors = [abs(pv-scipy_pvalue) for pv in profiled_pvalues]\n", " sample_errors = [abs(pv-scipy_pvalue) for pv in sampled_pvalues]\n", "\n", " profile_mean = sum(profile_errors)/len(profile_errors)\n", " sample_mean = sum(sample_errors)/len(sample_errors)\n", "\n", " range_profile_errors = [abs(profile_mean-min(profile_errors)),abs(profile_mean-max(profile_errors))] \n", " range_sample_errors = [abs(sample_mean-min(sample_errors)),abs(sample_mean-max(sample_errors))] \n", "\n", " kll_bars[drift_magnitude][kll_val]['size_kb'] = size_kb\n", " kll_bars[drift_magnitude][kll_val]['profile_bars'] = profile_mean\n", " kll_bars[drift_magnitude][kll_val]['sample_bars'] = sample_mean\n", " kll_bars[drift_magnitude][kll_val]['profile_yerr'] = range_profile_errors\n", " kll_bars[drift_magnitude][kll_val]['sample_yerr'] = range_sample_errors\n", " kll_bars[drift_magnitude][kll_val]['distribution'] = distribution\n", " return kll_bars" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "import matplotlib.pyplot as plt\n", "\n", "def plot_kll_experiment(bars_per_kll_per_drift, include_sampling=True):\n", " \"\"\"Plots kll experiments for different magnitudes (expects 4).\n", "\n", " Parameters\n", " ----------\n", " bars_per_kll_per_drift : dict\n", " KLL Experiment results.\n", " include_sampling : bool, optional\n", " If false, plots only errors for the profiling case, by default True\n", " \"\"\" \n", " matplotlib.rc_file_defaults()\n", " fig, axs = plt.subplots(2,2)\n", " fig.tight_layout(pad=1.0)\n", " barWidth = 0.17\n", " for i,drift_magnitude in enumerate(bars_per_kll_per_drift):\n", " x,y = int(i%2),int(i/2)\n", " bars_per_kll = bars_per_kll_per_drift[drift_magnitude] \n", " profile_bars = [bars_per_kll[key]['profile_bars'] for key in bars_per_kll]\n", " sample_bars = [bars_per_kll[key]['sample_bars'] for key in bars_per_kll]\n", " \n", " profile_error = [[bars_per_kll[key]['profile_yerr'][0] for key in bars_per_kll],[bars_per_kll[key]['profile_yerr'][1] for key in bars_per_kll]]\n", " size_kb = [\"{} KB\".format(bars_per_kll[key]['size_kb']) for key in bars_per_kll]\n", "\n", " r1 = np.arange(len(profile_bars))\n", " r2 = [x + barWidth for x in r1]\n", "\n", " if include_sampling:\n", " sample_error = [[bars_per_kll[key]['sample_yerr'][0] for key in bars_per_kll],[bars_per_kll[key]['sample_yerr'][1] for key in bars_per_kll]]\n", " axs[x][y].bar(r2, sample_bars, color='tab:blue', yerr = sample_error, width=barWidth,label='Sampled')\n", " axs[x][y].set_xticks([r+1*barWidth for r in range(len(profile_bars))], size_kb)\n", " else:\n", " axs[x][y].set_xticks([r for r in range(len(profile_bars))], size_kb)\n", " axs[x][y].tick_params(axis='both', which='major', labelsize=6)\n", " axs[x][y].bar(r1, profile_bars, color='tab:orange', yerr = profile_error, width=barWidth,label='Profiled')\n", " axs[x][y].set_xlabel('Drift Size:{}'.format(drift_magnitude))\n", " axs[x][y].set_ylabel('error')\n", " axs[x][y].set_ylim(bottom=0)\n", "\n", " if i==2:\n", " axs[x][y].legend(loc=1)\n", " first_key = list(bars_per_kll.keys())[0]\n", " if include_sampling:\n", " fig.text(.5, -0.05, \"KS pvalue mean abs. error comparison between profiling and sampling. {} distribution. Sample size = 100 000.\".format(bars_per_kll[first_key]['distribution']), ha='center',fontsize=10)\n", " else:\n", " fig.text(.5, -0.05, \"KS pvalue mean abs. error for profiling. {} distribution. Sample size = 100 000.\".format(bars_per_kll[first_key]['distribution']), ha='center',fontsize=10)\n", "\n", " plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Normal Distribution" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Drift Injection" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plot_drift(distribution=\"normal\", magnitudes=drift_magnitudes)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Running the Experiment" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [], "source": [ "quant_bars_per_drift = run_experiment_on_params(distribution=\"normal\",magnitudes = drift_magnitudes)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Experiment #1 - Data Volume" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plot_pvalues(quant_bars_per_drift)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Experiment #2 - No. of Buckets" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plot_buckets_experiment(quant_bars_per_drift)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "- sensitive enough to get very small drift magnitude\n", "- overall trend the same, ground truth pretty much within profiling empirical error bounds\n", "- all but one point would yield the same result (drift/no-drift)\n", "- last point for no drift is arguably wrong, as there's no drift\n", "- oddly enough, even though whylogs is further from the ground truth, it is closer to the expected value, which is no drift (for the first case)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Experiment #3 - Profile Size" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [], "source": [ "kll_bars = run_kll_experiment(distribution=\"normal\",magnitudes=drift_magnitudes, kllSizeMap=kllSizeMap)" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plot_kll_experiment(kll_bars, include_sampling=False)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "- Error inversely proportional to Profile Size: By increasing the profile size, the errors due to profiling decreases, and it gets closer to the standard approach.\n", "- again, KS is so sensitive that when any drift is present, both approaches go directly to 0" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Pareto Distribution" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plot_drift(distribution=\"pareto\", magnitudes=drift_magnitudes)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Running the Experiments" ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [], "source": [ "quant_bars_per_drift = run_experiment_on_params(distribution=\"pareto\",magnitudes = drift_magnitudes)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Experiment #1 - Data Volume" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plot_pvalues(quant_bars_per_drift)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Experiment #2 - No. of Buckets" ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plot_buckets_experiment(quant_bars_per_drift)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Experiment #3 - Profile Size" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [], "source": [ "kll_bars = run_kll_experiment(distribution=\"pareto\",magnitudes=drift_magnitudes, kllSizeMap=kllSizeMap)" ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plot_kll_experiment(kll_bars, include_sampling=False)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Uniform Distribution" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plot_drift(distribution=\"uniform\", magnitudes=drift_magnitudes)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Running the Experiment" ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [], "source": [ "quant_bars_per_drift = run_experiment_on_params(distribution=\"uniform\",magnitudes = drift_magnitudes)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Experiment #1 - Data Volume" ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plot_pvalues(quant_bars_per_drift)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Experiment #2 - No. of buckets" ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plot_buckets_experiment(quant_bars_per_drift)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Experiment #3 - Profile Size" ] }, { "cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [], "source": [ "kll_bars = run_kll_experiment(distribution=\"uniform\",magnitudes=drift_magnitudes, kllSizeMap=kllSizeMap)" ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plot_kll_experiment(kll_bars, include_sampling=False)" ] } ], "metadata": { "kernelspec": { "display_name": ".venv", "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.10" }, "orig_nbformat": 4, "vscode": { "interpreter": { "hash": "5dd5901cadfd4b29c2aaf95ecd29c0c3b10829ad94dcfe59437dbee391154aea" } } }, "nbformat": 4, "nbformat_minor": 2 }