From a9282daa84f6a05dc789c2765afb579f1de20c01 Mon Sep 17 00:00:00 2001 From: krmayankb Date: Tue, 11 Oct 2022 11:45:37 -0700 Subject: [PATCH 001/258] added basic regression ranking --- cleanlab/regression/__init__.py | 1 + cleanlab/regression/rank.py | 24 ++++++++++++++++++++++++ 2 files changed, 25 insertions(+) create mode 100644 cleanlab/regression/__init__.py create mode 100644 cleanlab/regression/rank.py diff --git a/cleanlab/regression/__init__.py b/cleanlab/regression/__init__.py new file mode 100644 index 0000000000..77e9b5a97b --- /dev/null +++ b/cleanlab/regression/__init__.py @@ -0,0 +1 @@ +from . import rank \ No newline at end of file diff --git a/cleanlab/regression/rank.py b/cleanlab/regression/rank.py new file mode 100644 index 0000000000..2cd91694c3 --- /dev/null +++ b/cleanlab/regression/rank.py @@ -0,0 +1,24 @@ +import numpy as np + +def get_label_quality_score( + true_labels: np.ndarray, + pred_labels: np.ndarray +)-> np.ndarray: + """ + Returns label quality score + + Score is continous value in range [0,1] + + 1 - clean label (given label is likely correct). + 0 - dirty label (given label is likely incorrect). + """ + residual = true_labels - pred_labels + quality_scores = np.exp(-abs(residual)) + return quality_scores + + +if __name__ == "__main__": +## WILL BE DELETED LATER + a = np.array([1,2,3,4]) + b = np.array([2,2,5,4.1]) + print(get_label_quality_score(a,b)) From 05035950d782fee4adde8da6c44afb47953fb5db Mon Sep 17 00:00:00 2001 From: krmayankb Date: Fri, 4 Nov 2022 14:17:40 -0700 Subject: [PATCH 002/258] minor fixes, docstring modified --- cleanlab/regression/__init__.py | 2 +- cleanlab/regression/rank.py | 56 +++++++++++++++++++++++---------- 2 files changed, 40 insertions(+), 18 deletions(-) diff --git a/cleanlab/regression/__init__.py b/cleanlab/regression/__init__.py index 77e9b5a97b..aab0b677cf 100644 --- a/cleanlab/regression/__init__.py +++ b/cleanlab/regression/__init__.py @@ -1 +1 @@ -from . import rank \ No newline at end of file +from . import rank diff --git a/cleanlab/regression/rank.py b/cleanlab/regression/rank.py index 2cd91694c3..2b4520b1b7 100644 --- a/cleanlab/regression/rank.py +++ b/cleanlab/regression/rank.py @@ -1,24 +1,46 @@ -import numpy as np +import numpy as np -def get_label_quality_score( - true_labels: np.ndarray, - pred_labels: np.ndarray -)-> np.ndarray: + +def get_label_quality_scores(labels: np.ndarray, pred_labels: np.ndarray) -> np.ndarray: """ - Returns label quality score - - Score is continous value in range [0,1] - + Returns label quality score for each example in the regression dataset. + + Each score is continous value in range [0,1] 1 - clean label (given label is likely correct). 0 - dirty label (given label is likely incorrect). + + Parameters + ---------- + labels: + Raw labels from original dataset. + Array of shape ``(N, )`` consisting given labels, where N is number of datapoints in the regression dataset. + + pred_labels: + Predicated labels from regressor fitted on the dataset. + Array of shape ``(N,)`` consisting predicted labels, where N is number of datapoints in the regression dataset. + + Returns + ------- + label_quality_scores: + Array of shape ``(N, )`` of scores between 0 and 1, one per datapoint in the dataset. + + Lower scores indicate datapoint more likely to contain a label issue. + + Examples + -------- + >>> import numpy as np + >>> from cleanlab.regression.rank import get_label_quality_scores + >>> labels = np.array([1,2,3,4]) + >>> pred_labels = np.array([2,2,5,4.1]) + >>> label_quality_scores = get_label_quality_scores(labels, pred_labels) + >>> label_quality_scores + array([0.36787944, 1. , 0.13533528, 0.90483742]) """ - residual = true_labels - pred_labels - quality_scores = np.exp(-abs(residual)) - return quality_scores + assert ( + labels.shape == pred_labels.shape + ), f"shape of label {labels.shape} and predicted labels {pred_labels.shape} are not same." -if __name__ == "__main__": -## WILL BE DELETED LATER - a = np.array([1,2,3,4]) - b = np.array([2,2,5,4.1]) - print(get_label_quality_score(a,b)) + residual = pred_labels - labels + quality_scores = np.exp(-abs(residual)) + return quality_scores From 0a0c41e69df2232a5eb615bd47815896acd77461 Mon Sep 17 00:00:00 2001 From: krmayankb Date: Wed, 9 Nov 2022 17:25:35 -0800 Subject: [PATCH 003/258] tutorial added, added to docs index pages --- cleanlab/__init__.py | 1 + cleanlab/regression/rank.py | 2 + docs/source/cleanlab/regression.rst | 8 + docs/source/tutorials/index.rst | 1 + docs/source/tutorials/regression.ipynb | 338 +++++++++++++++++++++++++ 5 files changed, 350 insertions(+) create mode 100644 docs/source/cleanlab/regression.rst create mode 100644 docs/source/tutorials/regression.ipynb diff --git a/cleanlab/__init__.py b/cleanlab/__init__.py index 991eaecbb9..46b87525d1 100644 --- a/cleanlab/__init__.py +++ b/cleanlab/__init__.py @@ -8,3 +8,4 @@ from . import multiannotator from . import outlier from . import token_classification +from . import regression diff --git a/cleanlab/regression/rank.py b/cleanlab/regression/rank.py index 2b4520b1b7..2fdde78299 100644 --- a/cleanlab/regression/rank.py +++ b/cleanlab/regression/rank.py @@ -1,5 +1,7 @@ import numpy as np +""" generate label quality score for regression dataset""" + def get_label_quality_scores(labels: np.ndarray, pred_labels: np.ndarray) -> np.ndarray: """ diff --git a/docs/source/cleanlab/regression.rst b/docs/source/cleanlab/regression.rst new file mode 100644 index 0000000000..1cae31915a --- /dev/null +++ b/docs/source/cleanlab/regression.rst @@ -0,0 +1,8 @@ +regression +============== + +.. automodule:: cleanlab.regression + :autosummary: + :members: + :undoc-members: + :show-inheritance: diff --git a/docs/source/tutorials/index.rst b/docs/source/tutorials/index.rst index 1fc00488be..a45367135f 100644 --- a/docs/source/tutorials/index.rst +++ b/docs/source/tutorials/index.rst @@ -15,3 +15,4 @@ Tutorials token_classification pred_probs_cross_val faq + regression diff --git a/docs/source/tutorials/regression.ipynb b/docs/source/tutorials/regression.ipynb new file mode 100644 index 0000000000..46f3b5ee38 --- /dev/null +++ b/docs/source/tutorials/regression.ipynb @@ -0,0 +1,338 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Label Quality Scores for Regression with Noisy Labels\n", + "In this tutorial, you will learn how to use cleanlab on regression dataset to: \n", + "- find label issue in your regression dataset\n", + "- generate label quality scores for each example in the dataset. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Install dependencies and import them \n", + "You can use pip to install all packages required for this tutorial as follows:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "!pip install cleanlab\n", + "!pip install scikit-learn" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np \n", + "import pandas as pd \n", + "from cleanlab.regression.rank import get_label_quality_scores\n", + "from sklearn.linear_model import LinearRegression\n", + "import matplotlib.pyplot as plt " + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "def make_data(feature_size = (20, 3), \n", + " means = [8, 20, -10], \n", + " stds = [2, 5, 3], \n", + " bias = 0.8,\n", + " coeff = [2, 0.1, 0.5],\n", + " error = [-2, 0, 2], \n", + " prob_error = [0.2, 0.6, 0.2], \n", + " seed = 42\n", + ") -> pd.DataFrame:\n", + " \"\"\"\n", + " feature_size: Tuple of (datapoints, features)\n", + " \"\"\"\n", + " assert (len(means) == feature_size[1]), (f\"length of mean {len(means)} is not same as features requested{feature_size[0]}\")\n", + " assert (len(stds) == feature_size[1]), (f\"length of stds {len(stds)} is not same as features requested{feature_size[0]}\")\n", + " np.random.seed(seed) \n", + "\n", + " features = []\n", + " for i in range(feature_size[1]):\n", + " values = coeff[i] * np.random.normal(loc=means[i], scale=stds[i], size=feature_size[0])\n", + " features.append(values)\n", + " \n", + " true_labels = sum(map(np.array, features))+ bias\n", + " labels = true_labels + np.random.choice(error, feature_size[0], p=prob_error)\n", + " \n", + " data_dict = {\n", + " \"lables\" : labels, # You have these labels, which have some errors.\n", + " \"true_labels\" : true_labels, # You never get to see these perfect labels.\n", + " } \n", + " for idx, feature in enumerate(features): # adding names to each features \n", + " data_dict[\"feature_\"+str(idx+1)] = feature\n", + " data = pd.DataFrame.from_dict(data_dict)\n", + " col = list(data.columns)\n", + " new_col = col[2:] + col[:2]\n", + " data = data.reindex(columns=new_col)\n", + " return data\n", + "\n", + "def plot_data(data, \n", + " circles, \n", + " title, \n", + " alpha=0.6, \n", + " color = '#1f77b4', \n", + " xlabel = \"feature\", \n", + " colorbar = False):\n", + " \n", + " plt.figure(figsize=(14, 5))\n", + " plt.xlabel(xlabel, size=13)\n", + " plt.ylabel('label',size=13)\n", + " data = data.to_numpy()\n", + " plt.scatter(data[:,0], data[:,1], c = color, s=60)\n", + " for i in circles:\n", + " plt.plot(\n", + " data[i][0],\n", + " data[i][1],\n", + " \"o\",\n", + " markerfacecolor=\"none\",\n", + " markeredgecolor=\"red\",\n", + " markersize=14,\n", + " markeredgewidth=2.5,\n", + " alpha=alpha\n", + " )\n", + " plt.title(title, fontsize=20)\n", + " \n", + " if colorbar: plt.colorbar(orientation = 'vertical')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "data = make_data(feature_size=(100,3))\n", + "true_errors = np.where(data['true_labels'] != data['lables'])[0]\n", + "plot_data(data[['feature_1','lables']], circles=true_errors, title=\"Messy Regression dataset\", xlabel=\"feature_1\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The figure above represents a toy dataset we'll use to demostrate label scoring for regression dataset. In this example, lables are ploted w.r.t. one of the features of the dataset. \n", + "\n", + "Like many real-world datasets, the given label happen to be incorrect for some of the examples(**circled in red**) in this dataset. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Using cleanlab to generate label quality scores" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
feature_1feature_2feature_3lablestrue_labels
017.9868571.292315-4.46331915.61585215.615852
115.4469431.789677-4.15882311.87779713.877797
218.5907541.828643-3.37542317.84397417.843974
322.0921191.598861-3.41929723.07168421.071684
415.0633871.919357-7.06650412.71624010.716240
\n", + "
" + ], + "text/plain": [ + " feature_1 feature_2 feature_3 lables true_labels\n", + "0 17.986857 1.292315 -4.463319 15.615852 15.615852\n", + "1 15.446943 1.789677 -4.158823 11.877797 13.877797\n", + "2 18.590754 1.828643 -3.375423 17.843974 17.843974\n", + "3 22.092119 1.598861 -3.419297 23.071684 21.071684\n", + "4 15.063387 1.919357 -7.066504 12.716240 10.716240" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# start with checking the dataset generated\n", + "data.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# Note that \"true_labels\" will not be available in real-life dataset. We have added here only for comparision.\n", + "X = data[['feature_'+str(i+1) for i in range(3)]]\n", + "y = data['lables']\n", + "\n", + "# initialize your favourite model and generate predictions \n", + "yourFavouriteModel = LinearRegression()\n", + "yourFavouriteModel = yourFavouriteModel.fit(X,y)\n", + "predictions = yourFavouriteModel.predict(X)\n", + "\n", + "# get label quality score for each example in the dataset \n", + "label_quality = get_label_quality_scores(labels=np.array(data['lables']), pred_labels=predictions)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_data(\n", + " data[['feature_1','lables']], \n", + " circles=true_errors ,\n", + " color=label_quality, \n", + " title=\"Messy Regression dataset with label quality scores\", \n", + " colorbar=True, \n", + " xlabel = \"feature_1\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In the above plot, we have colored each datapoint considering its label quality score. \\\n", + "Datapoints in the plot are same as earlier plot in the notebook. **Red circle** represents that these datapoint were incorrectly marked when compared to true_label. \n", + "\n", + "Low scores for datapoints marked in **Red circle** and High scores for other datapoints justifies that method can identify the errors in the dataset. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.10.8 ('ENV': 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.10.8" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "1ed33b5e6ac3d9870092cd802185bba6fb7a8302b6022e7097221f18c33cb7b2" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From f4a8d17d1499a17ae2f6de2bca43fb40e1180d0a Mon Sep 17 00:00:00 2001 From: krmayankb Date: Thu, 10 Nov 2022 12:44:24 -0800 Subject: [PATCH 004/258] unit tests added --- cleanlab/regression/rank.py | 5 ++++- tests/test_regression.py | 27 +++++++++++++++++++++++++++ 2 files changed, 31 insertions(+), 1 deletion(-) create mode 100644 tests/test_regression.py diff --git a/cleanlab/regression/rank.py b/cleanlab/regression/rank.py index 2fdde78299..54c38577f1 100644 --- a/cleanlab/regression/rank.py +++ b/cleanlab/regression/rank.py @@ -1,6 +1,6 @@ import numpy as np -""" generate label quality score for regression dataset""" +""" generate label quality score for regression dataset """ def get_label_quality_scores(labels: np.ndarray, pred_labels: np.ndarray) -> np.ndarray: @@ -39,6 +39,9 @@ def get_label_quality_scores(labels: np.ndarray, pred_labels: np.ndarray) -> np. array([0.36787944, 1. , 0.13533528, 0.90483742]) """ + if not isinstance(labels, np.ndarray) or not isinstance(pred_labels, np.ndarray): + raise TypeError("labels and pred_labels must be of type np.ndarray") + assert ( labels.shape == pred_labels.shape ), f"shape of label {labels.shape} and predicted labels {pred_labels.shape} are not same." diff --git a/tests/test_regression.py b/tests/test_regression.py new file mode 100644 index 0000000000..71de96cf3c --- /dev/null +++ b/tests/test_regression.py @@ -0,0 +1,27 @@ +import numpy as np +import pandas as pd +import pytest + +from cleanlab.regression.rank import get_label_quality_scores + +# To be used for all the tests +labels = np.array([1, 2, 3, 4]) +pred_labels = np.array([1, 3, 4, 5]) + + +def test_output_shape_type(): + scores = get_label_quality_scores(labels=labels, pred_labels=pred_labels) + assert labels.shape == scores.shape + assert isinstance(scores, np.ndarray) + + +@pytest.mark.parametrize("format", [pd.Series, pd.DataFrame, list]) +def test_type_error_for_input_types(format): + with pytest.raises(TypeError) as error: + _ = get_label_quality_scores(labels=format(labels), pred_labels=format(pred_labels)) + + +def test_assertion_error_for_input_shape(): + with pytest.raises(AssertionError) as error: + _ = get_label_quality_scores(labels=labels[:-1], pred_labels=pred_labels) + _ = get_label_quality_scores(labels=labels, pred_labels=pred_labels[:-1]) From 5aee14192d6dee8f5340adadb50331e55079b140 Mon Sep 17 00:00:00 2001 From: krmayankb Date: Thu, 10 Nov 2022 12:47:49 -0800 Subject: [PATCH 005/258] reindexed tutorial, punctuation fix for docstring --- cleanlab/regression/rank.py | 2 +- docs/source/tutorials/index.rst | 3 ++- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/cleanlab/regression/rank.py b/cleanlab/regression/rank.py index 54c38577f1..6f8ad48323 100644 --- a/cleanlab/regression/rank.py +++ b/cleanlab/regression/rank.py @@ -1,6 +1,6 @@ import numpy as np -""" generate label quality score for regression dataset """ +""" Generates label quality scores for every sample in regression dataset """ def get_label_quality_scores(labels: np.ndarray, pred_labels: np.ndarray) -> np.ndarray: diff --git a/docs/source/tutorials/index.rst b/docs/source/tutorials/index.rst index a45367135f..817161c40b 100644 --- a/docs/source/tutorials/index.rst +++ b/docs/source/tutorials/index.rst @@ -13,6 +13,7 @@ Tutorials outliers multiannotator token_classification + regression pred_probs_cross_val faq - regression + From 03fbc18f73017d5c7556a6f38186f62ee4f96999 Mon Sep 17 00:00:00 2001 From: krmayankb Date: Tue, 15 Nov 2022 15:51:04 -0800 Subject: [PATCH 006/258] plots changed in tutorial notebook --- docs/source/tutorials/regression.ipynb | 99 ++++++++++++-------------- 1 file changed, 47 insertions(+), 52 deletions(-) diff --git a/docs/source/tutorials/regression.ipynb b/docs/source/tutorials/regression.ipynb index 46f3b5ee38..92bc78ff13 100644 --- a/docs/source/tutorials/regression.ipynb +++ b/docs/source/tutorials/regression.ipynb @@ -30,7 +30,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -43,15 +43,15 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ - "def make_data(feature_size = (20, 3), \n", - " means = [8, 20, -10], \n", - " stds = [2, 5, 3], \n", + "def make_data(feature_size = (20, 2), \n", + " means = [8, -10], \n", + " stds = [2, 5], \n", " bias = 0.8,\n", - " coeff = [2, 0.1, 0.5],\n", + " coeff = [2, 0.1],\n", " error = [-2, 0, 2], \n", " prob_error = [0.2, 0.6, 0.2], \n", " seed = 42\n", @@ -88,12 +88,9 @@ " title, \n", " alpha=0.6, \n", " color = '#1f77b4', \n", - " xlabel = \"feature\", \n", " colorbar = False):\n", " \n", " plt.figure(figsize=(14, 5))\n", - " plt.xlabel(xlabel, size=13)\n", - " plt.ylabel('label',size=13)\n", " data = data.to_numpy()\n", " plt.scatter(data[:,0], data[:,1], c = color, s=60)\n", " for i in circles:\n", @@ -114,14 +111,14 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 10, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -129,16 +126,20 @@ } ], "source": [ - "data = make_data(feature_size=(100,3))\n", + "data = make_data(feature_size=(100, 2))\n", "true_errors = np.where(data['true_labels'] != data['lables'])[0]\n", - "plot_data(data[['feature_1','lables']], circles=true_errors, title=\"Messy Regression dataset\", xlabel=\"feature_1\")" + "plot_data(data[['feature_1','feature_2']], \n", + " circles=true_errors, \n", + " color=data['lables'], \n", + " colorbar=True, \n", + " title=\"Messy Regression dataset\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "The figure above represents a toy dataset we'll use to demostrate label scoring for regression dataset. In this example, lables are ploted w.r.t. one of the features of the dataset. \n", + "The figure above represents a toy dataset we'll use to demonstrate label scoring for regression dataset. In this example, datapoints are ploted on 2-D space (in this case feature_1 vs feature_2). Each datapoint is colored based on given label. \n", "\n", "Like many real-world datasets, the given label happen to be incorrect for some of the examples(**circled in red**) in this dataset. " ] @@ -152,7 +153,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -178,7 +179,6 @@ " \n", " feature_1\n", " feature_2\n", - " feature_3\n", " lables\n", " true_labels\n", " \n", @@ -187,57 +187,52 @@ " \n", " 0\n", " 17.986857\n", - " 1.292315\n", - " -4.463319\n", - " 15.615852\n", - " 15.615852\n", + " -1.707685\n", + " 19.079171\n", + " 17.079171\n", " \n", " \n", " 1\n", " 15.446943\n", - " 1.789677\n", - " -4.158823\n", - " 11.877797\n", - " 13.877797\n", + " -1.210323\n", + " 15.036620\n", + " 15.036620\n", " \n", " \n", " 2\n", " 18.590754\n", - " 1.828643\n", - " -3.375423\n", - " 17.843974\n", - " 17.843974\n", + " -1.171357\n", + " 18.219397\n", + " 18.219397\n", " \n", " \n", " 3\n", " 22.092119\n", - " 1.598861\n", - " -3.419297\n", - " 23.071684\n", - " 21.071684\n", + " -1.401139\n", + " 21.490981\n", + " 21.490981\n", " \n", " \n", " 4\n", " 15.063387\n", - " 1.919357\n", - " -7.066504\n", - " 12.716240\n", - " 10.716240\n", + " -1.080643\n", + " 14.782744\n", + " 14.782744\n", " \n", " \n", "\n", "" ], "text/plain": [ - " feature_1 feature_2 feature_3 lables true_labels\n", - "0 17.986857 1.292315 -4.463319 15.615852 15.615852\n", - "1 15.446943 1.789677 -4.158823 11.877797 13.877797\n", - "2 18.590754 1.828643 -3.375423 17.843974 17.843974\n", - "3 22.092119 1.598861 -3.419297 23.071684 21.071684\n", - "4 15.063387 1.919357 -7.066504 12.716240 10.716240" + " feature_1 feature_2 lables true_labels\n", + "0 17.986857 -1.707685 19.079171 17.079171\n", + "1 15.446943 -1.210323 15.036620 15.036620\n", + "2 18.590754 -1.171357 18.219397 18.219397\n", + "3 22.092119 -1.401139 21.490981 21.490981\n", + "4 15.063387 -1.080643 14.782744 14.782744" ] }, - "execution_count": 5, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" } @@ -249,12 +244,12 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ "# Note that \"true_labels\" will not be available in real-life dataset. We have added here only for comparision.\n", - "X = data[['feature_'+str(i+1) for i in range(3)]]\n", + "X = data[['feature_'+str(i+1) for i in range(2)]]\n", "y = data['lables']\n", "\n", "# initialize your favourite model and generate predictions \n", @@ -268,12 +263,12 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 17, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -284,12 +279,11 @@ ], "source": [ "plot_data(\n", - " data[['feature_1','lables']], \n", + " data[['feature_1','feature_2']], \n", " circles=true_errors ,\n", " color=label_quality, \n", " title=\"Messy Regression dataset with label quality scores\", \n", - " colorbar=True, \n", - " xlabel = \"feature_1\")" + " colorbar=True)" ] }, { @@ -297,7 +291,8 @@ "metadata": {}, "source": [ "In the above plot, we have colored each datapoint considering its label quality score. \\\n", - "Datapoints in the plot are same as earlier plot in the notebook. **Red circle** represents that these datapoint were incorrectly marked when compared to true_label. \n", + "Datapoints in the plot are same as earlier plot in the notebook. \\\n", + "**Red circle** represents that these datapoint were incorrectly marked when compared to true_label. \n", "\n", "Low scores for datapoints marked in **Red circle** and High scores for other datapoints justifies that method can identify the errors in the dataset. " ] From 29d60800bf7f73214b477bb300f6f1ba222089cf Mon Sep 17 00:00:00 2001 From: krmayankb Date: Wed, 7 Dec 2022 22:30:18 -0700 Subject: [PATCH 007/258] typo fix --- docs/source/tutorials/regression.ipynb | 132 ++++++++++++++++++++++--- 1 file changed, 118 insertions(+), 14 deletions(-) diff --git a/docs/source/tutorials/regression.ipynb b/docs/source/tutorials/regression.ipynb index 92bc78ff13..b4770e47d1 100644 --- a/docs/source/tutorials/regression.ipynb +++ b/docs/source/tutorials/regression.ipynb @@ -30,7 +30,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -43,7 +43,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 21, "metadata": {}, "outputs": [], "source": [ @@ -72,7 +72,7 @@ " labels = true_labels + np.random.choice(error, feature_size[0], p=prob_error)\n", " \n", " data_dict = {\n", - " \"lables\" : labels, # You have these labels, which have some errors.\n", + " \"labels\" : labels, # You have these labels, which have some errors.\n", " \"true_labels\" : true_labels, # You never get to see these perfect labels.\n", " } \n", " for idx, feature in enumerate(features): # adding names to each features \n", @@ -111,7 +111,111 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 22, + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
exam_1exam_2exam_3bonus_or_penaltytrue_labelslabels
0537793076.256.2
18164801085.565.5
2748897087.467.4
3619478077.757.7
4489091077.877.8
\n", + "
" + ], + "text/plain": [ + " exam_1 exam_2 exam_3 bonus_or_penalty true_labels labels\n", + "0 53 77 93 0 76.2 56.2\n", + "1 81 64 80 10 85.5 65.5\n", + "2 74 88 97 0 87.4 67.4\n", + "3 61 94 78 0 77.7 57.7\n", + "4 48 90 91 0 77.8 77.8" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "path = \"/Users/krmayank/Desktop/Work/cleanlab/experiments/student_score_regression.csv\"\n", + "data = pd.read_csv(path, index_col=0)\n", + "data.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 23, "metadata": {}, "outputs": [ { @@ -127,10 +231,10 @@ ], "source": [ "data = make_data(feature_size=(100, 2))\n", - "true_errors = np.where(data['true_labels'] != data['lables'])[0]\n", + "true_errors = np.where(data['true_labels'] != data['labels'])[0]\n", "plot_data(data[['feature_1','feature_2']], \n", " circles=true_errors, \n", - " color=data['lables'], \n", + " color=data['labels'], \n", " colorbar=True, \n", " title=\"Messy Regression dataset\")" ] @@ -153,7 +257,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 24, "metadata": {}, "outputs": [ { @@ -179,7 +283,7 @@ " \n", " feature_1\n", " feature_2\n", - " lables\n", + " labels\n", " true_labels\n", " \n", " \n", @@ -224,7 +328,7 @@ "" ], "text/plain": [ - " feature_1 feature_2 lables true_labels\n", + " feature_1 feature_2 labels true_labels\n", "0 17.986857 -1.707685 19.079171 17.079171\n", "1 15.446943 -1.210323 15.036620 15.036620\n", "2 18.590754 -1.171357 18.219397 18.219397\n", @@ -232,7 +336,7 @@ "4 15.063387 -1.080643 14.782744 14.782744" ] }, - "execution_count": 11, + "execution_count": 24, "metadata": {}, "output_type": "execute_result" } @@ -244,13 +348,13 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 25, "metadata": {}, "outputs": [], "source": [ "# Note that \"true_labels\" will not be available in real-life dataset. We have added here only for comparision.\n", "X = data[['feature_'+str(i+1) for i in range(2)]]\n", - "y = data['lables']\n", + "y = data['labels']\n", "\n", "# initialize your favourite model and generate predictions \n", "yourFavouriteModel = LinearRegression()\n", @@ -258,12 +362,12 @@ "predictions = yourFavouriteModel.predict(X)\n", "\n", "# get label quality score for each example in the dataset \n", - "label_quality = get_label_quality_scores(labels=np.array(data['lables']), pred_labels=predictions)" + "label_quality = get_label_quality_scores(labels=np.array(data['labels']), pred_labels=predictions)" ] }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 26, "metadata": {}, "outputs": [ { From bf7860ea9b0e0b60947bed49743f84067cf68ab6 Mon Sep 17 00:00:00 2001 From: krmayankb Date: Thu, 8 Dec 2022 23:03:45 -0700 Subject: [PATCH 008/258] cleanlab outlier based scoring method added --- cleanlab/regression/rank.py | 116 ++++++++++++++++++++++++++++++++++-- 1 file changed, 111 insertions(+), 5 deletions(-) diff --git a/cleanlab/regression/rank.py b/cleanlab/regression/rank.py index 6f8ad48323..dcd9460c64 100644 --- a/cleanlab/regression/rank.py +++ b/cleanlab/regression/rank.py @@ -1,9 +1,16 @@ import numpy as np +from cleanlab.outlier import OutOfDistribution +from sklearn.neighbors import NearestNeighbors """ Generates label quality scores for every sample in regression dataset """ -def get_label_quality_scores(labels: np.ndarray, pred_labels: np.ndarray) -> np.ndarray: +def get_label_quality_scores( + labels: np.ndarray, + pred_labels: np.ndarray, + *, + method: str = "residual", +) -> np.ndarray: """ Returns label quality score for each example in the regression dataset. @@ -13,14 +20,16 @@ def get_label_quality_scores(labels: np.ndarray, pred_labels: np.ndarray) -> np. Parameters ---------- - labels: + labels : np.ndarray Raw labels from original dataset. Array of shape ``(N, )`` consisting given labels, where N is number of datapoints in the regression dataset. - pred_labels: + pred_labels : np.ndarray Predicated labels from regressor fitted on the dataset. Array of shape ``(N,)`` consisting predicted labels, where N is number of datapoints in the regression dataset. + method : {"residual", "TO_BE_NAMED"}, default="residual" #TODO - update name once finalised + Returns ------- label_quality_scores: @@ -39,6 +48,7 @@ def get_label_quality_scores(labels: np.ndarray, pred_labels: np.ndarray) -> np. array([0.36787944, 1. , 0.13533528, 0.90483742]) """ + # TODO - add error trigger function in utils. if not isinstance(labels, np.ndarray) or not isinstance(pred_labels, np.ndarray): raise TypeError("labels and pred_labels must be of type np.ndarray") @@ -46,6 +56,102 @@ def get_label_quality_scores(labels: np.ndarray, pred_labels: np.ndarray) -> np. labels.shape == pred_labels.shape ), f"shape of label {labels.shape} and predicted labels {pred_labels.shape} are not same." + scoring_funcs = { + "residual": get_residual_score_for_each_label, + "TO_BE_NAMED": get_score_to_named_for_each_label, # TODO - update name once finalised + } + + # TODO - update name once finalised + try: + scoring_func = scoring_funcs[method] + except KeyError: + raise ValueError( + f""" + {method} is not a valid scoring method. + Please choose a valid scoring technique: residual, TO_BE_NAMED. + """ + ) + + # Calculate scores + label_quality_score = scoring_func(labels, pred_labels) + return label_quality_score + + +def get_residual_score_for_each_label( + labels: np.ndarray, + pred_labels: np.ndarray, +) -> np.ndarray: + """Returns the residual based label-quality scores for each datapoints. + + This is function to compute label-quality scores for regression datasets, + where lower score indicate labels less likely to be correct. + + Residual based scores can work better for datasets where independent variables + are based out of normal distribution. + + Parameters + ---------- + labels: np.ndarray + Labels in the same format expected by the :py:func:`get_label_quality_scores ` function. + + pred_labels: np.ndarray + Predicted labels in the same format expected by the :py:func:`get_label_quality_scores ` function. + + Returns + ------- + label_quality_scores: np.ndarray + Contains one score (between 0 and 1) per example. + Lower scores indicate more likely mislabled examples. + + """ residual = pred_labels - labels - quality_scores = np.exp(-abs(residual)) - return quality_scores + label_quality_scores = np.exp(-abs(residual)) + return label_quality_scores + + +# TODO - change name of the function +def get_score_to_named_for_each_label( + label: np.ndarray, + pred_labels: np.ndarray, + *, + variance: float = 10, +) -> np.ndarray: + """Returns label-quality scores. + + This is function to compute label-quality scores for regression datasets, + where lower score indicate labels less likely to be correct. + + Parameters + ---------- + labels: np.ndarray + Labels in the same format expected by the :py:func:`get_label_quality_scores ` function. + + pred_labels: np.ndarray + Predicted labels in the same format expected by the :py:func:`get_label_quality_scores ` function. + + variance: float, default = 10 + Manipulates variance of the distribution of residual. + + Returns + ------- + label_quality_scores: np.ndarray + Contains one score (between 0 and 1) per example. + Lower scores indicate more likely mislabled examples. + """ + + neighbors = int(np.ceil(0.1 * label.shape[0])) + print(neighbors) + knn = NearestNeighbors(n_neighbors=neighbors, metric="euclidean") + + residual = pred_labels - label + + label = (label - label.mean()) / label.std() + residual = np.sqrt(variance) * ((residual - residual.mean()) / residual.std()) + + # 2D features by combining labels and residual + features = np.array([label, residual]).T + + knn.fit(features) + ood = OutOfDistribution(params={"knn": knn}) + label_quality_scores = ood.score(features=features) + return label_quality_scores From 9bf8a5f5906d800f3c14b886fcd870779ec9c768 Mon Sep 17 00:00:00 2001 From: krmayankb Date: Fri, 9 Dec 2022 11:25:30 -0700 Subject: [PATCH 009/258] regression_utils created --- cleanlab/internal/regression_utils.py | 28 +++++++++++++++++++++++++++ cleanlab/regression/rank.py | 10 +++------- 2 files changed, 31 insertions(+), 7 deletions(-) create mode 100644 cleanlab/internal/regression_utils.py diff --git a/cleanlab/internal/regression_utils.py b/cleanlab/internal/regression_utils.py new file mode 100644 index 0000000000..57c99baedb --- /dev/null +++ b/cleanlab/internal/regression_utils.py @@ -0,0 +1,28 @@ +""" +Helper function internally used in cleanlab.regression +""" + +import numpy as np + + +def assert_valid_inputs( + labels: np.ndarray, + pred_labels: np.ndarray, + method: str, +) -> None: + """Checks that ``labels``, ``pred_labels``, ``method`` are correctly formatted.""" + + # Check if labels and pred_labels are np.ndarray + if not isinstance(labels, np.ndarray) or not isinstance(pred_labels, np.ndarray): + raise TypeError("labels and pred_labels must be of type np.ndarray") + + # Check if labels and pred_labels are of same shape + assert ( + labels.shape == pred_labels.shape + ), f"shape of label {labels.shape} and predicted labels {pred_labels.shape} are not same." + + # Check if method passed is string + if not isinstance(method, str): + raise TypeError( + f"Passed method is not of correct type. Expected string, got {type(method)}" + ) diff --git a/cleanlab/regression/rank.py b/cleanlab/regression/rank.py index dcd9460c64..8d53af9adf 100644 --- a/cleanlab/regression/rank.py +++ b/cleanlab/regression/rank.py @@ -1,6 +1,7 @@ import numpy as np from cleanlab.outlier import OutOfDistribution from sklearn.neighbors import NearestNeighbors +from cleanlab.internal.regression_utils import assert_valid_inputs """ Generates label quality scores for every sample in regression dataset """ @@ -48,13 +49,8 @@ def get_label_quality_scores( array([0.36787944, 1. , 0.13533528, 0.90483742]) """ - # TODO - add error trigger function in utils. - if not isinstance(labels, np.ndarray) or not isinstance(pred_labels, np.ndarray): - raise TypeError("labels and pred_labels must be of type np.ndarray") - - assert ( - labels.shape == pred_labels.shape - ), f"shape of label {labels.shape} and predicted labels {pred_labels.shape} are not same." + # Check if inputs are valid + assert_valid_inputs(labels=labels, pred_labels=pred_labels, method=method) scoring_funcs = { "residual": get_residual_score_for_each_label, From c399ffca26e7b094fdfa71974f81317fb73fedbb Mon Sep 17 00:00:00 2001 From: krmayankb Date: Mon, 12 Dec 2022 09:40:36 -0800 Subject: [PATCH 010/258] pred_labels changed to predictions --- cleanlab/internal/regression_utils.py | 8 ++++---- cleanlab/regression/rank.py | 25 ++++++++++++------------- 2 files changed, 16 insertions(+), 17 deletions(-) diff --git a/cleanlab/internal/regression_utils.py b/cleanlab/internal/regression_utils.py index 57c99baedb..04576c4012 100644 --- a/cleanlab/internal/regression_utils.py +++ b/cleanlab/internal/regression_utils.py @@ -7,19 +7,19 @@ def assert_valid_inputs( labels: np.ndarray, - pred_labels: np.ndarray, + predictions: np.ndarray, method: str, ) -> None: """Checks that ``labels``, ``pred_labels``, ``method`` are correctly formatted.""" # Check if labels and pred_labels are np.ndarray - if not isinstance(labels, np.ndarray) or not isinstance(pred_labels, np.ndarray): + if not isinstance(labels, np.ndarray) or not isinstance(predictions, np.ndarray): raise TypeError("labels and pred_labels must be of type np.ndarray") # Check if labels and pred_labels are of same shape assert ( - labels.shape == pred_labels.shape - ), f"shape of label {labels.shape} and predicted labels {pred_labels.shape} are not same." + labels.shape == predictions.shape + ), f"shape of label {labels.shape} and predicted labels {predictions.shape} are not same." # Check if method passed is string if not isinstance(method, str): diff --git a/cleanlab/regression/rank.py b/cleanlab/regression/rank.py index 8d53af9adf..3784d290b0 100644 --- a/cleanlab/regression/rank.py +++ b/cleanlab/regression/rank.py @@ -8,7 +8,7 @@ def get_label_quality_scores( labels: np.ndarray, - pred_labels: np.ndarray, + predictions: np.ndarray, *, method: str = "residual", ) -> np.ndarray: @@ -25,7 +25,7 @@ def get_label_quality_scores( Raw labels from original dataset. Array of shape ``(N, )`` consisting given labels, where N is number of datapoints in the regression dataset. - pred_labels : np.ndarray + predictions : np.ndarray Predicated labels from regressor fitted on the dataset. Array of shape ``(N,)`` consisting predicted labels, where N is number of datapoints in the regression dataset. @@ -43,14 +43,14 @@ def get_label_quality_scores( >>> import numpy as np >>> from cleanlab.regression.rank import get_label_quality_scores >>> labels = np.array([1,2,3,4]) - >>> pred_labels = np.array([2,2,5,4.1]) - >>> label_quality_scores = get_label_quality_scores(labels, pred_labels) + >>> predictions = np.array([2,2,5,4.1]) + >>> label_quality_scores = get_label_quality_scores(labels, predictions) >>> label_quality_scores array([0.36787944, 1. , 0.13533528, 0.90483742]) """ # Check if inputs are valid - assert_valid_inputs(labels=labels, pred_labels=pred_labels, method=method) + assert_valid_inputs(labels=labels, predictions=predictions, method=method) scoring_funcs = { "residual": get_residual_score_for_each_label, @@ -69,13 +69,13 @@ def get_label_quality_scores( ) # Calculate scores - label_quality_score = scoring_func(labels, pred_labels) + label_quality_score = scoring_func(labels, predictions) return label_quality_score def get_residual_score_for_each_label( labels: np.ndarray, - pred_labels: np.ndarray, + predictions: np.ndarray, ) -> np.ndarray: """Returns the residual based label-quality scores for each datapoints. @@ -90,7 +90,7 @@ def get_residual_score_for_each_label( labels: np.ndarray Labels in the same format expected by the :py:func:`get_label_quality_scores ` function. - pred_labels: np.ndarray + predictions: np.ndarray Predicted labels in the same format expected by the :py:func:`get_label_quality_scores ` function. Returns @@ -100,7 +100,7 @@ def get_residual_score_for_each_label( Lower scores indicate more likely mislabled examples. """ - residual = pred_labels - labels + residual = predictions - labels label_quality_scores = np.exp(-abs(residual)) return label_quality_scores @@ -108,7 +108,7 @@ def get_residual_score_for_each_label( # TODO - change name of the function def get_score_to_named_for_each_label( label: np.ndarray, - pred_labels: np.ndarray, + predictions: np.ndarray, *, variance: float = 10, ) -> np.ndarray: @@ -122,7 +122,7 @@ def get_score_to_named_for_each_label( labels: np.ndarray Labels in the same format expected by the :py:func:`get_label_quality_scores ` function. - pred_labels: np.ndarray + predictions: np.ndarray Predicted labels in the same format expected by the :py:func:`get_label_quality_scores ` function. variance: float, default = 10 @@ -136,10 +136,9 @@ def get_score_to_named_for_each_label( """ neighbors = int(np.ceil(0.1 * label.shape[0])) - print(neighbors) knn = NearestNeighbors(n_neighbors=neighbors, metric="euclidean") - residual = pred_labels - label + residual = predictions - label label = (label - label.mean()) / label.std() residual = np.sqrt(variance) * ((residual - residual.mean()) / residual.std()) From 25195500126306fc5569b0ae4a6e98e940d30d0f Mon Sep 17 00:00:00 2001 From: krmayankb Date: Thu, 22 Dec 2022 00:23:12 -0800 Subject: [PATCH 011/258] unit tests for new scoring method --- cleanlab/regression/rank.py | 19 ++++++++-------- tests/test_regression.py | 43 +++++++++++++++++++++++++++++++------ 2 files changed, 46 insertions(+), 16 deletions(-) diff --git a/cleanlab/regression/rank.py b/cleanlab/regression/rank.py index 3784d290b0..f53a0fb47e 100644 --- a/cleanlab/regression/rank.py +++ b/cleanlab/regression/rank.py @@ -10,7 +10,7 @@ def get_label_quality_scores( labels: np.ndarray, predictions: np.ndarray, *, - method: str = "residual", + method: str = "TO_BE_NAMED", # TODO update name once finalised ) -> np.ndarray: """ Returns label quality score for each example in the regression dataset. @@ -64,13 +64,13 @@ def get_label_quality_scores( raise ValueError( f""" {method} is not a valid scoring method. - Please choose a valid scoring technique: residual, TO_BE_NAMED. + Please choose a valid scoring technique: {scoring_funcs.keys()}. """ ) # Calculate scores - label_quality_score = scoring_func(labels, predictions) - return label_quality_score + label_quality_scores = scoring_func(labels, predictions) + return label_quality_scores def get_residual_score_for_each_label( @@ -106,8 +106,9 @@ def get_residual_score_for_each_label( # TODO - change name of the function +# TODO - change name of function in test def get_score_to_named_for_each_label( - label: np.ndarray, + labels: np.ndarray, predictions: np.ndarray, *, variance: float = 10, @@ -135,16 +136,16 @@ def get_score_to_named_for_each_label( Lower scores indicate more likely mislabled examples. """ - neighbors = int(np.ceil(0.1 * label.shape[0])) + neighbors = int(np.ceil(0.1 * labels.shape[0])) knn = NearestNeighbors(n_neighbors=neighbors, metric="euclidean") - residual = predictions - label + residual = predictions - labels - label = (label - label.mean()) / label.std() + labels = (labels - labels.mean()) / labels.std() residual = np.sqrt(variance) * ((residual - residual.mean()) / residual.std()) # 2D features by combining labels and residual - features = np.array([label, residual]).T + features = np.array([labels, residual]).T knn.fit(features) ood = OutOfDistribution(params={"knn": knn}) diff --git a/tests/test_regression.py b/tests/test_regression.py index 71de96cf3c..8a8154047c 100644 --- a/tests/test_regression.py +++ b/tests/test_regression.py @@ -2,26 +2,55 @@ import pandas as pd import pytest -from cleanlab.regression.rank import get_label_quality_scores +from cleanlab.regression import rank # To be used for all the tests labels = np.array([1, 2, 3, 4]) -pred_labels = np.array([1, 3, 4, 5]) - +predictions = np.array([1, 3, 4, 5]) +# test with deafault parameters def test_output_shape_type(): - scores = get_label_quality_scores(labels=labels, pred_labels=pred_labels) + scores = rank.get_label_quality_scores(labels=labels, predictions=predictions) assert labels.shape == scores.shape assert isinstance(scores, np.ndarray) +# test for acceptable datatypes @pytest.mark.parametrize("format", [pd.Series, pd.DataFrame, list]) def test_type_error_for_input_types(format): with pytest.raises(TypeError) as error: - _ = get_label_quality_scores(labels=format(labels), pred_labels=format(pred_labels)) + _ = rank.get_label_quality_scores(labels=format(labels), predictions=format(predictions)) +# test for input shapes def test_assertion_error_for_input_shape(): with pytest.raises(AssertionError) as error: - _ = get_label_quality_scores(labels=labels[:-1], pred_labels=pred_labels) - _ = get_label_quality_scores(labels=labels, pred_labels=pred_labels[:-1]) + _ = rank.get_label_quality_scores(labels=labels[:-1], predictions=predictions) + _ = rank.get_label_quality_scores(labels=labels, predictions=predictions[:-1]) + + +# TODO - change name once finalised +# test individual scoring functions +@pytest.mark.parametrize( + "scoring_funcs", + [rank.get_residual_score_for_each_label, rank.get_score_to_named_for_each_label], +) +def test_individual_scoring_functions(scoring_funcs): + scores = scoring_funcs(labels=labels, predictions=predictions) + assert labels.shape == scores.shape + assert isinstance(scores, np.ndarray) + + +# TODO - change name once finalised +# test for method argument +@pytest.mark.parametrize( + "method", + [ + "residual", + "TO_BE_NAMED", + ], +) +def test_method_pass_get_label_quality_scores(method): + scores = rank.get_label_quality_scores(labels=labels, predictions=predictions, method=method) + assert labels.shape == scores.shape + assert isinstance(scores, np.ndarray) From 9d002535bcff4bc6bfddf25cf1480faa428ef56f Mon Sep 17 00:00:00 2001 From: krmayankb Date: Fri, 23 Dec 2022 12:46:08 -0800 Subject: [PATCH 012/258] init merge conflict resolved --- cleanlab/__init__.py | 1 + 1 file changed, 1 insertion(+) diff --git a/cleanlab/__init__.py b/cleanlab/__init__.py index 46b87525d1..663977fc04 100644 --- a/cleanlab/__init__.py +++ b/cleanlab/__init__.py @@ -8,4 +8,5 @@ from . import multiannotator from . import outlier from . import token_classification + from . import regression From 1a9409f4f634f385881191916f3bbc3516d3979a Mon Sep 17 00:00:00 2001 From: krmayankb Date: Thu, 22 Dec 2022 01:15:43 -0800 Subject: [PATCH 013/258] tutorial draft1 --- docs/source/tutorials/regression.ipynb | 476 ++++++++++++++----------- 1 file changed, 268 insertions(+), 208 deletions(-) diff --git a/docs/source/tutorials/regression.ipynb b/docs/source/tutorials/regression.ipynb index b4770e47d1..682a81ffb2 100644 --- a/docs/source/tutorials/regression.ipynb +++ b/docs/source/tutorials/regression.ipynb @@ -1,117 +1,215 @@ { "cells": [ { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ - "# Label Quality Scores for Regression with Noisy Labels\n", - "In this tutorial, you will learn how to use cleanlab on regression dataset to: \n", - "- find label issue in your regression dataset\n", - "- generate label quality scores for each example in the dataset. " + "# Label Quality Scores for Regression with Noisy Labels " ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ - "## Install dependencies and import them \n", - "You can use pip to install all packages required for this tutorial as follows:" + "This quickstart tutorial shows how to use cleanlab for finding label errors in regression data. Using the approach mentioned here, you can find label error in any regression dataset irrespective of modality i.e., tabular, text, image etc. \n", + "\n", + "**This example will take you through following:**\n", + "- Generate label quality scores for each datapoint in the dataset. \n", + "- Find label issue for regression dataset. " ] }, { - "cell_type": "code", - "execution_count": null, + "attachments": {}, + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ - "!pip install cleanlab\n", - "!pip install scikit-learn" + "Quickstart \n", + "\n", + "Cleanlab uses two inputs to generates scores for labels in the dataset:\n", + "- `labels`: NumPy array of given labels in the dataset. labels[i] should contain label for `i`-th datapoint. \n", + "- `predictions`: NumPy array of predictions generated through your favourite regressor. predictions[i] should contain predicted value for `i`-th datapoint. \n", + "\n", + "If you already have predictions from your regressor, you can generate label quality scores for each datapoint using the code below: \n", + "\n", + "
\n", + "\n", + "```python \n", + "\n", + "from cleanlab.regression.rank import get_label_quality_scores\n", + "label_quality_scores = get_label_quality_scores(labels, predictions)\n", + "\n", + "```\n", + "
\n", + "" ] }, { - "cell_type": "code", - "execution_count": 1, + "attachments": {}, + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ - "import numpy as np \n", - "import pandas as pd \n", - "from cleanlab.regression.rank import get_label_quality_scores\n", - "from sklearn.linear_model import LinearRegression\n", - "import matplotlib.pyplot as plt " + "# 0. Visualization (can skip these details)" ] }, { - "cell_type": "code", - "execution_count": 21, + "attachments": {}, + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ - "def make_data(feature_size = (20, 2), \n", - " means = [8, -10], \n", - " stds = [2, 5], \n", - " bias = 0.8,\n", - " coeff = [2, 0.1],\n", - " error = [-2, 0, 2], \n", - " prob_error = [0.2, 0.6, 0.2], \n", - " seed = 42\n", - ") -> pd.DataFrame:\n", - " \"\"\"\n", - " feature_size: Tuple of (datapoints, features)\n", - " \"\"\"\n", - " assert (len(means) == feature_size[1]), (f\"length of mean {len(means)} is not same as features requested{feature_size[0]}\")\n", - " assert (len(stds) == feature_size[1]), (f\"length of stds {len(stds)} is not same as features requested{feature_size[0]}\")\n", - " np.random.seed(seed) \n", + "This is added just for reference. We will use this function to plot dataset, highlight points using label quality scores and true_errors.\n", + "You can skip this part and move to next section. " + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "
See the code for visualization **(click to expand)** \n", "\n", - " features = []\n", - " for i in range(feature_size[1]):\n", - " values = coeff[i] * np.random.normal(loc=means[i], scale=stds[i], size=feature_size[0])\n", - " features.append(values)\n", - " \n", - " true_labels = sum(map(np.array, features))+ bias\n", - " labels = true_labels + np.random.choice(error, feature_size[0], p=prob_error)\n", - " \n", - " data_dict = {\n", - " \"labels\" : labels, # You have these labels, which have some errors.\n", - " \"true_labels\" : true_labels, # You never get to see these perfect labels.\n", - " } \n", - " for idx, feature in enumerate(features): # adding names to each features \n", - " data_dict[\"feature_\"+str(idx+1)] = feature\n", - " data = pd.DataFrame.from_dict(data_dict)\n", - " col = list(data.columns)\n", - " new_col = col[2:] + col[:2]\n", - " data = data.reindex(columns=new_col)\n", - " return data\n", + "```python \n", + "# Note: this pulldown is for docs.cleanlab.ai, if running on local Jupyter or colab, please ignore it. \n", "\n", - "def plot_data(data, \n", - " circles, \n", - " title, \n", - " alpha=0.6, \n", - " color = '#1f77b4', \n", - " colorbar = False):\n", - " \n", + "def plot_data(\n", + " data_x, data_y, circles, title, alpha=0.6, color=\"#1f77b4\", colorbar=False, xlabel=\"\", ylabel=\"\"\n", + "):\n", " plt.figure(figsize=(14, 5))\n", - " data = data.to_numpy()\n", - " plt.scatter(data[:,0], data[:,1], c = color, s=60)\n", + " data_x = data_x.to_numpy()\n", + " data_y = data_y.to_numpy()\n", + " plt.scatter(data_x, data_y, c=color, s=30)\n", " for i in circles:\n", " plt.plot(\n", - " data[i][0],\n", - " data[i][1],\n", + " data_x[i],\n", + " data_y[i],\n", " \"o\",\n", " markerfacecolor=\"none\",\n", " markeredgecolor=\"red\",\n", - " markersize=14,\n", + " markersize=10,\n", " markeredgewidth=2.5,\n", - " alpha=alpha\n", + " alpha=alpha,\n", " )\n", " plt.title(title, fontsize=20)\n", - " \n", - " if colorbar: plt.colorbar(orientation = 'vertical')\n" + " plt.xlabel(xlabel)\n", + " plt.ylabel(ylabel)\n", + "\n", + " if colorbar:\n", + " plt.colorbar(orientation=\"vertical\")\n", + "\n", + "```\n", + "
" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def plot_data(\n", + " data_x, data_y, circles, title, alpha=0.6, color=\"#1f77b4\", colorbar=False, xlabel=\"\", ylabel=\"\"\n", + "):\n", + " plt.figure(figsize=(14, 5))\n", + " data_x = data_x.to_numpy()\n", + " data_y = data_y.to_numpy()\n", + " plt.scatter(data_x, data_y, c=color, s=30)\n", + " for i in circles:\n", + " plt.plot(\n", + " data_x[i],\n", + " data_y[i],\n", + " \"o\",\n", + " markerfacecolor=\"none\",\n", + " markeredgecolor=\"red\",\n", + " markersize=10,\n", + " markeredgewidth=2.5,\n", + " alpha=alpha,\n", + " )\n", + " plt.title(title, fontsize=20)\n", + " plt.xlabel(xlabel)\n", + " plt.ylabel(ylabel)\n", + "\n", + " if colorbar:\n", + " plt.colorbar(orientation=\"vertical\")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1. Install dependencies and import them \n", + "You can use `pip` to install all packages required for this tutorial as follows:\n", + "\n", + "`!pip install cleanlab xgboost`" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "!pip install cleanlab xgboost" + ] + }, + { + "cell_type": "code", + "execution_count": 94, + "metadata": { + "nbsphinx": "hidden" + }, + "outputs": [], + "source": [ + "# Package installation (hidden on docs website).\n", + "# Package versions we used: xgboost==1.7.2\n", + "\n", + "dependencies = [\"cleanlab\", \"xgboost\"]\n", + "\n", + "if \"google.colab\" in str(get_ipython()): # Check if it's running in Google Colab\n", + " %pip install cleanlab # for colab\n", + " cmd = \" \".join([dep for dep in dependencies if dep != \"cleanlab\"])\n", + " %pip install $cmd\n", + "else:\n", + " missing_dependencies = []\n", + " for dependency in dependencies:\n", + " try:\n", + " __import__(dependency)\n", + " except ImportError:\n", + " missing_dependencies.append(dependency)\n", + "\n", + " if len(missing_dependencies) > 0:\n", + " print(\"Missing required dependencies:\")\n", + " print(*missing_dependencies, sep=\", \")\n", + " print(\"\\nPlease install them before running the rest of this notebook.\")" + ] + }, + { + "cell_type": "code", + "execution_count": 95, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "from cleanlab.regression.rank import get_label_quality_scores\n", + "import xgboost as xgb\n", + "import matplotlib.pyplot as plt\n", + "\n", + "np.set_printoptions(suppress=True)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 2. Import dataset and Generate predictions" ] }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 107, "metadata": {}, "outputs": [ { @@ -138,7 +236,7 @@ " exam_1\n", " exam_2\n", " exam_3\n", - " bonus_or_penalty\n", + " notes\n", " true_labels\n", " labels\n", " \n", @@ -149,43 +247,43 @@ " 53\n", " 77\n", " 93\n", - " 0\n", + " NaN\n", + " 76.2\n", " 76.2\n", - " 56.2\n", " \n", " \n", " 1\n", " 81\n", " 64\n", " 80\n", - " 10\n", + " great participation +10\n", + " 85.5\n", " 85.5\n", - " 65.5\n", " \n", " \n", " 2\n", " 74\n", " 88\n", " 97\n", - " 0\n", + " NaN\n", + " 87.4\n", " 87.4\n", - " 67.4\n", " \n", " \n", " 3\n", " 61\n", " 94\n", " 78\n", - " 0\n", + " NaN\n", + " 77.7\n", " 77.7\n", - " 57.7\n", " \n", " \n", " 4\n", " 48\n", " 90\n", " 91\n", - " 0\n", + " NaN\n", " 77.8\n", " 77.8\n", " \n", @@ -194,15 +292,15 @@ "" ], "text/plain": [ - " exam_1 exam_2 exam_3 bonus_or_penalty true_labels labels\n", - "0 53 77 93 0 76.2 56.2\n", - "1 81 64 80 10 85.5 65.5\n", - "2 74 88 97 0 87.4 67.4\n", - "3 61 94 78 0 77.7 57.7\n", - "4 48 90 91 0 77.8 77.8" + " exam_1 exam_2 exam_3 notes true_labels labels\n", + "0 53 77 93 NaN 76.2 76.2\n", + "1 81 64 80 great participation +10 85.5 85.5\n", + "2 74 88 97 NaN 87.4 87.4\n", + "3 61 94 78 NaN 77.7 77.7\n", + "4 48 90 91 NaN 77.8 77.8" ] }, - "execution_count": 22, + "execution_count": 107, "metadata": {}, "output_type": "execute_result" } @@ -215,14 +313,14 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 108, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -230,149 +328,78 @@ } ], "source": [ - "data = make_data(feature_size=(100, 2))\n", - "true_errors = np.where(data['true_labels'] != data['labels'])[0]\n", - "plot_data(data[['feature_1','feature_2']], \n", - " circles=true_errors, \n", - " color=data['labels'], \n", - " colorbar=True, \n", - " title=\"Messy Regression dataset\")" + "# Generate true errors\n", + "true_errors = np.where(data.labels != data.true_labels)[0]\n", + "plot_data(\n", + " data_x=data[\"exam_3\"], \n", + " data_y=data[\"labels\"],\n", + " circles=true_errors,\n", + " title=\"Messy Regression dataset\",\n", + " xlabel=\"exam_3 feature\",\n", + " ylabel=\"label (Y value)\",\n", + ")" ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ - "The figure above represents a toy dataset we'll use to demonstrate label scoring for regression dataset. In this example, datapoints are ploted on 2-D space (in this case feature_1 vs feature_2). Each datapoint is colored based on given label. \n", + "In the dataframe displayed above, `labels` represents the noisy labels and `true_labels` represents the ground truth. Please note that, ground truth are usually not available in real dataset, we have added it here for comparision and to demonstrate our method. `notes` also has text information, we will model this a categorical variable. \n", "\n", - "Like many real-world datasets, the given label happen to be incorrect for some of the examples(**circled in red**) in this dataset. " + "We will use `xgboost` as regressor for this tutorial. xgboost provides easy to use interface to process categorical variable. This is demonstrated in the code below:" ] }, { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": 109, "metadata": {}, + "outputs": [], "source": [ - "## Using cleanlab to generate label quality scores" + "# XGBOOST automatically factors categorical variable, you just need to mark the columns as category\n", + "data.notes = data.notes.astype(\"category\")\n", + "\n", + "# XGBOOST takes data and label seperately, so you will need to divide data accordingly.\n", + "X = data.drop([\"labels\", \"true_labels\"], axis=1)\n", + "y = data[\"labels\"]\n", + "\n", + "# convert data to format \"DMatrix\" to make it compatible with XGBOOST.\n", + "xgboost_data = xgb.DMatrix(data=X, label=y, enable_categorical=True)\n", + "\n", + "# declare parameters and train the model.\n", + "params = {\"booster\": \"gblinear\", \"objective\": \"reg:squarederror\"}\n", + "boost = xgb.train(params=params, dtrain=xgboost_data, num_boost_round=50)" ] }, { - "cell_type": "code", - "execution_count": 24, + "attachments": {}, + "cell_type": "markdown", "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", - "
feature_1feature_2labelstrue_labels
017.986857-1.70768519.07917117.079171
115.446943-1.21032315.03662015.036620
218.590754-1.17135718.21939718.219397
322.092119-1.40113921.49098121.490981
415.063387-1.08064314.78274414.782744
\n", - "
" - ], - "text/plain": [ - " feature_1 feature_2 labels true_labels\n", - "0 17.986857 -1.707685 19.079171 17.079171\n", - "1 15.446943 -1.210323 15.036620 15.036620\n", - "2 18.590754 -1.171357 18.219397 18.219397\n", - "3 22.092119 -1.401139 21.490981 21.490981\n", - "4 15.063387 -1.080643 14.782744 14.782744" - ] - }, - "execution_count": 24, - "metadata": {}, - "output_type": "execute_result" - } - ], "source": [ - "# start with checking the dataset generated\n", - "data.head()" + "## 3. Using cleanlab to generate label quality scores" ] }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 110, "metadata": {}, "outputs": [], "source": [ - "# Note that \"true_labels\" will not be available in real-life dataset. We have added here only for comparision.\n", - "X = data[['feature_'+str(i+1) for i in range(2)]]\n", - "y = data['labels']\n", - "\n", - "# initialize your favourite model and generate predictions \n", - "yourFavouriteModel = LinearRegression()\n", - "yourFavouriteModel = yourFavouriteModel.fit(X,y)\n", - "predictions = yourFavouriteModel.predict(X)\n", + "# using trained xgboost model to get predictions\n", + "predictions = boost.predict(xgboost_data)\n", "\n", - "# get label quality score for each example in the dataset \n", - "label_quality = get_label_quality_scores(labels=np.array(data['labels']), pred_labels=predictions)" + "# get label quality score for each example in the dataset using cleanlab\n", + "label_quality_scores = get_label_quality_scores(labels=np.array(y), predictions=predictions)" ] }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 111, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -383,11 +410,15 @@ ], "source": [ "plot_data(\n", - " data[['feature_1','feature_2']], \n", - " circles=true_errors ,\n", - " color=label_quality, \n", - " title=\"Messy Regression dataset with label quality scores\", \n", - " colorbar=True)" + " data_x=data[\"exam_3\"], \n", + " data_y=data[\"labels\"],\n", + " circles=true_errors,\n", + " color=label_quality_scores,\n", + " title=\"Messy Regression dataset with label quality scores\",\n", + " colorbar=True,\n", + " xlabel=\"exam_3 feature\",\n", + " ylabel=\"label (Y value)\",\n", + ")" ] }, { @@ -402,8 +433,37 @@ ] }, { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": 112, + "metadata": { + "nbsphinx": "hidden" + }, + "outputs": [], + "source": [ + "# Note: This cell is only for docs.cleanlab.ai, if running on local Jupyter or Colab, please ignore it.\n", + "from sklearn.metrics import roc_auc_score\n", + "\n", + "label_quality_scores = get_label_quality_scores(np.array(y), predictions=predictions)\n", + "\n", + "true_errors = (data.labels != data.true_labels).astype(int)\n", + "label_quality_scores_residual = get_label_quality_scores(\n", + " np.array(y), predictions=predictions, method=\"residual\"\n", + ")\n", + "\n", + "if roc_auc_score(true_errors, 1 - label_quality_scores) < 0.5:\n", + " raise ValueError(\"Label quality scores did not perform well enough\")\n", + "\n", + "if roc_auc_score(true_errors, 1 - label_quality_scores) <= roc_auc_score(\n", + " true_errors, 1 - label_quality_scores_residual\n", + "):\n", + " raise ValueError(\"Label quality scores did not outperform alternative scores\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, "metadata": {}, + "outputs": [], "source": [] } ], From 87053989d2805a28a4afc529f81091286e3c1dcf Mon Sep 17 00:00:00 2001 From: krmayankb Date: Thu, 22 Dec 2022 01:16:36 -0800 Subject: [PATCH 014/258] tutorial draft1 --- docs/source/tutorials/regression.ipynb | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/source/tutorials/regression.ipynb b/docs/source/tutorials/regression.ipynb index 682a81ffb2..cc02658e80 100644 --- a/docs/source/tutorials/regression.ipynb +++ b/docs/source/tutorials/regression.ipynb @@ -331,7 +331,7 @@ "# Generate true errors\n", "true_errors = np.where(data.labels != data.true_labels)[0]\n", "plot_data(\n", - " data_x=data[\"exam_3\"], \n", + " data_x=data[\"exam_3\"],\n", " data_y=data[\"labels\"],\n", " circles=true_errors,\n", " title=\"Messy Regression dataset\",\n", @@ -410,7 +410,7 @@ ], "source": [ "plot_data(\n", - " data_x=data[\"exam_3\"], \n", + " data_x=data[\"exam_3\"],\n", " data_y=data[\"labels\"],\n", " circles=true_errors,\n", " color=label_quality_scores,\n", From c081913de21a45b54bb67427cd1fbbd28e498b7d Mon Sep 17 00:00:00 2001 From: krmayankb Date: Fri, 23 Dec 2022 13:07:04 -0800 Subject: [PATCH 015/258] merge conflict --- cleanlab/__init__.py | 1 - 1 file changed, 1 deletion(-) diff --git a/cleanlab/__init__.py b/cleanlab/__init__.py index 663977fc04..46b87525d1 100644 --- a/cleanlab/__init__.py +++ b/cleanlab/__init__.py @@ -8,5 +8,4 @@ from . import multiannotator from . import outlier from . import token_classification - from . import regression From d80e0774ebdbf152793845e81eec2bb6aab340ea Mon Sep 17 00:00:00 2001 From: krmayankb Date: Fri, 23 Dec 2022 14:56:32 -0800 Subject: [PATCH 016/258] default modified for method in docstring --- cleanlab/regression/rank.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cleanlab/regression/rank.py b/cleanlab/regression/rank.py index f53a0fb47e..a6176a8de3 100644 --- a/cleanlab/regression/rank.py +++ b/cleanlab/regression/rank.py @@ -29,7 +29,7 @@ def get_label_quality_scores( Predicated labels from regressor fitted on the dataset. Array of shape ``(N,)`` consisting predicted labels, where N is number of datapoints in the regression dataset. - method : {"residual", "TO_BE_NAMED"}, default="residual" #TODO - update name once finalised + method : {"residual", "TO_BE_NAMED"}, default="TO_BE_NAMED" #TODO - update name once finalised Returns ------- From 02defb93943361b497033bdd8fec69e6a16e7fe0 Mon Sep 17 00:00:00 2001 From: Mayank Kumar Date: Fri, 23 Dec 2022 15:01:21 -0800 Subject: [PATCH 017/258] grammatical correction in rank.py MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Elías Snorrason --- cleanlab/regression/rank.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cleanlab/regression/rank.py b/cleanlab/regression/rank.py index a6176a8de3..4318d664df 100644 --- a/cleanlab/regression/rank.py +++ b/cleanlab/regression/rank.py @@ -15,7 +15,7 @@ def get_label_quality_scores( """ Returns label quality score for each example in the regression dataset. - Each score is continous value in range [0,1] + Each score is a continous value in the range [0,1] 1 - clean label (given label is likely correct). 0 - dirty label (given label is likely incorrect). From 4a0a9efdbf6a54c4bde3ed4588bcf5b97c3a1e9a Mon Sep 17 00:00:00 2001 From: Mayank Kumar Date: Fri, 23 Dec 2022 15:24:02 -0800 Subject: [PATCH 018/258] Update cleanlab/regression/rank.py MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Elías Snorrason --- cleanlab/regression/rank.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/cleanlab/regression/rank.py b/cleanlab/regression/rank.py index 4318d664df..dc98059253 100644 --- a/cleanlab/regression/rank.py +++ b/cleanlab/regression/rank.py @@ -115,8 +115,8 @@ def get_score_to_named_for_each_label( ) -> np.ndarray: """Returns label-quality scores. - This is function to compute label-quality scores for regression datasets, - where lower score indicate labels less likely to be correct. + This function computes label-quality scores for regression datasets, + where a lower score indicates labels that are less likely to be correct. Parameters ---------- From f2c5862864c76f72113a244e7dc2320c1b574d28 Mon Sep 17 00:00:00 2001 From: krmayankb Date: Fri, 23 Dec 2022 16:55:11 -0800 Subject: [PATCH 019/258] =?UTF-8?q?rank.py=20updates=201.=20added=20typing?= =?UTF-8?q?=20hints=20for=20scoring=20funcs=202.=20Removed=20try-except=20?= =?UTF-8?q?block=20for=20raising=20value=20error.=203.=20grammatical=20cor?= =?UTF-8?q?rections=204.=20knn=20and=20neighbors=20construction=20moved=20?= =?UTF-8?q?closer=20to=20first=20usage.=20Co-authored-by:=20El=C3=ADas=20S?= =?UTF-8?q?norrason=20?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- cleanlab/regression/rank.py | 21 +++++++++------------ 1 file changed, 9 insertions(+), 12 deletions(-) diff --git a/cleanlab/regression/rank.py b/cleanlab/regression/rank.py index dc98059253..99c42aba3e 100644 --- a/cleanlab/regression/rank.py +++ b/cleanlab/regression/rank.py @@ -2,6 +2,7 @@ from cleanlab.outlier import OutOfDistribution from sklearn.neighbors import NearestNeighbors from cleanlab.internal.regression_utils import assert_valid_inputs +from typing import Dict, Callable """ Generates label quality scores for every sample in regression dataset """ @@ -52,15 +53,14 @@ def get_label_quality_scores( # Check if inputs are valid assert_valid_inputs(labels=labels, predictions=predictions, method=method) - scoring_funcs = { + scoring_funcs: Dict[str, Callable[[np.ndarray, np.ndarray], np.ndarray]] = { "residual": get_residual_score_for_each_label, "TO_BE_NAMED": get_score_to_named_for_each_label, # TODO - update name once finalised } # TODO - update name once finalised - try: - scoring_func = scoring_funcs[method] - except KeyError: + scoring_func = scoring_funcs.get(method, None) + if not scoring_func: raise ValueError( f""" {method} is not a valid scoring method. @@ -121,10 +121,10 @@ def get_score_to_named_for_each_label( Parameters ---------- labels: np.ndarray - Labels in the same format expected by the :py:func:`get_label_quality_scores ` function. + Labels in the same format as expected by the :py:func:`get_label_quality_scores ` function. predictions: np.ndarray - Predicted labels in the same format expected by the :py:func:`get_label_quality_scores ` function. + Predicted labels in the same format as expected by the :py:func:`get_label_quality_scores ` function. variance: float, default = 10 Manipulates variance of the distribution of residual. @@ -135,19 +135,16 @@ def get_score_to_named_for_each_label( Contains one score (between 0 and 1) per example. Lower scores indicate more likely mislabled examples. """ - - neighbors = int(np.ceil(0.1 * labels.shape[0])) - knn = NearestNeighbors(n_neighbors=neighbors, metric="euclidean") - residual = predictions - labels - labels = (labels - labels.mean()) / labels.std() residual = np.sqrt(variance) * ((residual - residual.mean()) / residual.std()) # 2D features by combining labels and residual features = np.array([labels, residual]).T - knn.fit(features) + neighbors = int(np.ceil(0.1 * labels.shape[0])) + knn = NearestNeighbors(n_neighbors=neighbors, metric="euclidean").fit(features) ood = OutOfDistribution(params={"knn": knn}) + label_quality_scores = ood.score(features=features) return label_quality_scores From 7d97c26d35e039595e2e371cae2c5f42eb3efeb1 Mon Sep 17 00:00:00 2001 From: krmayankb Date: Fri, 23 Dec 2022 19:15:43 -0800 Subject: [PATCH 020/258] outre: code updated for name for second method --- cleanlab/regression/rank.py | 12 +++++------- tests/test_regression.py | 6 ++---- 2 files changed, 7 insertions(+), 11 deletions(-) diff --git a/cleanlab/regression/rank.py b/cleanlab/regression/rank.py index 99c42aba3e..fe263f88ca 100644 --- a/cleanlab/regression/rank.py +++ b/cleanlab/regression/rank.py @@ -11,7 +11,7 @@ def get_label_quality_scores( labels: np.ndarray, predictions: np.ndarray, *, - method: str = "TO_BE_NAMED", # TODO update name once finalised + method: str = "outre", # TODO update name once finalised ) -> np.ndarray: """ Returns label quality score for each example in the regression dataset. @@ -30,7 +30,7 @@ def get_label_quality_scores( Predicated labels from regressor fitted on the dataset. Array of shape ``(N,)`` consisting predicted labels, where N is number of datapoints in the regression dataset. - method : {"residual", "TO_BE_NAMED"}, default="TO_BE_NAMED" #TODO - update name once finalised + method : {"residual", "outre"}, default="outre" Returns ------- @@ -55,10 +55,9 @@ def get_label_quality_scores( scoring_funcs: Dict[str, Callable[[np.ndarray, np.ndarray], np.ndarray]] = { "residual": get_residual_score_for_each_label, - "TO_BE_NAMED": get_score_to_named_for_each_label, # TODO - update name once finalised + "outre": get_outre_score_for_each_label, } - # TODO - update name once finalised scoring_func = scoring_funcs.get(method, None) if not scoring_func: raise ValueError( @@ -105,15 +104,14 @@ def get_residual_score_for_each_label( return label_quality_scores -# TODO - change name of the function # TODO - change name of function in test -def get_score_to_named_for_each_label( +def get_outre_score_for_each_label( labels: np.ndarray, predictions: np.ndarray, *, variance: float = 10, ) -> np.ndarray: - """Returns label-quality scores. + """Returns OUTRE based label-quality scores. This function computes label-quality scores for regression datasets, where a lower score indicates labels that are less likely to be correct. diff --git a/tests/test_regression.py b/tests/test_regression.py index 8a8154047c..dc29315f96 100644 --- a/tests/test_regression.py +++ b/tests/test_regression.py @@ -29,11 +29,10 @@ def test_assertion_error_for_input_shape(): _ = rank.get_label_quality_scores(labels=labels, predictions=predictions[:-1]) -# TODO - change name once finalised # test individual scoring functions @pytest.mark.parametrize( "scoring_funcs", - [rank.get_residual_score_for_each_label, rank.get_score_to_named_for_each_label], + [rank.get_residual_score_for_each_label, rank.get_outre_score_for_each_label], ) def test_individual_scoring_functions(scoring_funcs): scores = scoring_funcs(labels=labels, predictions=predictions) @@ -41,13 +40,12 @@ def test_individual_scoring_functions(scoring_funcs): assert isinstance(scores, np.ndarray) -# TODO - change name once finalised # test for method argument @pytest.mark.parametrize( "method", [ "residual", - "TO_BE_NAMED", + "outre", ], ) def test_method_pass_get_label_quality_scores(method): From 305d11bd271d29001e02d757d140bad91a749284 Mon Sep 17 00:00:00 2001 From: Mayank Kumar Date: Fri, 23 Dec 2022 22:21:46 -0800 Subject: [PATCH 021/258] Apply Docstring suggestions from code review Co-authored-by: Jonas Mueller <1390638+jwmueller@users.noreply.github.com> --- cleanlab/regression/rank.py | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/cleanlab/regression/rank.py b/cleanlab/regression/rank.py index fe263f88ca..afd25c725c 100644 --- a/cleanlab/regression/rank.py +++ b/cleanlab/regression/rank.py @@ -24,11 +24,10 @@ def get_label_quality_scores( ---------- labels : np.ndarray Raw labels from original dataset. - Array of shape ``(N, )`` consisting given labels, where N is number of datapoints in the regression dataset. + 1D array of shape ``(N, )`` containing the given labels for each example (aka. Y-value, response, target, dependent variable, ...), where N is number of examples in the dataset. predictions : np.ndarray - Predicated labels from regressor fitted on the dataset. - Array of shape ``(N,)`` consisting predicted labels, where N is number of datapoints in the regression dataset. + 1D array of shape ``(N,)`` containing the predicted label for each example in the dataset. These should be out-of-sample predictions from a trained regression model, which you can obtain for every example in your dataset via :ref:`cross-validation `. method : {"residual", "outre"}, default="outre" @@ -37,7 +36,7 @@ def get_label_quality_scores( label_quality_scores: Array of shape ``(N, )`` of scores between 0 and 1, one per datapoint in the dataset. - Lower scores indicate datapoint more likely to contain a label issue. + Lower scores indicate datapoints more likely to contain a label issue. Examples -------- @@ -76,7 +75,7 @@ def get_residual_score_for_each_label( labels: np.ndarray, predictions: np.ndarray, ) -> np.ndarray: - """Returns the residual based label-quality scores for each datapoints. + """Returns a residual label-quality score for each datapoint. This is function to compute label-quality scores for regression datasets, where lower score indicate labels less likely to be correct. From e9468dd9e476f9821e3c0ca2e4e17b00cb02d6a5 Mon Sep 17 00:00:00 2001 From: krmayankb Date: Fri, 23 Dec 2022 22:42:56 -0800 Subject: [PATCH 022/258] Support for array_like labels and predictions --- cleanlab/internal/regression_utils.py | 26 +++++++++++----- cleanlab/regression/rank.py | 43 ++++++++++++++++++--------- 2 files changed, 48 insertions(+), 21 deletions(-) diff --git a/cleanlab/internal/regression_utils.py b/cleanlab/internal/regression_utils.py index 04576c4012..a62e85aca5 100644 --- a/cleanlab/internal/regression_utils.py +++ b/cleanlab/internal/regression_utils.py @@ -10,19 +10,31 @@ def assert_valid_inputs( predictions: np.ndarray, method: str, ) -> None: - """Checks that ``labels``, ``pred_labels``, ``method`` are correctly formatted.""" + """Checks that ``labels``, ``predictions``, ``method`` are correctly formatted.""" # Check if labels and pred_labels are np.ndarray if not isinstance(labels, np.ndarray) or not isinstance(predictions, np.ndarray): - raise TypeError("labels and pred_labels must be of type np.ndarray") + raise TypeError("labels and predictions must be of type np.ndarray") - # Check if labels and pred_labels are of same shape + # Check if labels and predictions are of same shape assert ( labels.shape == predictions.shape ), f"shape of label {labels.shape} and predicted labels {predictions.shape} are not same." - # Check if method passed is string - if not isinstance(method, str): - raise TypeError( - f"Passed method is not of correct type. Expected string, got {type(method)}" + # Check if method is among allowed scoring method + scoring_methods = ["residual", "outre"] + if method not in scoring_methods: + raise ValueError( + f"Passed method is not among allowed method. Expected either of {scoring_methods}, got {method}" + ) + + +def check_dimensions(labels: np.ndarray, predictions: np.ndarray) -> None: + if labels.ndim != 1: + raise ValueError( + f"labels have dimensions {labels.ndim}, Expected 1-D array as input for labels" + ) + if predictions.ndim != 1: + raise ValueError( + f"predictions have dimensions {labels.ndim}, Expected 1-D array as input for predictions" ) diff --git a/cleanlab/regression/rank.py b/cleanlab/regression/rank.py index fe263f88ca..c6250ae4af 100644 --- a/cleanlab/regression/rank.py +++ b/cleanlab/regression/rank.py @@ -1,17 +1,20 @@ import numpy as np from cleanlab.outlier import OutOfDistribution from sklearn.neighbors import NearestNeighbors -from cleanlab.internal.regression_utils import assert_valid_inputs -from typing import Dict, Callable +from cleanlab.internal.regression_utils import assert_valid_inputs, check_dimensions +from typing import Dict, Callable, Optional +from cleanlab.typing import LabelLike """ Generates label quality scores for every sample in regression dataset """ +EPS = 1e-30 + def get_label_quality_scores( - labels: np.ndarray, - predictions: np.ndarray, + labels: Optional[LabelLike], + predictions: Optional[LabelLike], *, - method: str = "outre", # TODO update name once finalised + method: str = "outre", ) -> np.ndarray: """ Returns label quality score for each example in the regression dataset. @@ -22,7 +25,7 @@ def get_label_quality_scores( Parameters ---------- - labels : np.ndarray + labels : array_like Raw labels from original dataset. Array of shape ``(N, )`` consisting given labels, where N is number of datapoints in the regression dataset. @@ -53,6 +56,11 @@ def get_label_quality_scores( # Check if inputs are valid assert_valid_inputs(labels=labels, predictions=predictions, method=method) + # Convert to numpy array and check if they are 1-D array. + labels = np.asarray(labels) + predictions = np.asarray(predictions) + check_dimensions(labels, predictions) + scoring_funcs: Dict[str, Callable[[np.ndarray, np.ndarray], np.ndarray]] = { "residual": get_residual_score_for_each_label, "outre": get_outre_score_for_each_label, @@ -104,12 +112,13 @@ def get_residual_score_for_each_label( return label_quality_scores -# TODO - change name of function in test def get_outre_score_for_each_label( labels: np.ndarray, predictions: np.ndarray, *, - variance: float = 10, + residual_scale: float = 10, + frac_neighbors: float = 0.1, + neighbor_metric: str = "euclidean", ) -> np.ndarray: """Returns OUTRE based label-quality scores. @@ -124,8 +133,14 @@ def get_outre_score_for_each_label( predictions: np.ndarray Predicted labels in the same format as expected by the :py:func:`get_label_quality_scores ` function. - variance: float, default = 10 - Manipulates variance of the distribution of residual. + residual_scale: float, default = 10 + Manipulates scale of the distribution of residual. + + frac_neighbors: float, default = 0.1 + Fraction of datapoints that should be considered as n_neighbors to NearestNeighbors. + + neighbor_metric: str, default = "euclidean" + The parameter is passed to sklearn NearestNeighbors. # TODO add reference to sklearn.NearestNeighbor? Returns ------- @@ -134,14 +149,14 @@ def get_outre_score_for_each_label( Lower scores indicate more likely mislabled examples. """ residual = predictions - labels - labels = (labels - labels.mean()) / labels.std() - residual = np.sqrt(variance) * ((residual - residual.mean()) / residual.std()) + labels = (labels - labels.mean()) / (labels.std() + EPS) + residual = residual_scale * ((residual - residual.mean()) / (residual.std() + EPS)) # 2D features by combining labels and residual features = np.array([labels, residual]).T - neighbors = int(np.ceil(0.1 * labels.shape[0])) - knn = NearestNeighbors(n_neighbors=neighbors, metric="euclidean").fit(features) + neighbors = int(np.ceil(frac_neighbors * labels.shape[0])) + knn = NearestNeighbors(n_neighbors=neighbors, metric=neighbor_metric).fit(features) ood = OutOfDistribution(params={"knn": knn}) label_quality_scores = ood.score(features=features) From 48c3f5791863b406e6b447e18ffc3731e0e98fe5 Mon Sep 17 00:00:00 2001 From: krmayankb Date: Fri, 23 Dec 2022 23:13:07 -0800 Subject: [PATCH 023/258] doctring for method modified --- cleanlab/regression/rank.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/cleanlab/regression/rank.py b/cleanlab/regression/rank.py index e0efe5521c..d57cd5ffec 100644 --- a/cleanlab/regression/rank.py +++ b/cleanlab/regression/rank.py @@ -27,12 +27,13 @@ def get_label_quality_scores( ---------- labels : array_like Raw labels from original dataset. - 1D array of shape ``(N, )`` containing the given labels for each example (aka. Y-value, response, target, dependent variable, ...), where N is number of examples in the dataset. + 1D array of shape ``(N, )`` containing the given labels for each example (aka. Y-value, response, target, dependent variable, ...), where N is number of examples in the dataset. predictions : np.ndarray 1D array of shape ``(N,)`` containing the predicted label for each example in the dataset. These should be out-of-sample predictions from a trained regression model, which you can obtain for every example in your dataset via :ref:`cross-validation `. method : {"residual", "outre"}, default="outre" + String specifying which method to use for scoring the quality of each label and identifying which labels appear most noisy. Returns ------- From 65e1a3cb854947ab556843e86e54e9291de30cef Mon Sep 17 00:00:00 2001 From: krmayankb Date: Fri, 23 Dec 2022 23:17:38 -0800 Subject: [PATCH 024/258] datapoint -> example --- cleanlab/regression/rank.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/cleanlab/regression/rank.py b/cleanlab/regression/rank.py index d57cd5ffec..6ebe33af64 100644 --- a/cleanlab/regression/rank.py +++ b/cleanlab/regression/rank.py @@ -38,9 +38,9 @@ def get_label_quality_scores( Returns ------- label_quality_scores: - Array of shape ``(N, )`` of scores between 0 and 1, one per datapoint in the dataset. + Array of shape ``(N, )`` of scores between 0 and 1, one per example in the dataset. - Lower scores indicate datapoints more likely to contain a label issue. + Lower scores indicate examples more likely to contain a label issue. Examples -------- @@ -84,7 +84,7 @@ def get_residual_score_for_each_label( labels: np.ndarray, predictions: np.ndarray, ) -> np.ndarray: - """Returns a residual label-quality score for each datapoint. + """Returns a residual label-quality score for each example. This is function to compute label-quality scores for regression datasets, where lower score indicate labels less likely to be correct. @@ -137,7 +137,7 @@ def get_outre_score_for_each_label( Manipulates scale of the distribution of residual. frac_neighbors: float, default = 0.1 - Fraction of datapoints that should be considered as n_neighbors to NearestNeighbors. + Fraction of examples that should be considered as n_neighbors to NearestNeighbors. neighbor_metric: str, default = "euclidean" The parameter is passed to sklearn NearestNeighbors. # TODO add reference to sklearn.NearestNeighbor? From 7b15cbac2ffd280885d864a160c774a8b187c408 Mon Sep 17 00:00:00 2001 From: krmayankb Date: Sat, 24 Dec 2022 02:27:34 -0800 Subject: [PATCH 025/258] check_valid_inputs update 1. added support for list, np.ndarray, pd.Series, pd.DataFrame 2. check if inputs are numeric --- cleanlab/internal/regression_utils.py | 64 +++++++++++++++++++++++---- 1 file changed, 55 insertions(+), 9 deletions(-) diff --git a/cleanlab/internal/regression_utils.py b/cleanlab/internal/regression_utils.py index a62e85aca5..a7bfb4bbd1 100644 --- a/cleanlab/internal/regression_utils.py +++ b/cleanlab/internal/regression_utils.py @@ -3,23 +3,35 @@ """ import numpy as np +import pandas as pd +from pandas.api.types import is_numeric_dtype +from cleanlab.typing import LabelLike +from typing import Optional def assert_valid_inputs( - labels: np.ndarray, - predictions: np.ndarray, + labels: Optional[LabelLike], + predictions: Optional[LabelLike], method: str, ) -> None: """Checks that ``labels``, ``predictions``, ``method`` are correctly formatted.""" - # Check if labels and pred_labels are np.ndarray - if not isinstance(labels, np.ndarray) or not isinstance(predictions, np.ndarray): - raise TypeError("labels and predictions must be of type np.ndarray") + supported_types = (list, np.ndarray, pd.Series, pd.DataFrame) - # Check if labels and predictions are of same shape - assert ( - labels.shape == predictions.shape - ), f"shape of label {labels.shape} and predicted labels {predictions.shape} are not same." + # Check if labels and predictions are of supported types + if not isinstance(labels, supported_types) and not isinstance(predictions, supported_types): + raise TypeError( + f"Expected labels and predictions to be either of {supported_types}, Got labels of type {type(labels)}, and predictions of type {type(predictions)}", + ) + + # check if labels and predictions are 1-D and numeric + check_dimension_and_datatype(check_input=labels, text = "labels") + check_dimension_and_datatype(check_input=predictions, text = "predictions") + + # check if number of examples are same. + assert len(labels) == len( + predictions + ), f"Length of labels {len(labels)} and predictions {len(predictions)} are not same." # Check if method is among allowed scoring method scoring_methods = ["residual", "outre"] @@ -29,6 +41,40 @@ def assert_valid_inputs( ) +def check_dimension_and_datatype(check_input: Optional[LabelLike], text : str): + # check if input is empty + if not len(check_input): + raise ValueError( + f"{text} is Empty, check input." + ) + + if isinstance(check_input, list): + if isinstance(check_input[0], list): + raise ValueError(f"{text} must be 1-D. List of List is not supported.") + elif not all(isinstance(x, (int, float)) for x in check_input): + raise ValueError( + f"All element of {text} must be of type numeric i.e., integer or float" + ) + + elif isinstance(check_input, pd.DataFrame): + if check_input.shape[1] != 1: + raise ValueError( + f"{text} must be 1-D. For DataFrame, second dimension must be 1, got {check_input.shape}." + ) + elif check_input.shape[1] == 1: + if not is_numeric_dtype(check_input): + raise ValueError(f"{text} must be 1-D and numeric type. got {check_input.dtype}.") + elif isinstance(check_input, (np.ndarray, pd.Series)): + if len(check_input.shape) != 1: + raise ValueError(f"{text} must be 1-D {type(check_input)}, got {check_input.shape}") + elif len(check_input.shape) == 1: + if isinstance(check_input, pd.Series) and not is_numeric_dtype(check_input): + raise ValueError(f"{text} must be 1-D and numeric type. got {check_input.dtype}.") + elif isinstance(check_input, np.ndarray): + if not all(isinstance(x, (int, float)) for x in check_input.tolist()): + raise ValueError(f"{text} must be 1-d and numeric type i.e., integer or float.") + + def check_dimensions(labels: np.ndarray, predictions: np.ndarray) -> None: if labels.ndim != 1: raise ValueError( From b9b91049da5062dae0c60ecf539f5ea214bcee12 Mon Sep 17 00:00:00 2001 From: krmayankb Date: Tue, 27 Dec 2022 15:51:12 -0800 Subject: [PATCH 026/258] tutorial removed --- docs/source/tutorials/index.rst | 1 - docs/source/tutorials/regression.ipynb | 497 ------------------------- 2 files changed, 498 deletions(-) delete mode 100644 docs/source/tutorials/regression.ipynb diff --git a/docs/source/tutorials/index.rst b/docs/source/tutorials/index.rst index 78e4efac5f..d040963629 100644 --- a/docs/source/tutorials/index.rst +++ b/docs/source/tutorials/index.rst @@ -14,7 +14,6 @@ Tutorials multiannotator multilabel_classification token_classification - regression pred_probs_cross_val faq diff --git a/docs/source/tutorials/regression.ipynb b/docs/source/tutorials/regression.ipynb deleted file mode 100644 index cc02658e80..0000000000 --- a/docs/source/tutorials/regression.ipynb +++ /dev/null @@ -1,497 +0,0 @@ -{ - "cells": [ - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Label Quality Scores for Regression with Noisy Labels " - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "This quickstart tutorial shows how to use cleanlab for finding label errors in regression data. Using the approach mentioned here, you can find label error in any regression dataset irrespective of modality i.e., tabular, text, image etc. \n", - "\n", - "**This example will take you through following:**\n", - "- Generate label quality scores for each datapoint in the dataset. \n", - "- Find label issue for regression dataset. " - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Quickstart \n", - "\n", - "Cleanlab uses two inputs to generates scores for labels in the dataset:\n", - "- `labels`: NumPy array of given labels in the dataset. labels[i] should contain label for `i`-th datapoint. \n", - "- `predictions`: NumPy array of predictions generated through your favourite regressor. predictions[i] should contain predicted value for `i`-th datapoint. \n", - "\n", - "If you already have predictions from your regressor, you can generate label quality scores for each datapoint using the code below: \n", - "\n", - "
\n", - "\n", - "```python \n", - "\n", - "from cleanlab.regression.rank import get_label_quality_scores\n", - "label_quality_scores = get_label_quality_scores(labels, predictions)\n", - "\n", - "```\n", - "
\n", - "" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# 0. Visualization (can skip these details)" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "This is added just for reference. We will use this function to plot dataset, highlight points using label quality scores and true_errors.\n", - "You can skip this part and move to next section. " - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "
See the code for visualization **(click to expand)** \n", - "\n", - "```python \n", - "# Note: this pulldown is for docs.cleanlab.ai, if running on local Jupyter or colab, please ignore it. \n", - "\n", - "def plot_data(\n", - " data_x, data_y, circles, title, alpha=0.6, color=\"#1f77b4\", colorbar=False, xlabel=\"\", ylabel=\"\"\n", - "):\n", - " plt.figure(figsize=(14, 5))\n", - " data_x = data_x.to_numpy()\n", - " data_y = data_y.to_numpy()\n", - " plt.scatter(data_x, data_y, c=color, s=30)\n", - " for i in circles:\n", - " plt.plot(\n", - " data_x[i],\n", - " data_y[i],\n", - " \"o\",\n", - " markerfacecolor=\"none\",\n", - " markeredgecolor=\"red\",\n", - " markersize=10,\n", - " markeredgewidth=2.5,\n", - " alpha=alpha,\n", - " )\n", - " plt.title(title, fontsize=20)\n", - " plt.xlabel(xlabel)\n", - " plt.ylabel(ylabel)\n", - "\n", - " if colorbar:\n", - " plt.colorbar(orientation=\"vertical\")\n", - "\n", - "```\n", - "
" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "def plot_data(\n", - " data_x, data_y, circles, title, alpha=0.6, color=\"#1f77b4\", colorbar=False, xlabel=\"\", ylabel=\"\"\n", - "):\n", - " plt.figure(figsize=(14, 5))\n", - " data_x = data_x.to_numpy()\n", - " data_y = data_y.to_numpy()\n", - " plt.scatter(data_x, data_y, c=color, s=30)\n", - " for i in circles:\n", - " plt.plot(\n", - " data_x[i],\n", - " data_y[i],\n", - " \"o\",\n", - " markerfacecolor=\"none\",\n", - " markeredgecolor=\"red\",\n", - " markersize=10,\n", - " markeredgewidth=2.5,\n", - " alpha=alpha,\n", - " )\n", - " plt.title(title, fontsize=20)\n", - " plt.xlabel(xlabel)\n", - " plt.ylabel(ylabel)\n", - "\n", - " if colorbar:\n", - " plt.colorbar(orientation=\"vertical\")" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 1. Install dependencies and import them \n", - "You can use `pip` to install all packages required for this tutorial as follows:\n", - "\n", - "`!pip install cleanlab xgboost`" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "!pip install cleanlab xgboost" - ] - }, - { - "cell_type": "code", - "execution_count": 94, - "metadata": { - "nbsphinx": "hidden" - }, - "outputs": [], - "source": [ - "# Package installation (hidden on docs website).\n", - "# Package versions we used: xgboost==1.7.2\n", - "\n", - "dependencies = [\"cleanlab\", \"xgboost\"]\n", - "\n", - "if \"google.colab\" in str(get_ipython()): # Check if it's running in Google Colab\n", - " %pip install cleanlab # for colab\n", - " cmd = \" \".join([dep for dep in dependencies if dep != \"cleanlab\"])\n", - " %pip install $cmd\n", - "else:\n", - " missing_dependencies = []\n", - " for dependency in dependencies:\n", - " try:\n", - " __import__(dependency)\n", - " except ImportError:\n", - " missing_dependencies.append(dependency)\n", - "\n", - " if len(missing_dependencies) > 0:\n", - " print(\"Missing required dependencies:\")\n", - " print(*missing_dependencies, sep=\", \")\n", - " print(\"\\nPlease install them before running the rest of this notebook.\")" - ] - }, - { - "cell_type": "code", - "execution_count": 95, - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np\n", - "import pandas as pd\n", - "from cleanlab.regression.rank import get_label_quality_scores\n", - "import xgboost as xgb\n", - "import matplotlib.pyplot as plt\n", - "\n", - "np.set_printoptions(suppress=True)" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# 2. Import dataset and Generate predictions" - ] - }, - { - "cell_type": "code", - "execution_count": 107, - "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", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
exam_1exam_2exam_3notestrue_labelslabels
0537793NaN76.276.2
1816480great participation +1085.585.5
2748897NaN87.487.4
3619478NaN77.777.7
4489091NaN77.877.8
\n", - "
" - ], - "text/plain": [ - " exam_1 exam_2 exam_3 notes true_labels labels\n", - "0 53 77 93 NaN 76.2 76.2\n", - "1 81 64 80 great participation +10 85.5 85.5\n", - "2 74 88 97 NaN 87.4 87.4\n", - "3 61 94 78 NaN 77.7 77.7\n", - "4 48 90 91 NaN 77.8 77.8" - ] - }, - "execution_count": 107, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "path = \"/Users/krmayank/Desktop/Work/cleanlab/experiments/student_score_regression.csv\"\n", - "data = pd.read_csv(path, index_col=0)\n", - "data.head()" - ] - }, - { - "cell_type": "code", - "execution_count": 108, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Generate true errors\n", - "true_errors = np.where(data.labels != data.true_labels)[0]\n", - "plot_data(\n", - " data_x=data[\"exam_3\"],\n", - " data_y=data[\"labels\"],\n", - " circles=true_errors,\n", - " title=\"Messy Regression dataset\",\n", - " xlabel=\"exam_3 feature\",\n", - " ylabel=\"label (Y value)\",\n", - ")" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "In the dataframe displayed above, `labels` represents the noisy labels and `true_labels` represents the ground truth. Please note that, ground truth are usually not available in real dataset, we have added it here for comparision and to demonstrate our method. `notes` also has text information, we will model this a categorical variable. \n", - "\n", - "We will use `xgboost` as regressor for this tutorial. xgboost provides easy to use interface to process categorical variable. This is demonstrated in the code below:" - ] - }, - { - "cell_type": "code", - "execution_count": 109, - "metadata": {}, - "outputs": [], - "source": [ - "# XGBOOST automatically factors categorical variable, you just need to mark the columns as category\n", - "data.notes = data.notes.astype(\"category\")\n", - "\n", - "# XGBOOST takes data and label seperately, so you will need to divide data accordingly.\n", - "X = data.drop([\"labels\", \"true_labels\"], axis=1)\n", - "y = data[\"labels\"]\n", - "\n", - "# convert data to format \"DMatrix\" to make it compatible with XGBOOST.\n", - "xgboost_data = xgb.DMatrix(data=X, label=y, enable_categorical=True)\n", - "\n", - "# declare parameters and train the model.\n", - "params = {\"booster\": \"gblinear\", \"objective\": \"reg:squarederror\"}\n", - "boost = xgb.train(params=params, dtrain=xgboost_data, num_boost_round=50)" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 3. Using cleanlab to generate label quality scores" - ] - }, - { - "cell_type": "code", - "execution_count": 110, - "metadata": {}, - "outputs": [], - "source": [ - "# using trained xgboost model to get predictions\n", - "predictions = boost.predict(xgboost_data)\n", - "\n", - "# get label quality score for each example in the dataset using cleanlab\n", - "label_quality_scores = get_label_quality_scores(labels=np.array(y), predictions=predictions)" - ] - }, - { - "cell_type": "code", - "execution_count": 111, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot_data(\n", - " data_x=data[\"exam_3\"],\n", - " data_y=data[\"labels\"],\n", - " circles=true_errors,\n", - " color=label_quality_scores,\n", - " title=\"Messy Regression dataset with label quality scores\",\n", - " colorbar=True,\n", - " xlabel=\"exam_3 feature\",\n", - " ylabel=\"label (Y value)\",\n", - ")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "In the above plot, we have colored each datapoint considering its label quality score. \\\n", - "Datapoints in the plot are same as earlier plot in the notebook. \\\n", - "**Red circle** represents that these datapoint were incorrectly marked when compared to true_label. \n", - "\n", - "Low scores for datapoints marked in **Red circle** and High scores for other datapoints justifies that method can identify the errors in the dataset. " - ] - }, - { - "cell_type": "code", - "execution_count": 112, - "metadata": { - "nbsphinx": "hidden" - }, - "outputs": [], - "source": [ - "# Note: This cell is only for docs.cleanlab.ai, if running on local Jupyter or Colab, please ignore it.\n", - "from sklearn.metrics import roc_auc_score\n", - "\n", - "label_quality_scores = get_label_quality_scores(np.array(y), predictions=predictions)\n", - "\n", - "true_errors = (data.labels != data.true_labels).astype(int)\n", - "label_quality_scores_residual = get_label_quality_scores(\n", - " np.array(y), predictions=predictions, method=\"residual\"\n", - ")\n", - "\n", - "if roc_auc_score(true_errors, 1 - label_quality_scores) < 0.5:\n", - " raise ValueError(\"Label quality scores did not perform well enough\")\n", - "\n", - "if roc_auc_score(true_errors, 1 - label_quality_scores) <= roc_auc_score(\n", - " true_errors, 1 - label_quality_scores_residual\n", - "):\n", - " raise ValueError(\"Label quality scores did not outperform alternative scores\")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3.10.8 ('ENV': 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.10.8" - }, - "orig_nbformat": 4, - "vscode": { - "interpreter": { - "hash": "1ed33b5e6ac3d9870092cd802185bba6fb7a8302b6022e7097221f18c33cb7b2" - } - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} From c05f1fe6fdf1b2e41e3db24b27e6a8141e06a2e3 Mon Sep 17 00:00:00 2001 From: krmayankb Date: Tue, 27 Dec 2022 22:45:55 -0800 Subject: [PATCH 027/258] support for array_like --- cleanlab/internal/regression_utils.py | 126 +++++++++++++------------- cleanlab/regression/rank.py | 15 +-- 2 files changed, 70 insertions(+), 71 deletions(-) diff --git a/cleanlab/internal/regression_utils.py b/cleanlab/internal/regression_utils.py index a7bfb4bbd1..4e396f2d55 100644 --- a/cleanlab/internal/regression_utils.py +++ b/cleanlab/internal/regression_utils.py @@ -3,84 +3,88 @@ """ import numpy as np -import pandas as pd -from pandas.api.types import is_numeric_dtype -from cleanlab.typing import LabelLike -from typing import Optional +from numpy.typing import ArrayLike +from typing import Tuple, Optional def assert_valid_inputs( - labels: Optional[LabelLike], - predictions: Optional[LabelLike], + labels: ArrayLike, + predictions: ArrayLike, method: str, -) -> None: +) -> Tuple[np.ndarray, np.ndarray]: """Checks that ``labels``, ``predictions``, ``method`` are correctly formatted.""" - supported_types = (list, np.ndarray, pd.Series, pd.DataFrame) + # Load array_like input as numpy array. If not raise error. + try: + labels = np.asarray(labels) + except: + raise ValueError(f"labels must be array_like.") - # Check if labels and predictions are of supported types - if not isinstance(labels, supported_types) and not isinstance(predictions, supported_types): - raise TypeError( - f"Expected labels and predictions to be either of {supported_types}, Got labels of type {type(labels)}, and predictions of type {type(predictions)}", - ) + try: + predictions = np.asarray(predictions) + except: + raise ValueError(f"predictions must be array_like.") + + # Check if labels and predictions are 1-D and numeric + valid_labels = check_dimension_and_datatype(check_input=labels, text="labels") + valid_predictions = check_dimension_and_datatype(check_input=predictions, text="predictions") - # check if labels and predictions are 1-D and numeric - check_dimension_and_datatype(check_input=labels, text = "labels") - check_dimension_and_datatype(check_input=predictions, text = "predictions") + # Check if number of examples are same. + assert ( + valid_labels.shape == valid_predictions.shape + ), f"Number of examples in labels {labels.shape} and predictions {predictions.shape} are not same." - # check if number of examples are same. - assert len(labels) == len( - predictions - ), f"Length of labels {len(labels)} and predictions {len(predictions)} are not same." + # Check if inputs have missing values + check_missing_values(valid_labels, text="labels") + check_missing_values(valid_predictions, text="predictions") # Check if method is among allowed scoring method scoring_methods = ["residual", "outre"] if method not in scoring_methods: raise ValueError( - f"Passed method is not among allowed method. Expected either of {scoring_methods}, got {method}" + f"Passed method is not among allowed methods. Expected either of {scoring_methods}, got {method}." ) + # return 1-D numpy array + return valid_labels, valid_predictions -def check_dimension_and_datatype(check_input: Optional[LabelLike], text : str): - # check if input is empty - if not len(check_input): - raise ValueError( - f"{text} is Empty, check input." - ) - if isinstance(check_input, list): - if isinstance(check_input[0], list): - raise ValueError(f"{text} must be 1-D. List of List is not supported.") - elif not all(isinstance(x, (int, float)) for x in check_input): - raise ValueError( - f"All element of {text} must be of type numeric i.e., integer or float" - ) - - elif isinstance(check_input, pd.DataFrame): - if check_input.shape[1] != 1: - raise ValueError( - f"{text} must be 1-D. For DataFrame, second dimension must be 1, got {check_input.shape}." - ) - elif check_input.shape[1] == 1: - if not is_numeric_dtype(check_input): - raise ValueError(f"{text} must be 1-D and numeric type. got {check_input.dtype}.") - elif isinstance(check_input, (np.ndarray, pd.Series)): - if len(check_input.shape) != 1: - raise ValueError(f"{text} must be 1-D {type(check_input)}, got {check_input.shape}") - elif len(check_input.shape) == 1: - if isinstance(check_input, pd.Series) and not is_numeric_dtype(check_input): - raise ValueError(f"{text} must be 1-D and numeric type. got {check_input.dtype}.") - elif isinstance(check_input, np.ndarray): - if not all(isinstance(x, (int, float)) for x in check_input.tolist()): - raise ValueError(f"{text} must be 1-d and numeric type i.e., integer or float.") - - -def check_dimensions(labels: np.ndarray, predictions: np.ndarray) -> None: - if labels.ndim != 1: - raise ValueError( - f"labels have dimensions {labels.ndim}, Expected 1-D array as input for labels" - ) - if predictions.ndim != 1: +def check_dimension_and_datatype(check_input: np.ndarray, text: str) -> np.ndarray: + """ + Raises errors related to: + 1. If input is empty + 2. If input is not 1-D + 3. If input is not numeric + + If all the checks are passed, it returns the squeezed 1-D array required by the main algorithm. + """ + + assert isinstance( + check_input, np.ndarray + ), f"{text} could not be converted to numpy array, check input." + + # Check if input is empty + if not check_input.size: + raise ValueError(f"{text} is Empty, check input.") + + # Remove axis with length one + check_input = np.squeeze(check_input) + + # Check if input is 1-D + if check_input.ndim != 1: raise ValueError( - f"predictions have dimensions {labels.ndim}, Expected 1-D array as input for predictions" + f"Expected 1-Dimensional inputs for {text}, got {check_input.ndim} dimensions." ) + + # Check if datatype is numeric + if not np.issubdtype(check_input.dtype, np.number): + raise ValueError(f"Expected {text} to be Numeric, got {check_input.dtype}.") + + return check_input + + +def check_missing_values(check_input: np.ndarray, text: str): + """Raise error if there are any missing values in Numpy array.""" + + if np.isnan(check_input).any(): + raise ValueError(f"{text} has missing values, check input.") diff --git a/cleanlab/regression/rank.py b/cleanlab/regression/rank.py index 6ebe33af64..cd6c474c93 100644 --- a/cleanlab/regression/rank.py +++ b/cleanlab/regression/rank.py @@ -1,9 +1,9 @@ import numpy as np from cleanlab.outlier import OutOfDistribution from sklearn.neighbors import NearestNeighbors -from cleanlab.internal.regression_utils import assert_valid_inputs, check_dimensions +from cleanlab.internal.regression_utils import assert_valid_inputs from typing import Dict, Callable, Optional -from cleanlab.typing import LabelLike +from numpy.typing import ArrayLike """ Generates label quality scores for every sample in regression dataset """ @@ -11,8 +11,8 @@ def get_label_quality_scores( - labels: Optional[LabelLike], - predictions: Optional[LabelLike], + labels: ArrayLike, + predictions: ArrayLike, *, method: str = "outre", ) -> np.ndarray: @@ -54,12 +54,7 @@ def get_label_quality_scores( """ # Check if inputs are valid - assert_valid_inputs(labels=labels, predictions=predictions, method=method) - - # Convert to numpy array and check if they are 1-D array. - labels = np.asarray(labels) - predictions = np.asarray(predictions) - check_dimensions(labels, predictions) + labels, predictions = assert_valid_inputs(labels=labels, predictions=predictions, method=method) scoring_funcs: Dict[str, Callable[[np.ndarray, np.ndarray], np.ndarray]] = { "residual": get_residual_score_for_each_label, From d6ac6424c7b5b9ab4ba011e17da60d8e0c72cd45 Mon Sep 17 00:00:00 2001 From: krmayankb Date: Tue, 27 Dec 2022 22:47:13 -0800 Subject: [PATCH 028/258] unit tests to factor array_like --- tests/test_regression.py | 55 +++++++++++++++++++++++++++++++++------- 1 file changed, 46 insertions(+), 9 deletions(-) diff --git a/tests/test_regression.py b/tests/test_regression.py index dc29315f96..355752dee3 100644 --- a/tests/test_regression.py +++ b/tests/test_regression.py @@ -1,13 +1,25 @@ import numpy as np -import pandas as pd + +# import pandas as pd import pytest +from typing import Union, Sequence from cleanlab.regression import rank +ArrayLike = Union[np.ndarray, Sequence] + # To be used for all the tests labels = np.array([1, 2, 3, 4]) predictions = np.array([1, 3, 4, 5]) +# Inputs that are not array like +aConstant = 1 +aString = "predictions_non_array" +aDict = {"labels": [1, 2], "predictions": [2, 3]} +aSet = {1, 2, 3, 4} +aBool = True + + # test with deafault parameters def test_output_shape_type(): scores = rank.get_label_quality_scores(labels=labels, predictions=predictions) @@ -15,18 +27,43 @@ def test_output_shape_type(): assert isinstance(scores, np.ndarray) -# test for acceptable datatypes -@pytest.mark.parametrize("format", [pd.Series, pd.DataFrame, list]) -def test_type_error_for_input_types(format): - with pytest.raises(TypeError) as error: - _ = rank.get_label_quality_scores(labels=format(labels), predictions=format(predictions)) +@pytest.mark.parametrize( + "aInput", + [aConstant, aString, aDict, aSet, aBool], +) +def test_labels_are_arraylike(aInput): + with pytest.raises(ValueError) as error: + rank.get_label_quality_scores(labels=aInput, predictions=predictions) + assert error.type == ValueError + + +@pytest.mark.parametrize( + "aInput", + [aConstant, aString, aDict, aSet, aBool], +) +def test_predictionns_are_arraylike(aInput): + with pytest.raises(ValueError) as error: + rank.get_label_quality_scores(labels=labels, predictions=aInput) + assert error.type == ValueError # test for input shapes -def test_assertion_error_for_input_shape(): +def test_input_shape_labels(): + with pytest.raises(AssertionError) as error: + rank.get_label_quality_scores(labels=labels[:-1], predictions=predictions) + assert ( + str(error.value) + == f"Number of examples in labels {labels[:-1].shape} and predictions {predictions.shape} are not same." + ) + + +def test_input_shape_predictions(): with pytest.raises(AssertionError) as error: - _ = rank.get_label_quality_scores(labels=labels[:-1], predictions=predictions) - _ = rank.get_label_quality_scores(labels=labels, predictions=predictions[:-1]) + rank.get_label_quality_scores(labels=labels, predictions=predictions[:-1]) + assert ( + str(error.value) + == f"Number of examples in labels {labels.shape} and predictions {predictions[:-1].shape} are not same." + ) # test individual scoring functions From 2b327c30a3fd78a1c81b803bacadea42183e0069 Mon Sep 17 00:00:00 2001 From: Mayank Kumar Date: Tue, 27 Dec 2022 23:58:51 -0800 Subject: [PATCH 029/258] Update docs/source/tutorials/index.rst Co-authored-by: Jonas Mueller <1390638+jwmueller@users.noreply.github.com> --- docs/source/tutorials/index.rst | 1 - 1 file changed, 1 deletion(-) diff --git a/docs/source/tutorials/index.rst b/docs/source/tutorials/index.rst index d040963629..e0d63a7e06 100644 --- a/docs/source/tutorials/index.rst +++ b/docs/source/tutorials/index.rst @@ -16,4 +16,3 @@ Tutorials token_classification pred_probs_cross_val faq - From 4283a671c01a2753fcc6f299df69d2dd05666848 Mon Sep 17 00:00:00 2001 From: krmayankb Date: Tue, 11 Oct 2022 11:45:37 -0700 Subject: [PATCH 030/258] added basic regression ranking --- cleanlab/regression/__init__.py | 1 + cleanlab/regression/rank.py | 24 ++++++++++++++++++++++++ 2 files changed, 25 insertions(+) create mode 100644 cleanlab/regression/__init__.py create mode 100644 cleanlab/regression/rank.py diff --git a/cleanlab/regression/__init__.py b/cleanlab/regression/__init__.py new file mode 100644 index 0000000000..77e9b5a97b --- /dev/null +++ b/cleanlab/regression/__init__.py @@ -0,0 +1 @@ +from . import rank \ No newline at end of file diff --git a/cleanlab/regression/rank.py b/cleanlab/regression/rank.py new file mode 100644 index 0000000000..2cd91694c3 --- /dev/null +++ b/cleanlab/regression/rank.py @@ -0,0 +1,24 @@ +import numpy as np + +def get_label_quality_score( + true_labels: np.ndarray, + pred_labels: np.ndarray +)-> np.ndarray: + """ + Returns label quality score + + Score is continous value in range [0,1] + + 1 - clean label (given label is likely correct). + 0 - dirty label (given label is likely incorrect). + """ + residual = true_labels - pred_labels + quality_scores = np.exp(-abs(residual)) + return quality_scores + + +if __name__ == "__main__": +## WILL BE DELETED LATER + a = np.array([1,2,3,4]) + b = np.array([2,2,5,4.1]) + print(get_label_quality_score(a,b)) From 53455bff8410e06cdd5afccf92c69ad921507ff9 Mon Sep 17 00:00:00 2001 From: krmayankb Date: Fri, 4 Nov 2022 14:17:40 -0700 Subject: [PATCH 031/258] minor fixes, docstring modified --- cleanlab/regression/__init__.py | 2 +- cleanlab/regression/rank.py | 56 +++++++++++++++++++++++---------- 2 files changed, 40 insertions(+), 18 deletions(-) diff --git a/cleanlab/regression/__init__.py b/cleanlab/regression/__init__.py index 77e9b5a97b..aab0b677cf 100644 --- a/cleanlab/regression/__init__.py +++ b/cleanlab/regression/__init__.py @@ -1 +1 @@ -from . import rank \ No newline at end of file +from . import rank diff --git a/cleanlab/regression/rank.py b/cleanlab/regression/rank.py index 2cd91694c3..2b4520b1b7 100644 --- a/cleanlab/regression/rank.py +++ b/cleanlab/regression/rank.py @@ -1,24 +1,46 @@ -import numpy as np +import numpy as np -def get_label_quality_score( - true_labels: np.ndarray, - pred_labels: np.ndarray -)-> np.ndarray: + +def get_label_quality_scores(labels: np.ndarray, pred_labels: np.ndarray) -> np.ndarray: """ - Returns label quality score - - Score is continous value in range [0,1] - + Returns label quality score for each example in the regression dataset. + + Each score is continous value in range [0,1] 1 - clean label (given label is likely correct). 0 - dirty label (given label is likely incorrect). + + Parameters + ---------- + labels: + Raw labels from original dataset. + Array of shape ``(N, )`` consisting given labels, where N is number of datapoints in the regression dataset. + + pred_labels: + Predicated labels from regressor fitted on the dataset. + Array of shape ``(N,)`` consisting predicted labels, where N is number of datapoints in the regression dataset. + + Returns + ------- + label_quality_scores: + Array of shape ``(N, )`` of scores between 0 and 1, one per datapoint in the dataset. + + Lower scores indicate datapoint more likely to contain a label issue. + + Examples + -------- + >>> import numpy as np + >>> from cleanlab.regression.rank import get_label_quality_scores + >>> labels = np.array([1,2,3,4]) + >>> pred_labels = np.array([2,2,5,4.1]) + >>> label_quality_scores = get_label_quality_scores(labels, pred_labels) + >>> label_quality_scores + array([0.36787944, 1. , 0.13533528, 0.90483742]) """ - residual = true_labels - pred_labels - quality_scores = np.exp(-abs(residual)) - return quality_scores + assert ( + labels.shape == pred_labels.shape + ), f"shape of label {labels.shape} and predicted labels {pred_labels.shape} are not same." -if __name__ == "__main__": -## WILL BE DELETED LATER - a = np.array([1,2,3,4]) - b = np.array([2,2,5,4.1]) - print(get_label_quality_score(a,b)) + residual = pred_labels - labels + quality_scores = np.exp(-abs(residual)) + return quality_scores From 987ae0eefe29d5f7502c4e27a77e29e8c0a6eea2 Mon Sep 17 00:00:00 2001 From: krmayankb Date: Wed, 9 Nov 2022 17:25:35 -0800 Subject: [PATCH 032/258] tutorial added, added to docs index pages --- cleanlab/__init__.py | 1 + cleanlab/regression/rank.py | 2 + docs/source/cleanlab/regression.rst | 8 + docs/source/tutorials/index.rst | 1 + docs/source/tutorials/regression.ipynb | 338 +++++++++++++++++++++++++ 5 files changed, 350 insertions(+) create mode 100644 docs/source/cleanlab/regression.rst create mode 100644 docs/source/tutorials/regression.ipynb diff --git a/cleanlab/__init__.py b/cleanlab/__init__.py index 5746a49a21..753e47e82a 100644 --- a/cleanlab/__init__.py +++ b/cleanlab/__init__.py @@ -9,3 +9,4 @@ from . import outlier from . import token_classification from . import multilabel_classification +from . import regression diff --git a/cleanlab/regression/rank.py b/cleanlab/regression/rank.py index 2b4520b1b7..2fdde78299 100644 --- a/cleanlab/regression/rank.py +++ b/cleanlab/regression/rank.py @@ -1,5 +1,7 @@ import numpy as np +""" generate label quality score for regression dataset""" + def get_label_quality_scores(labels: np.ndarray, pred_labels: np.ndarray) -> np.ndarray: """ diff --git a/docs/source/cleanlab/regression.rst b/docs/source/cleanlab/regression.rst new file mode 100644 index 0000000000..1cae31915a --- /dev/null +++ b/docs/source/cleanlab/regression.rst @@ -0,0 +1,8 @@ +regression +============== + +.. automodule:: cleanlab.regression + :autosummary: + :members: + :undoc-members: + :show-inheritance: diff --git a/docs/source/tutorials/index.rst b/docs/source/tutorials/index.rst index e0d63a7e06..d0f89d7489 100644 --- a/docs/source/tutorials/index.rst +++ b/docs/source/tutorials/index.rst @@ -16,3 +16,4 @@ Tutorials token_classification pred_probs_cross_val faq + regression diff --git a/docs/source/tutorials/regression.ipynb b/docs/source/tutorials/regression.ipynb new file mode 100644 index 0000000000..46f3b5ee38 --- /dev/null +++ b/docs/source/tutorials/regression.ipynb @@ -0,0 +1,338 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Label Quality Scores for Regression with Noisy Labels\n", + "In this tutorial, you will learn how to use cleanlab on regression dataset to: \n", + "- find label issue in your regression dataset\n", + "- generate label quality scores for each example in the dataset. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Install dependencies and import them \n", + "You can use pip to install all packages required for this tutorial as follows:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "!pip install cleanlab\n", + "!pip install scikit-learn" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np \n", + "import pandas as pd \n", + "from cleanlab.regression.rank import get_label_quality_scores\n", + "from sklearn.linear_model import LinearRegression\n", + "import matplotlib.pyplot as plt " + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "def make_data(feature_size = (20, 3), \n", + " means = [8, 20, -10], \n", + " stds = [2, 5, 3], \n", + " bias = 0.8,\n", + " coeff = [2, 0.1, 0.5],\n", + " error = [-2, 0, 2], \n", + " prob_error = [0.2, 0.6, 0.2], \n", + " seed = 42\n", + ") -> pd.DataFrame:\n", + " \"\"\"\n", + " feature_size: Tuple of (datapoints, features)\n", + " \"\"\"\n", + " assert (len(means) == feature_size[1]), (f\"length of mean {len(means)} is not same as features requested{feature_size[0]}\")\n", + " assert (len(stds) == feature_size[1]), (f\"length of stds {len(stds)} is not same as features requested{feature_size[0]}\")\n", + " np.random.seed(seed) \n", + "\n", + " features = []\n", + " for i in range(feature_size[1]):\n", + " values = coeff[i] * np.random.normal(loc=means[i], scale=stds[i], size=feature_size[0])\n", + " features.append(values)\n", + " \n", + " true_labels = sum(map(np.array, features))+ bias\n", + " labels = true_labels + np.random.choice(error, feature_size[0], p=prob_error)\n", + " \n", + " data_dict = {\n", + " \"lables\" : labels, # You have these labels, which have some errors.\n", + " \"true_labels\" : true_labels, # You never get to see these perfect labels.\n", + " } \n", + " for idx, feature in enumerate(features): # adding names to each features \n", + " data_dict[\"feature_\"+str(idx+1)] = feature\n", + " data = pd.DataFrame.from_dict(data_dict)\n", + " col = list(data.columns)\n", + " new_col = col[2:] + col[:2]\n", + " data = data.reindex(columns=new_col)\n", + " return data\n", + "\n", + "def plot_data(data, \n", + " circles, \n", + " title, \n", + " alpha=0.6, \n", + " color = '#1f77b4', \n", + " xlabel = \"feature\", \n", + " colorbar = False):\n", + " \n", + " plt.figure(figsize=(14, 5))\n", + " plt.xlabel(xlabel, size=13)\n", + " plt.ylabel('label',size=13)\n", + " data = data.to_numpy()\n", + " plt.scatter(data[:,0], data[:,1], c = color, s=60)\n", + " for i in circles:\n", + " plt.plot(\n", + " data[i][0],\n", + " data[i][1],\n", + " \"o\",\n", + " markerfacecolor=\"none\",\n", + " markeredgecolor=\"red\",\n", + " markersize=14,\n", + " markeredgewidth=2.5,\n", + " alpha=alpha\n", + " )\n", + " plt.title(title, fontsize=20)\n", + " \n", + " if colorbar: plt.colorbar(orientation = 'vertical')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABIMAAAHiCAYAAAB7mwyvAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAADBF0lEQVR4nOzde1xUdf4/8NcZGIbbcFcBQZBBAwPRxEotFbtoba1m5Vpt1812Xbddt23bzd22bdvdtmzNX2X2zcpu28XaLbOLlIFaaiahXBRSQEUUVJC73Of8/vgwN5gZZmCGufB6Ph48GphzznzOzDB53rwvkizLMoiIiIiIiIiIaERQuHoBREREREREREQ0fBgMIiIiIiIiIiIaQRgMIiIiIiIiIiIaQRgMIiIiIiIiIiIaQRgMIiIiIiIiIiIaQRgMIiIiIiIiIiIaQRgMIiIiIiIiIiIaQRgMIiIiIiIiIiIaQRgMIiIiIiIiIiIaQRgMIiIiIvISd911FyRJQmJioquXMmz++te/QpIkSJLk6qUQERF5DAaDiIjIbW3fvl1/kSdJEtRqNc6fPz/gfm1tbQgNDTXZd/v27c5fsJcxfv6Mv/z8/DBmzBjMmTMH//jHP3DmzBlXL5WIiIiI7MBgEBEReYyWlhZ89NFHA263efNmNDU1OX9BI1RXVxfOnDmDnTt34s9//jNSU1PxxRdfuHpZRE6TmJgISZJw1113uXopTsdMKyKikYHBICIi8gj+/v4AgDfffHPAbXXb6PahocnMzERRUZH+a/fu3XjjjTdw6aWXAgDOnTuHxYsX4+jRoy5eKb322muQZRnHjh1z9VKIiIjIjTEYREREHuHHP/4xAODLL79ETU2Nxe3OnDmjz1JZuHDhsKzN2wUFBSEtLU3/NWPGDNx+++3YvXs3brrpJgBAa2sr/v3vf7t4pURERERkCwaDiIjII1x99dWIjo5GT08P3nnnHYvbvfPOO+ju7kZ0dDSuuuqqYVzhyCNJEv71r3/pv9+2bZsLV0NEREREtmIwiIiIPIKPjw9uueUWANZLxd544w0AwK233gofHx+bj5+bm4s777wTSUlJCAwMREhICNLT0/H73/8ep06dsrrvqVOn8Mc//hEXXXQRQkNDoVQqMWbMGKSnp+OWW27Ba6+9ZrGH0YcffohFixYhLi4OKpUKarUaSUlJuPzyy/HII4/gu+++02/b1dWF6OhoSJKEBQsWDHhOxcXF+t4fTz31lM3PhT2SkpIQFBQEADhx4oTVbcvKyvDb3/4W6enpCA0NRUBAAJKSknDXXXchLy9vwMfq7u7Gs88+i4svvhghISEICwtDZmYmnnnmGXR2duLYsWP6833ttdf67d930lZ1dTX+8Ic/4MILL4RarTbbaLynpwevv/46rrvuOsTGxkKlUiEyMhKXXXYZ1qxZg7a2Nqtr/v777/Gzn/0MEydORFBQEPz9/REfH49p06ZhxYoV+PjjjyHLcr/92tvb8eyzz2Lu3LkYNWoUlEolIiIicMEFF+Caa67BmjVrzJaC2TpNrKioCPfddx8mTJiAwMBAqNVqXHjhhfjtb39rtcTM3HP85Zdf4vrrr0d0dDRUKhXGjx+P5cuXo6qqyuoabFVVVYUVK1YgKSkJ/v7+iI2NxY9//GObg4+tra147733cO+992LKlCn639FRo0Zhzpw5ePrpp9HS0mJ237lz50KSJBw/fhwA8Prrr/drqD537lyTferr67Fx40b89Kc/xaRJkxAcHAw/Pz9ER0dj/vz5eOmll9DZ2Wl1zT09PXjttdcwf/58REdHw8/PD6GhoZgwYQKuuOIK/POf/8ShQ4esHuOjjz7CzTffjHHjxsHf31//+/LYY4+hvr6+3/avvfYaJEnCY489pv+ZuQbyLEEkIvISMhERkZvKzc2VAcgA5I0bN8r5+fn674uLi/ttf/DgQf39+/fvlzdu3Kj/Pjc31+xjtLW1yUuXLtVvZ+4rKChI/vjjj83uv3PnTjkkJMTq/gDkLVu2mOzX3d0t33zzzQPuN23aNJP9fv/738sAZIVCIVdVVVl9/n7729/KAGRfX1+5urra6rbm6NYwZ84cq9uFhobKAOTQ0FCL26xevVpWKpUWz1OSJPmRRx6xuH9jY6N86aWXWtz/4osvlvfv32/yfunrzjvvlAHICQkJ8p49e+SoqKh+xzF+nxw/flzOyMiw+vokJyfLP/zwg9k1r1mzRlYoFAO+xs3NzSb7nTp1Sp40adKA+/3ud7+zeo6W/POf/7S6LpVKJb/++utm9z169KjJc/zHP/7R4nFGjRolHzp0yOI6bDHQ79df//pX+dFHH9V/b86cOXMGfC7Hjx8vl5SUDGrfvr8fCQkJA+4zdepUi7+Tzc3N8uWXXz7gMW688Uaz+587d06eN2+e1X1Hjx4t79mzx2Q/489La19Hjx4d+IUjIiK35wsiIiIPMXXqVFx44YU4ePAg3nzzTZMSJcCQMZSWloYpU6bgwIEDVo8nyzJuuukmfPrppwCA66+/HkuWLEFSUhIUCgW+++47/Pvf/0ZlZSVuuukm7Nq1C5mZmfr9Ozo6sHTpUjQ1NUGtVmP58uXIysrC6NGj0dnZiaNHj2L37t348MMP+z32+vXr8f777wMALrvsMtx7773QaDQICgpCXV0dCgsLsXXrVjQ2Nprsd++992L16tXQarV444038PDDD5s9t66uLrz11lsAgGuuuQbR0dFWn4vBqq6u1q/RUjbK6tWr8dBDDwEAJk+ejOXLl2PChAkICwvDDz/8gOeffx579uzB448/jqioKPz617/ud4ylS5fi22+/BQDMmjUL999/P5KTk3H27Fm89dZb+M9//oNf/OIXNq25paUFN954I9rb2/GnP/0JV111FQIDA1FUVISYmBgAQF1dHS677DKcOHECKpUKy5Ytw5w5c5CYmIiWlhZ88cUX+H//7/+hrKwM11xzDfLz8xEaGqp/jMLCQjz44IPQarUYP348fvWrX2HKlCmIiIhAc3MzfvjhB+Tm5mLz5s391nf//ffrsz5++tOfYvHixYiNjYWPjw+qq6uRl5dndj9bvPDCC1i1ahUAYNSoUfjDH/6AWbNmoaenB9u2bcPq1avR2tqKu+66C1FRUbj22mstHmvDhg3YvXs35syZg5///OeYOHEiGhoa8MYbb+CNN97A2bNncc8992DPnj2DWmtlZSWuu+46NDU1QaFQ4L777sNNN92E0NBQFBYW4l//+hf++te/mvxOmtPd3Y309HT8+Mc/RmZmJmJjYyHLMo4fP44PP/wQmzZtwtGjR7Fo0SIcOHDApPH8xo0b0draivnz5+PUqVNYuHAh/v73v5scX5cZp9PT04NLLrkE1113HaZOnYoxY8boPw/eeustbN26Ffv378fSpUv7ZaIBYprX119/DQC47rrrcNttt+mze86cOYP9+/fjk08+MTvtq6OjA1deeSXy8/Ph4+ODW2+9Fddeey3Gjx+Prq4u7Ny5E2vWrMGZM2dw7bXXYv/+/UhISAAALFq0CJmZmXjhhRewfv16ACKDrK+xY8dafb6JiMhDuDoaRUREZEnfzCBZluUnn3xSBiDHx8fLWq1Wv61Wq5Xj4+NlAPJTTz0ly7I8YGbQSy+9JAOQlUql/Pnnn5tdw7lz5+QLL7xQBiDPmjXL5L6vvvpKf/y+mT/Gurq65MbGRpOf6f7yf8kll8hdXV0W962rq+v3M92+EydOtLjf//73P/3aPvzwQ4vbWaPb31pm0P3336/f7vHHH+93/8GDB/UZQY8++qjJa6bT09Mj//SnP5UByMHBwfK5c+dM7v/oo4/0j7F48WK5p6en3zGefvppk+wFa5lBusc5cOCAxfO69dZb9Rk2FRUVZrfJz8+Xg4KCZADyqlWrTO575JFHZEBkldXU1Fh8nIaGBpPzaWtr0z9f5jJ/jJl7b1jLDDpz5owcGBgoA5BjY2PlyspKq+c0duxYubOz0+R+48wgAPKyZcvMvqb33nuvfpv8/Hyr52HJTTfdpD/G22+/3e/+pqamfplb5hw+fNjq43z55Zf6TKmXX37Z7Da6bJ8777xzwHUP9Hivvvqqfr3btm3rd7/uc+ymm26yehxzr/+qVatkAHJYWJicl5dndr9jx47JMTExMgD51ltv7Xf/QJlWRETkHdgziIiIPMptt90GhUKBEydOmPxVffv27Thx4gQUCgVuvfXWAY8jyzKefPJJAMCvf/1riz14wsPDsXr1agDArl27cOTIEf19xlPNZs+ebfGxfH19ERISYvIz3b4zZ86Er6/lRN2IiIh+P7v33nsBAIcPH8auXbvM7rdx40YAwOjRo3HddddZPP5gNDc3Iz8/H3fffTeef/55AMCECROwYsWKftv++9//RldXFzIzM/Hoo4+azWZQKBR47rnnoFKp0NLSgg8++MDk/hdffBEAEBAQgBdffBEKRf9/vjzwwAO46KKLbD6Hhx56CBkZGWbvO3bsGN577z0AwPPPP4/x48eb3W7q1Kn6c+7bo0j3+k6cOBFjxoyxuI7Q0FCT8zl37hy6uroAWH9PAebfG9Zs3LgR58+fBwCsWbMG8fHx/baZOnWqPtvs5MmT+OijjyweLyYmBs8995zZ1/TBBx/U39ZludijpqZGn1F33XXX6fuFGVOr1XjppZcGPNaECROs3n/llVfqpxVaO19bDfR4d999N6ZMmWLx8XTvncsvv9zqcfq+/i0tLVi3bh0A4PHHH8e0adPM7peQkIBHHnkEAPD++++jtbXV6uMQEZF3YjCIiIg8ytixY5GVlQXAtJG07va8efNsKmM4dOgQysvLAUA/Ht0S44ty45IXXUkRYAi+2Eq375YtW1BbW2vXvjfffLO+JMnc454+fRqff/45AOD222+3GmyyxY4dO0wayIaEhGDatGn6AMjChQuxfft2hIeH99t3y5YtAIAbb7zRbNBAJywsDOnp6QBMn+Pu7m7s2LEDALBgwQKMGjXK7P6SJOH222+3+Zxuu+02i/d9+umn6OnpQWBgIK655hqrx9G9N06dOoXKykr9z3Wv76FDh0yagA8kMjISfn5+AMR7uru72+Z9B6JruBwWFobFixdb3E4XbDTex5ybbroJKpXK7H0XXHABgoODAQAVFRV2rzU3Nxc9PT0ARPDEkosvvhgXXnihXcc+e/Ysjhw5guLiYv2X7n1VUFBg91qtkWUZNTU1OHz4sMnj6T6jzD2e7r3z3nvv6YN3ttixY4e+ZNPWz7Suri58//33Nj8GERF5DwaDiIjI49xxxx0AgP/+979oa2tDW1ubPptEd99AjKdXzZgxw+zUHN2X7qIWMM0Guuyyy5CUlAQAWLlyJS6++GI88cQT2LVr14DTgu68804AYsJWcnIy7rnnHrzzzjs2TWAKCAjQZz9t2rSp3wWjcRDhnnvuGfB4QxEbG4uVK1ciNja2333Hjx/H2bNnAQAPP/yw1edYkiT9a2L8HJeXl+sndlnKdNAZqHeMTnBwsP51M0e3jvPnz8PX19fqmo2zrozXfcstt0CpVKKjowOzZs3C9ddfjxdffBHFxcVmp4fpqFQq/OQnPwEAfPDBB0hOTsZDDz2Ezz77DA0NDTadnyXFxcUAgIsuughKpdLidmPGjNH3f9LtY05KSorVx9MFB5ubm+1cqWmvmunTp1vd9uKLLx7weLt27cJPfvITREZGYvTo0Zg4cSLS09P1Xxs2bAAAuwOzlnz66ae47rrrEBoaipiYGFxwwQUmj6frU2bu8XSfDbt379b3m/rwww/1v0uWGH+mxcTEWH3fpqWl6bc1ft8SEdHIwWAQERF5nMWLFyMwMBBNTU3YvHkzPvroIzQ3NyMoKMhqxoOxM2fODOqxjQMvSqUSW7ZsQWpqKgBg3759WLVqFS677DKEhYVhwYIFePvtt/UZDsbuuecerFq1Cr6+vmhsbMTGjRtx6623Ij4+HsnJyfjd735nNaNCl73R3Nzcr6xKly10ySWXYNKkSYM6T2OZmZkoKipCUVERCgsL8cUXX+CRRx5BaGgoTp48iQULFpgtBXLEc2w8AttSVpCt9+uEhYVZvd8R605JScE777yD8PBwdHd345NPPsHy5cuRnp6O0aNH4/bbb7dYPvX888/j+uuvByACaqtXr8aPfvQjREZGYvr06Vi9enW/xuK2OHfuHABROjgQXcNx3T7mBAYGWj2GrvzN3Pt/IMaPO9B6rZXhAaIh82WXXYZNmzZZPR8A+sDjYMmyjHvvvRfXXXcdPv300wEDYeYe75FHHsE999wDSZJw5swZrFu3DosXL8bo0aORlpaGRx99FKdPn+63nyPet0RENHJwmhgREXmc4OBg3HDDDfjPf/6DN998U59pccMNN/Sb7GOJ8QXqli1bLE7C6qvvhemkSZNQVFSELVu2YMuWLdi5cyfKysrQ1taG7OxsZGdnY82aNfjss8/67fuPf/wD9913H/7zn//gq6++wrfffovz58+jvLwca9aswXPPPYdnn33W7JSsiy66CFOnTsX+/fuxceNGfUbU3r179ZOoHJUVFBQUZJJJkJ6ejquuugpLlizBzJkz0dzcjNtuuw3FxcUmvZGMn+O//OUvuPnmm21+PGfy8fGxer9u3VFRUcjNzbX5uH17C91444248sor8d577yE7Oxtff/01zp49i9raWrz11lt46623cOedd+LVV1816RsUEhKCjz/+GN999x02bdqE7du348CBA+jp6UFeXh7y8vLw9NNP46OPPsKMGTPsOHPBWrmeOxrKer/66is89thjAICkpCQ8+OCDuOyyyzBu3DgEBQXpSyj/8pe/4PHHHx/yWl999VW88sorAIApU6Zg5cqVuOSSSzB27FgEBgbq33t33HGHyWeXMaVSiVdeeQW/+93v8M477yAnJwd5eXno7OzEwYMHcfDgQaxZswZvvfUWFi5cqN/P+PctPz/favaXsbi4uKGcMhEReSgGg4iIyCPdcccd+M9//oMvvvjC5Ge2ioyM1N8OCwszCXbYy8fHB4sWLcKiRYsAiHHrW7duxbp16/D999/j+++/x89//nOzI+YTEhKwatUqrFq1Cl1dXdi3bx82bdqE//u//0N7ezt++ctf4pJLLsHUqVP77XvvvfdixYoV2LFjB44ePYrx48frs4ICAwOxdOnSQZ+TLdLS0vDPf/4T999/P06cOIHVq1ebXFAbP8dKpXJQz7FxH6KBymQGut9WunU3NzcjNTV1wOCRNaGhobjvvvtw3333AQBKSkqwefNmPPfcczh16hRef/11TJ06Fb/5zW/67XvxxRfrS6Cam5uxfft2vPbaa/jf//6HM2fO4MYbb0R5eTkCAgJsWktERASqq6vNZpX0pSsdsrdJtaMYv+6nT5822+za+H5LdOVf4eHh+Pbbby1mjw2UMWQr3eMlJydj9+7dFl8bWx5v0qRJePzxx/H444+jvb0d33zzDd5++2288cYbaGlpwS233ILy8nJ9jyHj37dRo0YxyENERFaxTIyIiDzSFVdcgZiYGHR3d6O7uxuxsbG44oorbN7fOLhiaSLXYMXExODuu+/Gnj179BOuPvnkkwFLUJRKJWbOnIm1a9fi7bffBiDKTvqWgencdtttCAgIgCzLeO2119DW1oZ3330XgMhK6TvBzBl+/vOf6zNinnnmGZMeKElJSfpG14N9jjUaDfz9/QFgwEa3xj1ThkL33ujo6HDYMXVSU1Pxxz/+Ed9++60+A2rTpk0D7qdWq3H99dfjv//9L379618DEEHHb775xubH1gXj8vPzrTamPnPmDI4fP26yz3DTNRMHRPmlNdbuP3jwIAAgKyvLahnhQK+zrdlJusf78Y9/bDEQJMsy8vPzbTqejr+/P6688kq8+uqr+umGbW1t+OSTT/TbOOozzdMyx4iIaHAYDCIiIo/k4+OD22+/HSqVCiqVCrfffrvZkeOWXHTRRfq/nL/00ktob293+BqVSiXmzJkDQEzFsqcBsHFgy1JT29DQUP3UoNdffx0ffPCBvpeMsxtH6yiVSvzxj38EALS2tuKZZ57R3+fj44Nrr70WAPDFF1+gpKTE7uP7+vrqJx9t3brVYvaPLMsm0+WG4vrrr9dfEK9du9Yhx+wrPj4eEydOBGB/02Jb3hvmXHnllQCAhoYG/O9//7O43SuvvKIvX9LtM9yysrL0GVmvv/66xe327dtntcm1LuhlbXz6/v37sXfvXqvr0QUkOzo6rG5ny+Nt3rwZ1dXVVo9jjaXX/8orr9T3cXr22WetNiq3RneuwMDnS0REnovBICIi8lhPPvkk2tvb0d7ejn/961927atQKLBq1SoAYvT1HXfcYfXCp6mpCc8//7zJz77++muUlZVZ3Kezs1M/Fj04ONgkM+Gtt96ymp1hXP7WtxeNMV0j6ePHj+Ohhx4CILJpdEGo4XDXXXfpR2WvW7fOpLnxww8/DB8fH2i1Wtx0001Wp6X19PTgP//5T79tfv7znwMQmRC/+MUvoNVq++27Zs0au7MtLLngggv0/Y3effddrFmzxur2R48exTvvvGPys48++shq8O/EiRMoLS0FYPr6VlRU6N8zltj63ujr7rvv1gcLfve73+HkyZP9tikoKMA///lPAMDYsWP1pY/DLSYmRt8P5+OPPzabPdXS0qJ/b1gyYcIEAMA333xj9nf17NmzuP32221aDyCm29nyeFu2bDFbClZeXo4VK1ZY3P/cuXPYsmWL1UCOpdc/LCwMv/rVrwCISWS//e1vzf6u6Jw+fRovv/xyv5/rzlW3XiIi8lIyERGRm8rNzZUByADkjRs32r3/xo0b9fvn5ub2u1+r1co33HCDfhuNRiM/9dRT8vbt2+X9+/fLO3bskP/v//5PvuWWW+SgoCA5MjLSZP9HH31UVigU8pw5c+SnnnpK3rp1q/z999/L33zzjfzqq6/KF198sf7Yv/nNb0z2BSCPGTNGXr58ufzmm2/Ku3fvlvPz8+XPP/9cfuCBB+SAgAAZgBwcHCxXVlZaPc+JEyfqHweA/Pjjj9v9XJmjO96cOXMG3PaZZ57Rb/+3v/3N4n2hoaHy73//e/nzzz+X8/Pz5d27d8tvv/22fP/998sxMTEyALmoqKjf8a+++mr9MWbNmiW/99578vfffy9v3bpV/ulPfyoDMHm+X3vttX7HuPPOO2UAckJCwoDnU1dXJyclJemPN3v2bPnll1+W9+zZI+fn58tffvml/PTTT8tXXnmlrFAo5BtvvNFk/zlz5siBgYHyzTffLK9fv17/nsrJyZGfeuopOT4+Xn/sDz/8UL+f7j0/adIk+U9/+pP84Ycfyt9995383Xffyf/973/lJUuW6PebMmWKrNVq7TrHdevW6fcfM2aM/Mwzz8h79+6Vd+3aJT/22GNycHCwDECWJEn+9NNP++1/9OhRm38nExISZADynXfeOeDzbc7Ro0dltVotA5B9fHzkX/7yl3JOTo6cl5cnv/rqq/r3fWZmpn5Nfb3//vv6+2JjY+Vnn31W3rVrl7xr1y559erVckxMjCxJkjxjxgyLx5BlWf7Tn/6kv/+JJ56QDxw4IB85ckQ+cuSIXFVVpd9u9erV+u0mTpwov/LKK/LevXvlHTt2yI8++qgcGhoq+/v7yxdddJHZ10n3/CYmJsoPPPCA/N5778nffvutnJeXJ2/ZskW+7777ZIVCIQOQx44dKzc3N5vs397eLl9yySX6NWRkZMjPP/+8/M033+jff88995y8cOFC2c/PT542bVq/cz1y5Ih+/6uvvlresWOHfPjwYf35dnV1DeLVJCIid8NgEBERuS1nB4NkWZY7Ozvl5cuXy5IkmQRUzH2NHz/eZN9HH310wH0AyAsXLpTPnz9vsq8t+4WGhsqff/75gOf55JNP6vdRKBTyiRMn7H6uzLEnGNTa2ipHRUXJAOTIyMh+F6kvvfSSHBgYOOA5+/n5yUeOHOl3/Pr6epNgT9+vqVOnynl5efrv33333X7HsCcYJMuyXF1dLV9++eU2vVZ33323yb5z5swZcB+FQtEvcGf8nrf2lZKSIldUVAzqHP/xj3/oAwrmvlQqlfz666+b3Xc4g0GyLJ4PXUDI3Ndf/vIXk99Dc+6++26L+/v4+Mhr164d8BhVVVVyRESE2WMY/350dnaaBC77fgUEBMibNm2y+DoZP7/WvmJiYuS8vDyza21qapIXL15s03GysrLMHsM46Nj36+jRowO+bkRE5P5YJkZERCOaUqnECy+8gIKCAtx///1IT09HaGgofHx8EBoaiilTpuBnP/sZPvjgg349bx588EH897//xfLly3HppZdi3Lhx8Pf3h7+/PxITE7FkyRJ88skn+Oijj/o1ky0uLsaTTz6J66+/HpMmTUJkZCR8fHwQFhaGSy+9FI8++ih++OEHLFiwYMBzMC5zueqqq1wyRSgwMBC//e1vAQB1dXVYv369yf3Lli1DRUUFHnvsMcyaNQtRUVHw9fVFUFAQJk6ciBtvvBEvvvgiTp48ieTk5H7HDwsLwzfffINnnnkG06ZNQ3BwMNRqNaZMmYInnngCu3fvNpn6pWtcPRTR0dHYuXMnPvnkE9x2221ISkpCYGAglEolRo0ahZkzZ+J3v/sdduzYgVdffdVk33feeQcvvfQSbr31VkyZMgXR0dHw9fVFcHAwLrzwQixfvhz79+/Hn//8Z5P9Lr/8cmzfvh0PP/wwsrKykJycDLVaDaVSiTFjxuDqq6/Giy++iAMHDthVImZs1apV2L9/P5YtWwaNRoOAgAAEBQUhNTUVv/nNb1BaWmrXZD5nmjt3Lg4ePIjly5cjISEBfn5+GDNmDH70ox9h69at+rHx1rz66qt48803cfnll0OtVkOlUiEhIQG33347du/ebXaSW19jx47Fd999h5/97GdITk426atjTKlU4tNPP8Wzzz6LzMxMBAYGIiAgAMnJyfjFL36B/Px8fQmiOQkJCfjuu+/w17/+FVdffTUuuOAChIWFwdfXF1FRUZg9ezZWr16N0tJSTJs2zewx1Go1/vvf/+Lrr7/GvffeiwsuuABqtRq+vr6IiIjA9OnTsWLFCnz22Wf48ssvzR7jrbfewlNPPYWLL74YoaGhdvVjIyIizyDJ8iC7yxEREZFb+PLLL3H11VcDAN577z0sWbLExStyjbfeeksfGCsrK4NGo3HxioiIiIjcE8P8REREHk6XlRIZGalvujsS6Zo4jxo1CklJSS5eDREREZH7YjCIiIjIg5WXl+ODDz4AIKZFqVQqF6/IOU6ePIm2tjaL97/88sv47LPPAAB33HGHfjQ8EREREfXHMjEiIiIPc/LkSZw/fx4VFRX4wx/+gIKCAvj7+6O8vByxsbGuXp5TvPbaa3jooYewdOlSzJ07FwkJCdBqtSgvL8d7772Hjz76CAAwZswYHDx4EJGRka5dMBEREZEb83X1AoiIiMg+t912G3bs2GHys8cff9xrA0E6Z8+exXPPPYfnnnvO7P0xMTH49NNPGQgiIiIiGgCDQURERB4qMDAQEydOxMqVK3HnnXe6ejlOdd1112H9+vXIzs7GoUOHcPbsWTQ3NyMsLAypqam4/vrr8Ytf/AJqtdrVSyUiIiJyeyOuTEyr1eLUqVNQq9XsJ0BEREREREREXkOWZTQ3NyM2NhYKheU20SMuM+jUqVOIj4939TKIiIiIiIiIiJzixIkTiIuLs3j/iAsG6dLHT5w4gZCQEBevhoiIiIiIiIjIMZqamhAfHz9g6fyICwbpSsNCQkIYDCIiIiIiIiIirzNQWxzLBWREREREREREROR1GAwiIiIiIiIiIhpBGAwiIiIiIiIiIhpBGAwiIiIiIiIiIhpBRlwDaSIiIiIiciO1tcDOncDBg0BzM9DRAahUgFoNpKUBs2cDkZGuXiURkVdhMIiIiIiIiIZfSQmQkwMUFQGybHpfezvQ2AhUVQHZ2UB6OjBvHpCa6pq1EhF5GQaDiIiIiIho+Gi1wKZNQG6ubdvLMlBYKL6ysoAlSwAFu10QEQ0Fg0FERERERDQ8tFpgwwYgP7//fXFxQHKyKBHr6ADKykRmkLHcXJExtGwZA0JEREPAYBAREREREQ2PTZtMA0GSBGRmioyfpCTxvY4sAxUVIgCUl2coJcvPF8dZunR4105E5EUYDCIiIiIiIucrKTEtDVMqRYZPRgYAoLSmCVuLa9DU1o2QAF8sSItGikYDaDTA9Okio6irS+ybmyv2Yw8hIqJBYTCIiIiIiIicLyfHcFuS9IGgY7WteGDTAeRXNsBHIUEhAVoZWLvtCKYlhOPfN2cgMSNDbL9+vSFDKCeHwSAiokFioS0RERERETlXXZ2YGqaTmakPBC1ctwsFVY0AgB6tjK4eGT1aEfA5cKIBC9ftwrHaVpEJlJlpOEZRkTguERHZjcEgIiIiIiJyrp07TcfHZ2UBAB7YdAAtHd364E9fPVoZLR3dePD9AvGDuXMNd8qyOC7RCFNa04S12w7jb1sOYe22wyitaXL1ksgDsUyMiIiIiIicq7jYcDsuDkhKQmlNE/IrGwbctUcrI+94PUprmkQPobFjgZMnDce94QbnrJnIzdhUUhkVZLpTba0Imh48CDQ3i0l9KhWgVgNpacDs2UBkpGtOiFyKwSAiIiIiInKu5mbD7eRkQJKwtbgGPgrJYlaQMR+FhOzi00iJDhH764JBLS1OWjCRe9GVVLZ0dAMQQdIeo/t1JZWbV8wSAaGSEtFXq6jINCsPANrbgcZGoKoKyM4G0tOBefPYg2uEYTCIiIiIiIicq6PDcFulAgA0tXVDIcHkgtYShQQ0tnWZ7A9AXNQSjQC2llT+/r39eD+yynRynzWyDBQWiq+sLGDJEkDBbjIjAYNBRERERETkXCqVIXDTGxgKCfCFDUlBAEQpTGiA0mR/AIC/vwMXSeSebC2p1Pb0YMKWd1E/qhXhgX6md8bFiaw6lUr8DpWVicwgY7m5ImNo2TIGhEYABoOIiIiIiMi51GpxkQmIi1BZxoK0aKzddsSm3Xu0YnvIsthfJzjYCYslci+2llReV/I10k+Xo8o3VASDJElM4MvKApKSxPc6sgxUVIgAUF6eoZQsPx/YtAlYutSJZ0TugMEgIiIiIiJyrrQ0QxZCVRVQUYEUjQYXjQtDQVWj1YtcH4WEqfFhuCBaLQJBun5BuuMSeTlbSio1tScwo7IIkgR0dmsBpVJk+GRkABDZRVuLa9DU1o2QAF8sSIsWDdk1GmD6dGDDBqCrtxQzN1fsxx5CXo25X0RERERE5FyzZ5tmJfT2M1mzZAqCVb7wUUhmd/NRSAhW+eLpm8UFLbZvN9wpSeK4RF7OlpLKmZUFAAAZgJ+vjz4QdKy2FYtf2IUFa7/GczllePPbY3gupwwL1n6NG9fvxrHaVhH4WbbM9Hc0J8d5J0RugcEgIiIiIiJyrshIMbFIJy8PKChAYlQQNq+YhanxYQBE8EfpI+mDQ1PjwwzTkQoKxH466ekciU0jwoK0aKvZc2FtTUg5ewyAqPYalTVLHwhauG4XCqpEiWaPVkZXj6w/lm4CmT4glJlpOGhREVBX57RzItdjmRgRERERETnfvHliYhEgrlg3bACWLUNiRgY+WD4TpTVNyC4+jca2LoQGKLEgLVqUhgEiELRhg+mI7Hnzhv8ciFwgJTrEaknlJSeKIckisScyWIXoRdcAsH0C2YPvF+CD5TOBuXOBffvEnbIM7NwJ3HCDs06LXIzBICIiIiIicr7UVNHIVjfyuqsLWL9eZCPMnYsUjQYp0SGG7XXNordvN21wC4jjsJ8JjSBrlkzBwnW7zAZ3Jp49DkkClD4KTL8sHUhKsnkCWY9WRt7xepTWNIkeQmPHGvpyFRczGOTFGAwiIiIiIqLhsWSJmCqWny++l2WRibBvnxh9rdEYRl+Xl/cffQ0A06aJ4xCNILqSygffL0De8Xr4KCQoJEArA0GdbYgMVmFGUgTUkycBkmTzBDJAlGdmF58WwdjkZEMwqKXFyWdFrsRgEBERERERDQ+FQjSq3bTJkCGkU1VlPvhjLCtLBIIUbH1KI09iVJDZksqfnBmNcB+t2EilAmDbBDIdhQQ0tnWZ7A8AaG937AmQW2EwiIiIiIiIho9CASxdKhrW5uSIRrWylewFSRLNoufNY2kYEUQPIZOSyi/UIuMOEFl1sG0CmY5WBkIDlCb7AwD8/R2wWnJXDAYREREREdHwS00VX3V1olFtcbEoS2lvFxehwcFAWpoYH8+pYUSWqY2CQWVlgCxjQVo01m47YtPuPVqxvb5Pl05wsBMWS+6CwSAiIiIiInKdyEjRpJaNaokGJy3NUGJZVQVUVCBFo7E6gUzHRyFhanyYmNxXVmboF6Q7LnktFtsSERERERERearZs0U5pU5vP641S6YgWOULH4VkdjcfhYRglS+evjlD/GD7dsOdkiSOS16LwSAiIiIiIiIiTxUZKfpq6eTlAQUF+glkU+PDAIjgj9JH0geHpsaHYfOKWUiMCgIKCsR+OunpLM/0ciwTIyIiIiIiIvJk8+YBhYXitiwDGzYAy5YhMSPD7ASyBWnRojQMEIGgDRtMG7nPmzf850DDisEgIiIiIiIiIk+WmgpkZelLxNDVBaxfD2RmAnPnIkWjMZ1ApmsWvX27yAgyDgRlZXFy3wjAYBARERERERGRp1uyREwVy88X38sysG+f+IqLAzQaQKUS4+PLyw1Np41NmyaOQ16PwSAiIiIiIiIiT6dQAMuWAZs2GTKEdKqqzAd/jGVliUCQgq2FRwIGg4iIiIiIiIi8gUIBLF0KZGQAOTlAUZFpCVhfkiSaRc+bx9KwEYbBICIiIiIiIiJvkpoqvurqgJ07geJioKUFaG8H/P2B4GAgLU2Mj+fUsBFJkmVrYULv09TUhNDQUDQ2NiIkJGTgHYiIiIiIiIiIPICtMQ9mBhERERERERGRXmlNE7YW16CprRshAb5YkBZtOo2MPB6DQURERERERESEY7WteGDTAeRXNsBHIUEhAVoZWLvtCKYlhOPfN2cgMSrI1cskB2CbcCIiIiIiIqIR7lhtKxau24WCqkYAQI9WRlePjB6t6Cxz4EQDFq7bhWO1ra5cJjkIg0FEREREREREI9wDmw6gpaNbH/zpq0cro6WjGw++XzDMKyNnYJkYERERERHRSFRbKyZNHTwINDcDHR2ASgWo1Zw05SEc1duntKYJ+ZUNA27Xo5WRd7wepTVNXtdDaKT1SWIwiIiIiIiIaCQpKQFycoCiIqDvcOn2dqCxEaiqArKzgfR0YN48Maac3Iaje/tsLa6Bj0KymBVkzEchIbv4tNcESkZqnySWiREREREREY0EWi3w7rvA2rVAYWH/QFBfsiy2W7tW7KfVDscqaQDO6O3T1NYNhWTbtgoJaGzrsnvd7mgk90liMIiIiIiIiMjbabXAhg1Abm7/++LigLlzgfnzxX/j4vpvk5sr9mdAyOWc0dsnJMAXNiQFARBZM6EBSpuP7c5Gcp8klokRERERERF5u02bgPx8w/eSBGRmAllZQFKS+F5HloGKChEAysszZBDl54vjLF06vGsnPWf19lmQFo21247YtIYerYwFadE2bevORnqfJAaDiIiIiIiIvFlJiWlGkFIJLFsGZGQAsNA4V6MBNBpg+nSREdTVWxaUmyv2Yw8hl3BWb5+U6BBcNC4MBVWNVo/to5AwNT4MF0Sr7Vq3OxrJfZIABoOIiIiIiIi8W06O4bYk6QNBNjXOzcgQ269fb8gQyslhMMhFdL19emzY1t7ePmuWTMHCdbsslk35KCQEq3zx9M0ZdqzYfTnzufQE7BlERERERETkrerqxNQwncxMfSDI5sa5GRliP52iInFcGnbO7O2TGBWEzStmYWp8GAAR/FH6SPDp7Sw9NT4Mm1fM8prJWiO1T5IOg0FERERERETeaudO06lhWVkABtE4d+5cw52yLI5Lw25BWrRNZU3A4Hr7JEYF4YPlM7F15eX49bwJuP3SRPx63gRkr5yND5bP9JpAEOD859LdsUyMiIiIiIjIWxUXG27HxQFJSYNrnKvRAGPHAidPGo57ww3OWTNZNFy9fVKiQ7yqP445I7FPkjFmBhEREREREXmr5mbD7eRkQJL0jXNtoWucC0kS++u0tDh4oWSrNUumIFjla/E19LbePs40kp9LBoOIiIiIiIi8VUeH4bZKBcDQONcWJo1ze/cHALS3O2iBZK+R1tvHmUbyc8kyMSIiIiIiIm+lUhkCN72BoUE3zjUOLPn7O3CRZC9db5/SmiZkF59GY1sXQgOUWJAW7XXlTM42Up9LBoOIiIiIiIi8lVoNNIqJYSgrA2TRCHfttiM27a5vnCvLYn+d4GAnLJbsNRJ6+wyXkfZcskyMiIiIiIjIW6WlGW5XVQEVFfrGuQP1DfJRSMhMCBfZEeXlhubRfY9LRB6HwSAiIiIiIiJvNXu2aP6sk5sLYBCNc7dvN9wpSeK4ROSxGAwiIiIiIiLyVpGRQHq64fu8PKCgwL7GuQUFYj+d9HRxXCLyWOwZRERERERE5M3mzQMKC8VtWQY2bACWLUNiRsbAjXMLCsT2smx6PCLyaAwGERERERERebPUVCArS18ihq4uYP16IDMTmDsXKRqNaeNcXbPo7dtFRpBxICgrSxyPiDwag0FERERERETebskSMVUsP198L8vAvn3iKy4O0GjEGPqODtEsuqqq/zGmTRPHISKPx2AQERERERGRt1MogGXLgE2bDBlCOlVV5oM/xrKyRCBIwbazRN6AwSAiIiIiIqKRQKEAli4FMjKAnBygqMi0BKwvSRLNoufNY2kYkZdhMIiIiIiIiGgkSU0VX3V1wM6dQHEx0NICtLcD/v5AcDCQlibGx3NqGJFXkmTZWijY+zQ1NSE0NBSNjY0ICQkZeAciIiIiIiIiIg9ga8yDBZ9ERERERERERCOIWwWDnnjiCUyfPh1qtRqjR4/GokWL8MMPP5hs097ejhUrViAyMhLBwcG48cYbcfr0aRetmIiIiIiIaHBKa5qwdtth/G3LIazddhilNU2uXhIRjRBuVSa2YMECLF26FNOnT0d3dzdWrVqF4uJiHDp0CEFBQQCA5cuX49NPP8Vrr72G0NBQ/OpXv4JCocCuXbtsegyWiRERERERkSsdq23FA5sOIL+yAT4KCQoJ0MpAj1bGtIRw/PvmDCRGBbl6mUTkgWyNebhVMKivs2fPYvTo0dixYwdmz56NxsZGjBo1Cm+//TZuuukmAEBpaSlSU1OxZ88eXHrppQMek8EgIiIiIiJylWO1rVi4bhdaOrrRo+1/KeajkBCs8sXmFbMYECIiu3lFz6DGxkYAQEREBADg+++/R1dXF6688kr9NikpKRg3bhz27Nlj9hgdHR1oamoy+SIiIiIiInKFBzYdsBgIAkR2UEtHNx58v2CYV0ZEI4nbBoO0Wi1WrlyJWbNmIS0tDQBQU1MDPz8/hIWFmWw7ZswY1NTUmD3OE088gdDQUP1XfHy8s5dORERERETUT2lNE/IrGywGgnR6tDLyjtezhxAROY3bBoNWrFiB4uJivPvuu0M6zsMPP4zGxkb914kTJxy0QiIiIiIiItttLa6Bj0KyaVsfhYTsYg7KISLn8HX1Asz51a9+hU8++QQ7d+5EXFyc/ufR0dHo7OxEQ0ODSXbQ6dOnER0dbfZYKpUKKpXK2UsmIiIiIiKyqqmtGwoJ6LFhW4UENLZ1OX1NRDQyuVVmkCzL+NWvfoUPP/wQOTk5GD9+vMn906ZNg1KpxFdffaX/2Q8//IDKykrMmDFjuJdLRERERERks5AAXwxQIaanlYHQAKVzF0REI5ZbZQatWLECb7/9NjZv3gy1Wq3vAxQaGoqAgACEhobiZz/7GR544AFEREQgJCQE999/P2bMmGHTJDEiIiIiIrNqa4GdO4GDB4HmZqCjA1CpALUaSEsDZs8GIiNdvUrycAvSorF22xGbtu3RyliQZr76gYhoqNxqtLwkma+f3bhxI+666y4AQHt7O373u9/hnXfeQUdHB+bPn48XXnjBYplYXxwtT0RERER6JSVATg5QVARY+2exJAHp6cC8eUBq6vCtj7zO4hd2oaCq0WoTaR+FhKnxYfhg+cxhXBkReQNbYx5uFQwaDgwGERERERG0WmDTJiA31/59s7KAJUsAhVt1XCAPcay2FQvX7bI4Xt5HISFY5YvNK2YhMSrIBSskIk9ma8yD/wcjIiIiopFFqwU2bDAfCIqLA+bOBebPF/81Gmail5sr9tdqnb1S8kKJUUHYvGIWpsaHARDBH6WPpJ8yNjU+jIEgInI6ZgYRERER0cjy7rumgSBJAjIzRcZPUpL4XkeWgYoKsX1enmkpWVYWsHTp8K2bvE5pTROyi0+jsa0LoQFKLEiLxgXRalcvi4g8mK0xD7dqIE1ERERE5FQlJaaBIKUSWLYMyMgAIC7OtxbXoKmtGyEBvliQFo0UjQbQaIDp00VGUFfvuO/cXLEfewjRIKVEhyAl2g3/QM2G6kRej8EgIiIiIho5cnIMtyVJHwg6VtuKBzYdQH5lA3wUEhSSGO29dtsRTEsIx79vzkBiRobYfv16Q4ZQTg6DQeQ9rDVUb28HGhuBqiogO5sN1Yk8HHsGEREREdHIUFcnLnJ1MjP1gaCF68SEJ0CM9O7qkfXNfQ+caMDCdbtwrLZVZAJlZhqOUVQkjkvkybRaUT65di1QWGh9sh4g7i8sFNu/+y77ZxF5IGYGEREREdHIsHNn/54/AB7YdMDiZCdABIdaOrrx4PsFYtT33LnAvn3iTlkWx73hBicvnsgO9pR56Rqq5+f3P05cHJCcLPbt6ADKykRmkLHcXJExtGwZJ+wReRAGg4iIiIhoZCguNtyOiwOSklBa04T8yoYBd+3Rysg7Xo/SmibRQ2jsWODkScNxGQwidzCYMq+CAtNA0GAaqufnA5s2saE6kQdhMIiIiIiIRobmZsPt5GRAkrC1uAY+CsliVpAxH4WE7OLTouFvcrIhGNTS4qQFE9lIqxXBGOPm6Nboyrx27ADOnTMEfdhQnWjEYDCIiIiIiEaGjg7DbZUKANDU1g2FBPTYsLtCAhrbukz2ByAyLohcZShlXqdOiZ5XnZ0iiMOG6iMTp8eNSAwGEREREdHIoFIZAje9gaGQAF/YkBQEQFwMhwYoTfYHAPj7O3CRRHbatGlwZV7ffCOyggDg7FkgJcWkoXpLRzcAUSJpHCzVNVTfvGKWCAhlZhp6aOkaqjNw4Bk4PW5EYzCIiIiIiEYGtVpc3AAiQ0KWsSAtGmu3HbFp9x6t2B6yLPbXCQ52wmKJbFBSYloaZk+ZV3OzCOLoggDNzUBJCR7IPceG6t5usGWFhYUiyLhkCZuFewEGg4iIiIhoZEhLM5TIVFUBFRVI0Whw0bgwFFQ1Wu0b5KOQMDU+DBdEq0UgSNcvSHdcIlfIyTHcliT7yrxaWkSWx6FDQFAQoFaj5qPPkN+YMuDDsqG6B+P0OOrFYBARERERjQyzZ4tyB10mRG4uoNFgzZIp+rIYcwEhH4WEYJUvnr5ZZFtg+3bDnZIkjutq7Pkx8tTVifIencxMu8q8dtaeQ2hkJDBqFODrC0gSzuzah8jksajzVw/48Gyo7qEGW1bI6XFeh8EgIiIiIhoZIiNF34vCQvF9Xh4wfToSMzKwecUsPPh+AfKO15tkUvRoZUyND8PTN2cgMSpIjOHOyzMcMz3dtUEW9vzwaGbLuKJDbNt5507T1zwrCwDwwKYDNpV5fVN8Ej+aGA7ExOh7B3V1a3FJVTE+S54x4MOzoboHGkpZIafHeR0Gg4iIiIjIe/XNmKmuFsEgPz8gPBx47jng/vuRmJGBD5bPRGlNE7KLT6OxrQuhAUosSIsWpWGACARt2GB6AT5vnmvOy9aeH+3t4pzr64E9e4AXXwQSE0UmwOTJzBhyEZvKuKKCrB+kuNhwOy4OSEpCaU0T8isbBnz8Hq2ME+d7UH++E+EhIUCPyB3y81VgwpnjgA3BIDZU90BDKSvk9Divw2AQEREREXkfSxkzgYFAVJQYqd3SIrJmSkuB+fOBW25BikZjmpmhaxa9fbtpmQQgMjFccSFkS8+Ps2eB/ftFP5i+ZTtlZUBDgyjrYcbQsLNrWpe1gFBzs+F2cjIgSdhaXAMfhWS1/5VOmyoQVfVtCA/0Ez+QZcSFByCgttn6jr3YUN3DDLGskNPjvA+DQURERETkPWzJmNFogM5OkTUky+Ji5u23gR07RKaMcQPV8vL+DVQBYNo0MVHHFaz1/EhMBN5/X2RC+fkBU6eKoMGpUyJApAtm1daKc0tO5pSgYWZrGZd+Wpclxtk4vWVaTW3dUEgwuZi35MjoBMxuOSy+aWwEfH0RHhKCuABpwIASG6p7oCGWFXJ6nPdhMIiIiIiIvIM9U3LGjhUXMadOGbY5eRLYtk0Ef4ybqPblyqCJtZ4fWi1qnn4WZ3d+i85uLfx8FYgLDxBlQJMmiW137BCBsKYmce6RkaJcDuCUoGFgTxmXflqXpR5CKpWhP09vYCgkwBc2JAUBAPbGpWF5WXnvA/aI90NICC5Pj0ewytezG6pTf0MsK+T0OO/DYBAREREReYfBTMl5+21RKnXunPjZ2bMio0ajMT22JLlHOZWVnh//fehpxOR/C0kCJABaScJbPaPRPOMyPPSLa5E4Khi45hrR80OrFRlDCoU4DqcEDQt7yrhMpnWZo1aL4B0gsnNkUba1dtsRm9ZS56/G6FmZwNEfxHHOnwdGjUJoRhw2L/fQhupk2RDLCjk9zvswGEREREREnm+wU3IeeQT48Y9FI+nKStFoubZWTFiKjRX9T9xlNLuVnh8r//oOfrL/W8gQcZ1OHx+8mzEfJaOT4NMu4evnd+HGaWOhkJSYERiPzLNlImNIkoBbbhGlZV48JWhIU7scyJ4yLpNpXeakpRlKGKuqgIoKpGg0uGhcGAqqGm0q8xoz91rgsX1Aa6u4o6QEmDkTiVFBntVQnQY2xLJCTo/zPgwGEREREZHnG+qUnPvvN52SM3kysGKFa87FEis9PzKO5OvvkiXoA0GAyOZo7ujGa7uPQ+kjYfv5Mbi36BtEqVWYkRQB9blzXjslyCFTu+wwUNDJnjIuk2ld5syeLbLadK9Zbi6g0WDNkin6hsADlnlFBQEhfRqmFxYCL78MzJ3rGQ3VyTZDLCvk9Djvw2AQEREREXm2kTIlx0LPj4ofKnHjmaP6uwqjJ+gDQX119cioCI1GjToSUksdsg+exhWx+Qi/4Qb3P387OWxql42PZUvQyZ4yLv20LksiI0VZVmGh+D4vD5g+HYkZGdi8wo4yL0kSE/Zqa4GICBE02LdPfMXFiZJJd26oTrYZYlkhp8d5H3aGIyIiIiLP5oApOQDElBwd3ZQcd2Kh58eMqoOQjE5xz7jJ1o8jSTgWHgNZBrp6tNjxfW8gyd3P3052v/6DpAs6FVQ16o/b1SPrH1cXdDpW24qU6BBcNC4MPgorDcohsncyE8INJVmWGJdlybIo2yoo0Jd5bV15OX49bwJuvzQRv543AdkrZ+OD5TMNgaANG8S+qamiLDI21vT4VVWi6fgXX4j/mgsEZWUB997LpuPuznjKm66scDDvx/JyTo/zEswMIiIiIiLPNlKm5Fjo+XFB7XH4dXdidOs5+Gi1uHX/Z1Bpu9Hho0SrXwAOj0rA3vg0NAQYyn06fUS5hywD9eeaPOP87eDQqV0DsHc0t11lXANJTRXBGF2/rK4uUe6XmWlfmZdRaSVyckRmmGylfshdGqq7KXfpUWXCEWWFAKfHeREGg4iIiIjIs42UKTlmen4knDkOTWUxxjTXAjJwJjgCIZ1tYvPuLoR0nEdMcx1mH81H6ahE7B6XgfKoePj1GBoTdyr9POP87eDQqV1WDDboZHMZly2WLBHlP7pJerI8+DIvhUIEd+rqRGZYcbF4H7S3i94w7tRQ3Q0Nd48quziqrJDT47wGg0FERERE5NlGypQc454fR44A77yDH2//Amda6oHemEePZL5UR5KB1DPHkHrmGPbEpyGx/pT+vja/ADR5wvnbwaFTu6wYbNDJpmldtlIoRFbPpk2mE/UAEfgxF/wxlpVlCATpREaKrDAPzQxzheHsUTVo8+YBhYWoP9+Jqvo2tK16Eod/vBSZC+dyetwIxGAQEREREXk2V03Jqa0V2RMHD4rspI4OsRa12jnZE7pR4rIMbNsGlJQgPCQEDSpf9LT3QJaBZv8gfDsuHR0+Sqh6upBQfwoxzXUmh7mqbC+iW+pQFhkPQMIPUQlI8bIpQQ6d2mXFUINOKdEhjikfUiiApUsHVeZVGj4WW3PK3KukyQPZWy7oCsdGjcN/u2IRU/QtJAmQACj+70Vs/GgbWi69DL//5bX4zZUTDDtwepxXYzCIiIiIiDzbcE/JKSmxfMHd3i7WUlUl+nM4sq+KrudHeTlw9qy4oA8JQeyoUBSd60R1UAQOR8bj49TZ4j4AkGWMa6jBjMpCTK45AkkGxrScQ/j5JoxTVON4RCz2xF2IlV42JcihU7usGK6gk81SU20u8zom+/eWNFW4X0mThxnOHlWDpctcah0zDUuizyKtplwkFMoyMqqPQProCD7d8SmW/GQuRkWFcHrcCMBgEBERERF5Nl3GDGCYkqPR4KJxYSioarRawuOjkDA1PkyUQpSVWZ+So9WaL8WxRJZFf47CQvOlOPaKjARGjRJTnQAREIqJgeqOn+KCA0U4V3EOMc11SGiswYnwGBGkkCRUhsegMjwGhTETsHzP+4hoawIggkL741KRnJJg2/l7EN2UJLte/0EYrqCT3QYo8/KIkiYPMlw9qoZCn7kkS3gnYz6u8/saMyqL9PfLMhBRfwb739qMqyeNsXwgR3yWkVvgK0hEREREnm22USYMoA/WrFkyBcEqX4tjk+2akqPVin4Z5gJBcXFiLPv8+eK/cXH9t8nNFftrtXadmk0uukistzdLaUalaBBreVi02E6SAD9fhddOCbL79R+EwY6KL61pwtpth/G3LYewdtthlNY0DXoNg2FPSRMNTFcuaIuh9KgaLF3mku71liUFtkyag1cyF6JkdCJkQyIhaps7UH++0/QAkgRMngysXCnKERkI8grMDCIiIiIizzYcU3I2bTJMawLExVFmpvgreVKSaTBKloGKChEAMu6zkZ8vjrN06eDOs65OZAPFxgKnToksodBQNG98Azvzj0Lb3Q0oA5FefQQF0RNQMjoJkGUkNFTj0soiZNQcwXn/IJwLDENEawPOR43BreMDoJbagYIyr5sSlBgV5NipXRbYM5rbHaZNeUJJk6dxu3LBPixlLpVHxaM8Kh5hbU245EQxJp49juDudhxr0SI8NozT47wcg0FERERE5Pl6p+QAEMGXDRuAZcuQmJEx9Ck5JSWmGUFKpZjelCEySkprmrC1uMa0Aa9GI0Z6T58ujt3VmwmQmyv2G0wPoZ07xRo1GqCzUwSFAOwpqwW6upBy5hja/PzR7BeIh7a/hu/i0+Cr7RENpCUgUOmD+IhABIclYGxbCAInXyiCWK+/LoJXXjglyKFTu6w8hi1BJwBuUZrlCSVNnsZtywV7DdTovCEgBNkTZyJ74kwofSTcfmkipl4/aVjXSMOPwSAiIiIi8nypqSJLRxe06eoC1q8X2Ttz5yJFozG9oLVnSk5OjuG2JOkDQTZleWRkiO3Xrzc8Rk7O4IJBxcWGNVx5JTBxIuo/+wK1LZ2AKhingyMwpuUcAjrFZLW4phycCwjF6eAItKgCcb6zB0mjghB+7Q1AaSnwww9AdbXIWLroIsvn7wUcNrXLAluCTotfsJw9BAzftKmhTkCj/oarR9VguXvmErkGg0FERERE5B2WLBGTvHTlXLIM7NsnvuLiREaNSmXflJy6OjE1TCczUx8IsjnLIyND7Ldvn7izqEgc196yi+Zmw+2JE4FbbsHH58NQcWYLJp45isrwGPhpuxF+vrf/jAxEnG9ExPlGnPfzx5FRCShUj8UcWQYOHTIEl1Qqy+dPdrEUdHKn0iwGBpzDnnLB4ebumUvkGuz8RERERETeQaEQWThZWf3vq6oSU7i++EL811wgKCsLuPde0+aoutIs420wiAa8c+ca7pRlcVx7dXQYbvcGcI6PTsDbmddh9ew7sCNpGr5JnIJj4bHQKnzQ5aNEm58/qkNG4UjkOHT7KBFccVicf2Oj0WJ7LJ8/OYSuNMsWutIsZ1mQFm1TiRjAwIA9dOWCU+PDAIjXUekj6V/3qfFhLpvONthG5+TdmBlERERERN5DoRANmjMyRDlWUZFpMKcvSRLNkufNM18apcueAUR2UVLS4LI8NBpg7FjD6PbiYotjvy1SqYB2UQKmCwzpsjyMe34AgKb2BGZWFiDl7DFIvacvQUwPE4vrMZx/dLSYEuRlpWHuxJ1Ks9y9pMmTDUePqsFy58wlcg0Gg4iIiIjI+6Smiq+6OpGFU1wMtLSIYIq/v+1TcoxLs5KTAUkafAPe5GRDMKilxf5zUqsNGT1lZYAsWyz/MDclKKirHXHR4UCoWgTI4uOBmBixLgaCnMrdSrMYGHAuZ/eoGozhmq5HnoPBICIiIiLyXpGRIgPH3iwcHTOlWYPO8jDuzaPL8LFHWpqhvK2qCqioQIpGYzXLQ5cxtC1FlK/8YvlMEUgyLhNLS7N/LWQXd+vZwsDAyOTOmUs0/BgMIiIiIiKyxEppli1MsjyMA0v+/vavZfZsIDvbUPaWmwtoNPZneWzfbrhTksRxna22VmRoHTwosq06OsRzq1bblqHl4dyxNIuBgZHLHTOXaPgxGEREREREI4s9gQk7SrPM0Wd56EbZ6wQH27/uyEjR36iwUASo3n8f2L8fiUFB+LqhBTlHG1HeLqE6dDQUEhDTeBYBHecRH+iDy9LGInT9XiAoSOyvy1JKT3duEKakxHLvpvZ28dxWVYkgl7XeTV7AXUuzGBggGpkYDCIiIiKiYVFa04StxTVoautGSIAvFqRFD+9F6GACE4MozdIxyfIoKzP0CwIGX5qVkAC88w5w7pw4h6oqIDUVIZGRWBTehfPHKtFW9C20WhmdoWFQJyUgJCYc6DwPFJwQz4EsAxERQGysOEdn0GqBTZtE9pItZFkEqQoLxVSzJUu8bqoZS7OIyJ0wGERERERETnWsthUPbDqA/MoGkwvgtduOYFpCOP7t7AvgoQQmMjNN73NVaZbxOahUhmCWVisynACgsxOBSiUCA3vL0nrOA4cPAbURgK+vyIjS7VdXJ45TUABccIFjAy9aLbBhA5Cf3/++uDjRsFqlEhlZZWWGYJtObq4IzC1b5pUBIZZmEZE7kGTZ2qxN79PU1ITQ0FA0NjYiJITpkERERETOdKy21aagyeYVs5wTEBpqYAIAmppEuZgkia/ly4GMDByrbbWY5ZGZEG7I8igoANavNwRiJk8GVqwAYGO2VN9zkGWR4VNbK8q+WlrEl+74sizWqSsF6+wUZWnBwUBrq/jZqFFASorY7qKLHBt4efdd08CbJImgWlYWkJQkvteRZaCiQmyfl2easZWVBSxdav2xRngvIiKivmyNeTAYREREREROs/iFXTaXU32wfKbjF+CIwER9vcikSU4W3yuVIniSIbJ+rGZ5FBSIQE5Xl+FxVq7EsVHjzGZL9Wjl/tlS5s7hoouAtjbg44+BU6dMz1nd+9jNzaY/j40FRo82BLaM2RJ4sUVJCbB2reF7M8+VxeCXhefKbA8hayV/xiTJ63sREREZszXmwTIxIiIiIkdipoJeaU0T8isbBtyuRysj73g9SmuaHNtDqKTENIhiS2BCowE0GmD6dENgIjxc9Oiprxe3u7pEpk9mJjB3LlI0GtN165pFb99uNtvl2Khx+mwp3fkbj6k/cKIBC9ftEtlSZystn0NJCRq/2o4Wnwb4NTZA8lHAL20SQsaKseRNJ2vQWXwIco8WCoWEgOZWBP72NuC66/oHXnJzxTGHGjDJyTHcliT9Wm0qFczIENsbZ1Hl5Jiuib2IiIgcgsEgIiIiIkfg1KR+thbXwEchWc0K0vFRSMguPu3YYJAjAxNJSaaZNrIM7NsnvuLiRABJV25WXm6+3GzaNGDJEjzw4h6LZXOACA61dHTjwfcL8IF2v8Vz+OKvGxBc2Q5JORp+4eEoGTUeAY1tSGhvhrKrE9UdSgRFXoDE+lM4ExSOjk4/tL6Vi6suzbIt8GKvujrx/tfJzNSv1ebgV0aG2G/fPnFnUZE4bmQkexERETkQg0FEREREQ8FMBYua2rqhkGBy4W+JQgIa27oG3tBWjg5MSBIQEiK+z8szfayqKvPBH2O9r3XpmRabs6XKSo+jvv57hAco+53DHas/xy+OlAIQb6nvxk7CexnzzR7rJwXZyKg+AgAIOlyCO1Z/jjd+f431wMtg7NzZv+cPgAc2HbA9+LV8JjB3rmFNsiyOe8MN4vfMOBA0mJK//HxxHEeUxBEReTDv/JcHERER0XDQZSqYCwTFxYmL2vnzxX/j4vpvk5sr9tdqnb1SlwgJ8IUNSUEARGZOqC7o4QgOCEwAEK+dsago0cdm8uT+fXf6kiSx3cqVIvigUOizpWwxo+ogqs6dNzmH0pom3LLhW6Qe2Q/jJ3fPuMkWj/PtuHTDN1oZF5YdMH9+usDLYBUXG27HxQFJSfpSwYGyw4xLBaHRAGPHmh7XXMnf8uXAvfcCGg1KTzdj7bbD+NuWQ1i77TBKTzeL49x7r9hOafTeys0VxyMiGsGYGUREREQ0WMxUsGpBWjTWbjti07Y9WhkL0qId9+BWAhO2rEXfw0gXmDh50nDcG24Q5VR1dSJ4Ulwspnm1twP+/mJql4X+UPZkS11QexydASJQWB8xGj/bWo38EyIb6Kazx/XbVasjURlm+bk7HhaDGnUkopvrAADJZ47h84HObzCMy+iSkwFJGnypYHKyYU0tLc7vRURENMIwGEREREQ0GI5qTgw4rnmvm0mJDsFF48Jsniamn8DlCM4MTOhERorAiR3BE3uypQI72uCn9kVzexf+daQbBVKT/r6gzjb97ePhsdazlCQJx8Jj9MGgoK52287PXh0dhtu9Y+0HXSrYuz8AoKFB9PrRcXQvIm/B5vVEZAcGg4iIiIgGg5kKNlmzZIr+gt1cEMZHISFY5Yunb85w7AM7KzDR3j6kZdmTLaXs7kR8eAj2lNehaUyMyfOn6jH0V+rwGbi8rtNoG1V3p3POT6Uy7N/7/A+6VND49TtzBhg92vC9o3sRDYLZYK8jm5/bg83riWgQ2DOIiIiIyF4DNCcuqBJZDD1aGV09sv5iVZepcKy2VWQCZWYajqHLVPAyiVFB2LxiFqbGhwEQwR+lj6TvmzM1PkxkbkQFOfaBjQMcjgxM+PsPaVm6bKmB+gb5KCSEh6shQ0ZtSyeUXabNtY0DQMaBIUv8jINHvn7OOT+1UWZXWRkgi9I/WzKxAKNSQVkW++s0GTKiHN6LyE7Halux+IVdWLD2azyXU4Y3vz2G53LKsGDt17hx/W7xuz1ctFrg3XeBtWtFQ/q+gaC+dM3r164V+3lprzIisg0zg4iIiIjs5eypSUPlZuUiiVFB+GD5TJTWNCG7+DQa27oQGqDEgrRox5aGGVOrDaVFRoEJu3sY9Q1MBAcPeWm2ZkvNyUxCVdERSBKQUH9KrKW3HKzVLwAhHaK5dN/7+pFlJNZX679tVfo75/zS0gxT1aqqUJVXjFX7mqzv08ukVLCszFC2BpgGmZxV8mcDu8rSHB3c7EvXvN64Z5lOXJw4T5VK/O6XlfWfdpebK34/li3z2mmGRGQdg0FERERE9nJ2c+LBcvNykZTokOErpekTmEBFBVI0Gvt7GPUNTKSlDXlpumypB98vQN7xepNywh6tjKnxYXj65gyEf92Kiv0/QAIQ01yHcQ01qAyPAQAcHpWAmN4eQH3v6yuhoVrfLwgAykYnIjMh3PHnN3u2eG/JMprbu/Dy46+iIO2qAXfrVyq4fbvhTkkyLRFzYcmf3cFeZ2LzeiIaIgaDiIiIiOw1HM2J7aHVios6cyPuzdGVixQWiovHJUu8LzvAKDABQDw3Go39PYz6BiZmz3bI8mzKlpo9G8pX3oNulTMqC/UBn73xaZh9NB+S3P++vi6tNCppVEg4mDwFbzjj/CIjRZCxsBB7yusw8XwNJkYloWR0ktXddMGvxKggoKBABCx00tOB48cNWV4uKvkbVLDXWYFPNq8nIgfwsv/rExEREQ0DK82JbeHQ5r26chFzgaC4OFGKNn+++G9cXP9tcnPF/t7WP0QXmNDJywMKCuzrYWQuMOHg8rqU6BD85soJ+Mv1k/CbKyfggmg1SmuasHbbYfxt92kcj9Xo41mTa44g9UwFAKAhIASloxL1xzG+Ly02BGmxIhBx4dmjmHK6TJ8ocn5iKt74/TXOO79581B/vhO1LZ2AVsbSgmz9uiz5+w1phvVs2GCa1TZvnvN6EdlREqcL9tpCF+x1GivN6wfsZ6RrXm+cOWR8PCIaMZgZRERERGQvZ01NGkzzXpaLWDZvnsh+AsS5btgALFuGxIyMgbNyLAUmnMjcJLpvEI+7IF5fSQaWFmTj3Yz5KBmdhN3jMpB65pj+vp+VfIXM26Yh8QpRonT0q11oevZbyGFKhDfWYXT3eQQExQKPrxKZNiUlQGgoEBMj3nuOOL/UVOwZNxlScQ1kGVD29OCn+z9DYfQEfDsuHcfDYkzekz4S8G32d0jpOmb6ngTEezg11S1K/gZdluZoAzSvt6mfka55va5fma55PcfOE40oDAYRERER2ctdmhOzXMS61FQRUNA9R11dwPr14kJ47lykaDSmpTy612P7dsuBCRvZO3rc0sX84Yh47BmXjhm9pV59gyt7xqVj5okiKH0UmD8xAupNrwN7twMAxh84ANSdAs6dE+cSGwu0topzPHtW/KypSQRYLr3U5nMbSN7FV6ErvwKp1eK9LclARvURZFQfQbU6EsfDY9Dpo4RfTxeSGmuQvr8DSAg3Pci0aaJ8EXCLkr9BB3sdzd2b1xORx2AwiIiIiDyPq6dluUGmAgCr5SJ9M0y0MrB22xFMSwjHv2/OENkBy5aJ4Iju4jInx7uCQYAIKDQ2GrKnZFlcBO/bJ8rmNBrD1KXy8v5TlwDTwMQAbHruzUyasnYx/0nq5VB3nkdaTTkA0edhas0RTKk5glNBERgd4IOZfucRUHVcBHd27BC/F52dgJ+feG8EB4vn4dSp/ouOigJ8fcXIcQf0kAoJ8sPzU+bjGmWAPoilE9Ncp298DYil+alDTQ/Qdw1GvYgAiEDd9OlIzMiwqRG3I0riBhXsdQZ3bV5PRB6HwSAiIiLyHO4yLcsNMhVGarmIvRk3UChE0Mtcg+2qKvPBH2N2BEcGO3p8oIt5WVLgnYz5uM7va8yoLELy6GAoJAl+vgpcE65CWECsCGSd6h0x39BgKD/s7gYCA8X7S5JEdpCPD9DTIwJHoaGm5YQOGDmuC5xsmTQHh0YnYWZlAVLOHtM3uzY5NxmID+9dn7XfWReX/KVEh9gf7HUGd2teT0Qei8EgIiIicn/uNi3LDTIVRlq5yGAzbgCI137pUlEGZymYaGygwIQFgx09bsvFvCwpsGXSHPwQnYSHVdXI6jpteg7JyeL9U1BgCASpVEBQkMggiY0VmXO6oFB6unjPqFQO7yFlHDgpj4pHeVQ8wtqacMmJYkw8exxBXe1QdXeiU+mH0KhwhC2+duBsPheW/OnYHex1BivN6+3uZzTU5vVE5NEYDCIiIiL3ppuWZdwkWScuTlwE68p8ysr6Z3o4INPBLFc3Jx5B5SKDzbjpJzVVfNXViaBXcbHIiGhvFw2Ug4MHXWY4lNHj9lzMHx01Dl9fOhtZM8f0P4eQEPEVGys2Pn8emDRJ/MzfH2dlJb4NjEHphKlQjonCgojerCon9JDqGzhpCAhB9sSZyJ4ogmC6wMnmFbMAa6+ZsWEu+etLN4nOpmCvs7hT83oi8mgMBhEREZF7c9dpWa7OVBhB5SKDzbixKDJSBLwcGPQa9HOPQV7MmzuHdetECRggfi+WL+/fQ6pTguJQA7QHG5zaQ8opgZNhLPmzJDEqaOBgrzO5S/N6IvJ4bhUM2rlzJ1avXo3vv/8e1dXV+PDDD7Fo0SL9/XfddRdef/11k33mz5+PrVu3DvNKiYiIaFi4+7QsV2YqjJBykaFk3AynoYwed0hzYjfsIeWUwMkwlfwNJCU6xCXvM7dpXk9EHs+tgkGtra3IyMjAPffcg8WLF5vdZsGCBdi4caP+e5XxP16IiIjIu7j7tCxXZiqMkHKRoWTcDKehjB53SHNiN+4h5ZTAiRNL/tyaOzSvJyKv4FbBoGuuuQbXXHON1W1UKhWio20f1djR0YEOo3/gNDU1DXp9RERENIzcMNPBLFdlKoyQcpGhZNwMp6Fm9wy5OfEI6iFlwgklf27NHZrXm1NbK4JyBw+KEtaODhGwVqu9MyhH5AXcKhhki+3bt2P06NEIDw/HvHnz8Pe//x2RVj5YnnjiCTz22GPDuEIiIiJyCDfOdDBruDMVRki5yFAybobTULN7htxjZwT1kBrxXN283lhJieUgeHu7CFhXVYlsJieU6xHR4HlUMGjBggVYvHgxxo8fj/LycqxatQrXXHMN9uzZAx9ds7w+Hn74YTzwwAP675uamhAfHz9cSyYiIqLB8tRMh+HKVBgh5SIO6aczTIaa3TOkHjsjpIcUwfXN6wEx5dFceawlsiwCWIWFDmnkTURD51HBoKVGE0DS09MxefJkaDQabN++HVdccYXZfVQqFfsKEREReSJmOljnruUiDuaQfjrDxFETtAbVY2eE9JCiXq5sXq/Viuwi4ymPOnFx4vNW99hlZf0fOzdXrH3ZMgaEiFzIo4JBfSUlJSEqKgplZWUWg0FERETkoZjpMDB3KhdxoiH30zHD7CQ6BzQ5dtno8RHSQ4p6ubJ5/aZNpoEgSRJZSVlZQFKS+F5HloGKCrFG46yk/HxxHKM/9hPR8PLoYFBVVRXq6uoQExPj6qUQERGRozHTYWDuUC4yDByVcQPAtkl0NhxnIMM+enyE9JAiI65oXl9SYhp8Uir1Ux4BC0FWjUZkKk2fLgLQXb1B+txcsZ+bfu4QeTu3Cga1tLSgzOgvEUePHsWBAwcQERGBiIgIPPbYY7jxxhsRHR2N8vJyPPTQQ0hOTsb8+fNduGoiIiJyCmY62MaV5SLDyBEZN3ZNonNAQGhYjZAeUmTGcDavz8kx3JYkfSDIpiBrRobYfv16w/s0J4fBICIXcatgUF5eHrJ6J4UA0Dd+vvPOO7F+/XoUFhbi9ddfR0NDA2JjY3H11Vfj8ccfZ08gIiIib8RMB9u4slzEBYaScWP3JDpPMkJ6SJEVzm5eX1cnso90MjP1gSCbg6wZGWI/3YTHoiJxXL7PiIadWwWD5s6dC9lKamN2dvYwroaIiIhcyhWZDrW14i/rBw+KBtYdHSKrRq127Fh4R3NFuYiHGdQkuuEs83KEEdJDilxk506grQ2orgbq68V7pagI+w/V4q4OBUqjxmFvfBoaAkx/b/oFWefONQSDZFkc19nTF4moH7cKBhERERHpDWemQ0mJ5SBKe7sow6qqEsEpdw6iDGe5iIcZ9CQ6TzJCekiRC5SUAK+8IppBy7K+3Lb+XBPazp7DGABjmmox+2g+SkclYve4DJRHxet3NwmyajTA2LGGjM3iYgaDiFyAwSAiIiJyX87OdNBqzZdXWSLLYj2Fhe5dXuXschEPNOhJdJ5mhPSQomFi/Bl54oTh8zQkBJAkVNW3QZIMP5ZkIPXMMaSeOYY949LxSerlkCXxGWkSZE1ONgSDWlpccGJExGAQEREROYVDRnc7M9NBqxXBIuMRyTpxceJiRXfRXFbW/6I5N1dcdC9b5p4BITIx6El0nmaE9ZAiJ+r7GanVGu4bPRqYOxclhWfwne9JxNWdQkxzncnuMyqLoO48j3cy5kOWFKZBVuOer7qpkUQ0rBgMIiIiIody+OhuZ2U6bNpkGgiSJBFkysoCkpLE9zqyLMojcnNNg0z5+eI4S5fafj7kEoOaROep2EOKHKHvZ6SPDxARAcTGAtdfD9xyC06NOoyPpTL09GgxrqEGMyoLMbnmCKTet1taTTmu8/saWybNMQ2ydnQYjuvvP3znRER6DAYRERGRwzhldLczMh1KSkyPpVTqRyQDFrKaNBoReJo+Xfy1vKv3L9y5uWI/XkS7tZToEPsn0Xk69pCiwTL3GTlrFtAtPtvPHjiE/4z6AcfPnRe/T5KEyvAYVIbHoDBmApYWZEPZIz79Z1QW4dDoJJRHxYsgqy6DU6e3/xARDS8Gg4iIiMhhnDa629GZDjk5ptv2BoJsymrKyBDbr19vWENODoNBHsDuSXTegj2kyF7mPiMrKtD80RbsKa9DbUslNjePR1VETL9dS0Yn4d2M+fjp/s/0GUKXnShE+LTJIshaVmboFwSIgCQRDTsGg4iIiMghhmV0tyMyHerqRDBJJzNTHwiyOaspI0PspxuPXFQkjsvsisGprRWv58GDQHOzKCFRqQC12qGZK4lRQbZPoiMaqSx8RlYGhGPvP15Gd4/oHXTxsQIcDTVfTlkyOgmF0ROQUX0EkgSk1R3Hz66IE3du327YUJLE7zcRDTsGg4iIiMghhnV091AyHXbu7N9YGoPIapo71xAMkmVxXGZe2KekxHKmV3u76BVVVQVkZzusp01iVNDAk+iIRjILn5Ert51AemQCLjh9FAAwueYICmMmoGR0Ur9DKH0k7EuYjIzqI4gMVmFGUgTUB78H2upF3zWd9HQG0YlchMEgIiIicgiPGd1dXGy4HRcHJCUNLqtJowHGjjWUOxQXMxhkK+Nx1baQZaCwUHw5aNpVSnTI4IORRN7MymdkY/xkfTBIkoGlBdl4N2N+v4DQj9JjMT4yGVeHHEVUY6344bZtMJlDD4gALxG5BGdGEhERkUN4zOju5mbD7eRkQJLw7neVNu+uy2qCJIn9dVpaHLhIL6YbV20uEBQXJzKu5s8X/42L679Nbq7Y33jMNRE5jpnPSF3mZ3lUPPaMS9ffrezpwU/3f4afFGQjof4UIMvwUUgYHxWE31w1EVEZk0SGX2kpsGuXofE+IAK77LVG5DLMDCIiIiKH8JjR3cYjjVUqAMBnRTU2726S1dS7PwBR1uRkZqec2ZHdMtT9HaLvuGpJEj1JsrKApCTxvY4sAxUVIgCUl2fIKMjPF8dZunR41+5F3OK9QO7JzGekcebnJ6mXQ915Hmk15QBEhlBG9RFkVB9BtToSJyNjESMfBs6MBrZsAQoKxLF8jS49p00TGX5E5DIMBhEREZFDeMzobpXKELjp6EBpTRPONHdY38dIj1Y2ZDUZXzT5+ztwkaZsmnJmpemxLfu3d/c4Pzhgblx17yQ3wEKAQqMBNBpg+nSREaTLLMjNFfsxs8AuQ30v0QjQ5zMSMM38lCUF3smYj+v8vsaMyiKTXWOa6xDbUofU7krgXChw9qzhTh8f8V8HlXoS0dAwGEREROQl3OEv/R4xulutFmULAFBWhq1R1foLYltoZZEFBVkWI5J1goMdv1bAvilnZi7iB9p/f2U9rlizAz1aeUjBAZvef+bGVfdOcrMUoJgUo8bF4yOgkJRISr8aP9r1EcJ1wbicHAaD7DDU9xKNEH0+IyHL/TI/ZUmBLZPm4NDoJMysLEDK2WP6MfKyDMSHB4obuuNIkij7XLmSv7NEboLBICIiIg/nTn/p94jR3WlpYkIVAFRVwefoUfgoJGh7bIsGjVarRFZTWZmhebTuuE5g95QzO/fXytCXXw0mOGDz+8/CuOqBAhSHqptxqLoZvgpAhi+KzgbjipZKMZ2oqEgcl9OIbDLU9xKNEH0+I1FRgRSNxmzmZ3lUPMqj4hHW1oRLThQjpbYS4/1lhEWogbY2EQSKjwdiYoBFixgIInIjDAYRERF5MHf8S7/bj+6ePVuMKu8NgKSUfg+t/1Sbd/9Reoy4sX274YeSJI47RH2zay6IVts/5cwoG8fWKWnWjmstOGDX++9r8+OqBwpQ6HRrAUDGt+PSMeW7I8g+eBrzLxwD9c6dnOJmg0FNzGMPoZGpz2ckcnMBjcZq5mdDQAi2pczCt6o52LxiFhAVBLz8sqEHmIM+I4nIcRgMIiIi8mDu/Jd+tx3dHRkJpKeLMeUAMmvLMdE3pN9oZEuWXjxONETNyzP8MD19SNkplrJrBgqQGNNNOUuJDgFqa4GdO3Hu4x1YVXoSyu5OdPgo0eoXgMOjErA3Pg0NAba9NtaCA3a9/2otj6u2x/GwGFQHRyKmpQ57Ks7h6uJiBoNsoJsGZct7yuS9RCNPn89I5OUB06cjMSPD9sxPB39GEpHjMRhERETkofiX/iGYN09/oRMeoMT9pduxTpJwcNR4i7voG1+frhCNjI2zXObNG/RSBsqusZVCApSHS4EfvhDlWLIMVU09QjpaoZUBVXcXQjrOI6a5DrOP5qN0VCJ2j8tAeVT8gMc2Fxyw9/1X11wL/aVgn3HV9gS9IEk4Fh6D6OY61DZ3oO50HXiJOTDjaVADMZmYRyOT0WckZFl85i1bhsSMjIEzPwsKHPoZSUTOwWAQERGRh+Jf+ocgNVWUKfVOtro8MRStBZ8jf3Qydsen4XhYjMmIcx8JSG05jRfbjwLri/qXOw2hD4atZVLWSLIW1x78BpcXHAfGhup/7uergLmjSjKQeuYYUs8cw55x6fgk9XLIkuXJPuaCA/a+/ypPNSBydO/ENTPjqu3R6SMaSEsSUHmynsEgGxhPgxqIVoZhYh6NTH0+I9HVBaxfL3p9zZ2LFI3G9P8nuob627eLjCAHfkYSkXMwGEREROSh+Jf+IVqyREy6yc+H2l+JBReOQWjFcaTvPYzTIVE4ERGDdoUSvt2dmCk34EcRPVCX9rlAnjZNHKcPWye7DbWnDyACQbcUZCOtphzxun5GvaInJWODQpSIqXq6kFB/CjHNdSbbzKgsgrrzPN7JmG8xIGQuOGDv+69N8jH8wMy4anv49Yj3sgTgvIL/nLVF32lQ1vRoxfQoGuGMPiMBiADPvn3iKy4O0GhEYLejAygvNzSdNmbhM5KIXI//9yQiIvJQ/Ev/ECkUYrT5pk1Abi7U/kpMTwxH2ZkWRLY2YVJtEyKC/DBhtBphgUoAfQIlWVniIkdh+Lm9k90GVSbVx3UlXyP9dDki1SqxTkkSf73PysKopCRUrd9tmAAkyxjXUIMZlYWYXHNEPwo6raYc1/l9jS2T5ph9DHPBAXvff1JICIA28QML46ptIstIrK8WNwEo1G7QlNzd1dYiZfdOPHHwczSfrbfaQ0pfDukOzd7Jtfp8RpqoqjIf/DFm5jOSiNwHg0FEREQein/pdwCFAli6FCfHTcCn/+8/CDpcCQVExokMoK6lE/Xnu8QYc//eQEt6uuh/0afsYTCT3QZbJqWjqT2BmSeKoPRRYEZSBKBUiou3jAwAIvNoclwoik81QSvLkCGhMjwGleExKIyZgKUF2VD2iEefUVmEQ6OT+vUQshQcsPf9N272xcDeHeIHA4yrtiahoRrRvdlNsgxxXDKvpATIydH3kLouogfZ1W3o6tGa7SG1NzEDp8cm4embM1y9cnIXvZ+RyMgweS9ZZOUzkojcC4NBREREHiolOsSmC2n+pd+6Y7WtWPhlHVo0V0IdPR2XnCjGxLPHEdTVDlV3J452++LIiR7cfOdVGH3d1RYn4gxmsttgyqSMM45mVhYgMlglglUBfvpAUN8MJQmyyfWbr0LC4WgN3sV83L7/M/HD3uMZB4N8FBKCVb5mgwP2vv/GLrwU+G6nXeOqzbm0sgiAuOaMDFZh7ML5NjxrI4xWazabQ+2vxPwLx2BPxTnUNndAkgyBz9Qzx3B5WzWmTl+EUREBLlk2ubHUVPFVVwfs3AkUFwMtLUB7O+DvDwQHA2lpYnw8p4YReQS7gkE7d+4c1IPMnj17UPsRERGRdQNdSFu7mCfBOIjTEBCC7IkzkT1xpsk2PgoJuefD8IGFi5zBTnazt0zqxZ9ehB9qWtDY1oUxXS34SVUnwgLGiDszM/WBoL4ZSsYkCVBIEm67ZByWXnw5It9RIP9/X6K2uQOptccxqqMZ5wJC+o+KNsOu919kkM3jqiUA3WaOl3qmQpS3SYDSR4Fp1/HCsx+tVkxy0vV5MRYXB3VyMq5WqXDydAMq9xbCr+YU/HwViA8PFGWGeXsAbYcILLK8h/qKjARuuEF8EZFHsysYNHfuXEhGkzUGIssyJElCT89gk5+JiIjImsSooH4X0rqsEVsu5oektlb8hfjgQaC5WTQRVakAtdpj/kI82CBOX4Od7GZvds2CtBgsSOv94YcfAgFG/5TLygIwcIaSLAM9soyik414NFoNXD8fV5cWov58J6rq2/BgwBnUzJtmOiraArvff3aMq5ZlGd8dPYeD1U3wUUiYdKYCNxd8AUkGItW92VA/vmbA53vE2bTJNBBk1EMKSUn6KXljAYz9hQxUVIgMIuMJUPn54jhLlw7/+omIaFjYFQzauHGjs9ZBREREg5QYFdTvQjo0QGnTxfyg9OlDYqK9XUyfqaoCsrNd3ztigIDVdjl2UEGcvoYy2c2W7JpApQ/Sxobgb1sOGaaTFRcbNoqLA5KSBhfc0miAsWMRfvIkwgP9kB7QCFw5wYYzEex6/w1iXHX5twdw9P3PEHayEKqYIEMGC8dV91dSYloaZqaHVL8pdxqNmAo1fboIznX1vjdzc8V+fI6JiLySXcGgO++801nrICIioiHSZZo4jYU+JBbJssgCKSwc/qkyNgasMisbcLs2El/HT+7XOLmvvkEcY0OZ7DZQdo2/rwLNHd1489tKk+lka78vxRWxKtHYOjkZkKRBZyghORk4eVLc0dJi24n0YfP7z85x1ZqqKmgAYFyY4RgcV21eTo7htiRZ7CFldspdRobYfv16w+9MTg6DQUREXooNpImIiGhgA/QhQXKy4QK+rKz/yOHcXBEAcHYfEjsDVoE9HbjiyB7cUPglzgSFoyp0DDp8/cyO3O4bxDE21Mlu5rJrZFnGl18fRPrBAiSfOY6gzjaoerr0I8FDqo8g92wosjLioVapAAwhQ6l3fwAiWOZMHFftHHV1IvipY6WHlMUpdxkZYr99+8SdRUXiuG5e7klERPYbcjCoubkZzzzzDL744gucPn0ab7zxBmbMmIHa2lq88MILWLJkCVJSUhyxViIiInIVG/uQABBZBa7oQ2JPwGrPHiA/H5ozZ6FsOg8ASOysRmhHK8oi4vuN3N49LgPlUfH9gjg6jprsps+uKSnBS399Gb88Uoq+KUe6keDRTWehbKhBVfNppKZPAjCEDKWODsMd/v62HWAoOK7a8XbuNH0Obewh1W/K3dy5hmCQLIvjslkwEZHXGVIw6OzZs7jssstQUVGB5ORkVFRUoK2tDQAQFRWF119/HQ0NDVizZo1DFktEREQu4Cl9SGwJWOkyh9rbgfh4qHx84N90HB3dPZBlIPx8ExIUNTgeHiMOIYuR25POHkPNRTNwwWjLDYsdMtmtd331n2Yj+Icaq6fb5eMLZU83fBvq0fbm2wgYOxYL5lxjf4aSLItsLp3gYMs7ObppOMdVO46De0jpywaLixkMIiLyQkMKBv35z39GTU0N9u7di3HjxmH06NEm9y9cuBBfffXVkBZIRERELuYJfUhsCVgVnkLy5neRcLwUceEBCA8JAUJCEBESjvL9pWjxVaFbUsBHq0WHjy9UPd36U1b6KHBv9zH99CtzJUpDnuxmlNlUVd8GSTI8ZdXqSBwPj0WHjxKqni4k1J9CXGMNAjvbIUnA+YZGBHz8MVKamjAtbhIOnGq2PUOprMxw4Q+I4Iu559eZTcM5rnrompsNt92ghxQREbm3IQWDPvnkE/zyl7/ERRddhLq6un73JyUl4bXXXhvKQxAREZEreUofEhsCVgtLdyL6eCGKARRVNSJSrcK0xVch6qEFiKw8g5q/PIna5g5IEnA8Kg47kjJx8bECXNFSKcaY+ysHLHUb0mQ3o8ymzm4tIEkoiE7GnnGTURkW3a8UL62mDH/OfRlR55ug1QI4dQrIz8eLmSpcqYq1PUNp+3bT5272bMP3ntQ0fKQzLvXzpB5SRETkEkMKBtXW1iI5Odni/QqFAu38HwgREZHrDLWsxxP6kNgQsNLUnsAlxwqh7d2ky8cHz068ElVNE7A5NBrtqaMgTZ+OxMJ8nO/swbies4i5Kh1zZy7BBacr7C51s3uyW5/MJh+VH96aei0OjhpvfntJQnHMBHyacjlmVhbi4vYzwNmzwKhRGJW3B5/deR9+U9AxcIZSQYHo66STnm54P3hK0/DBcnTJm6upVIbATW9gyGN6SBER0bAbUjAoOjoa5eXlFu/fv38/xo0bN5SHICIiosFwVFmPJ/QhsSFgNbOyQH+3LAHvZsxHyajxULR34UfPfo3Wzh4knR+D++rOQwYgyx1oyP4KqtkXisCPs0vd+mQ2hf56OQ5+2TDgbrvHZSD1zDEok0cBFYfF656airH7v8UHK1ZYz1AqKBDBHuPnbt48w21PaBo+GM4ueXMVtVqsHRDBOVke3JQ7e3pIERGRxxpSMOjaa6/FK6+8gvvvvx9+fn4m9+3duxdvvPEGVq5cOZSHICIiIns4uqzHE/qQDBCwCmtrQsrZY/pNCqMnoGR0EgCRDdHaKYpoKkKjcSo4EtHNovTdr+TQ8JS6mclsGn/FLFx48GscPNVkddfyqHhUTbkEIapqoLkeOHMGOHRIZAldfDFSMjNNM5R0F/rbt5sGbQDx+uuCHp7SNNwe3l7ylpZmyM6qqgIqKpCi0dg/5c6WHlJEROTxhhQMevTRR/Hxxx9j6tSp+PGPfwxJkvD6669jw4YN+N///ofY2Fj84Q9/cNRaiYiIyBpnlPV4Qh+SAQJWl5wohmR0Hbxn3GTzx5EkHAuP0QeDAjrbhqfUzUJmk2xt1LqRr6dk4aGAUvHanTkjjnXmDPCnPwGXXy4CNLrXvby8/+sOANOmiWCHjic0DbeHt5e8AaKsLTvb8Jzn5gIajf1T7qz1kCIiIq8x5DKxb7/9Fr/61a/w6quvQpZlvPnmm5AkCddeey3Wr1+PiIgIR62ViIiIrHFGWY8n9CGxELCSIBY58exx/d3V6kjRjNmCTh+l4VDdncNT6mYhs+lQdbPlfYwU1bSg9Nc/QUpIiAhktLaKO+rrRVDDXPDHWN+sF09pGm4Pby15MxYZKcraCgvF93l5wPTpSMzIsH3KnbUeUkRE5FWGFAwCgPj4eGzevBlNTU344YcfIMsykpOTGQQiIiIaTs4q6/GEPiR9AlbHalvxeXE1unu7RQd1tuk3PR4ea3rh34dfT5f+doevKIF3eqmbmcymd7+rtHl3H4WE7ENnkXLLLSLws3kzcO4c0NWF+vOdqKpvQ2e3Fn6+CsSFByA80E88B5b64XhC03B7eGPJW1+6Ztg//AB8+63IhFIogP37gZ/8BIl33jnwlLuBekgREZFXGXIwSCckJATTp0931OGIiIjIHs4q6/GEPiRGAav6wkNY+EMEmnuzVwBA1RvgUXV3YtLpciTUn0JQZxtUPV3o8FGi1S8Ah0clYG/chUisr9bv16oU2UtOL3Xrk9l0rLYVb393wubdTdaXlARceCGaG1vwQ/FR7DjWheDubvh3d6HdV4mWxi50T5qIWx64DeMmWhjy4QlNw+3hbSVvxsw1w46KAk6dErc7O4GXXxYBwqwspCxZgpQrJxn2t7WHFBEReR2HBIO+++47fPjhh6ioqAAAJCUlYdGiRbjkkksccXgiIiKyxpllPZ7Qh8QoYLXv60JEpCeiMdRQChbQ2QbNuZMIa2/BmaBwkR3US9XdhZCO84hprsO1pd8gtuksTgdHosk/GIdHJQAYhlK3PplND2w6gK4erc27911fc3sXsssaUKeOxXOzbum3vY9CwtvvlGLzikhRGtSXJzQNt5U3lrwB1pthazQiCFRbK77X9ZB67z3g00+BSy8Vv39dXbb3kCIiIq8zpA54PT09+NnPfoYZM2bgySefxPvvv4/3338fTz75JGbOnIm7774bPT22tJckIiKiQXNAWQ8AUdajoyvr0fUh0cnLAwoKkBgVhM0rZmFqfBgAEQBQ+kjwUYgSrKnxYeJCejj6kMyeDUgS6s93oralExcfE+cjyVpcf2gHUs8eQ1hbMyDLCO48D8D88xHdXIewtmZccPYYxjVU47s4kUHh9FI3tVp/8+z+g8g/Xt9v4rk1fde3p7wOXT1atPiaD1b1e937stI03BbD0jTcVs783XAVXTNsc4GguDhxjr/5DXDllf3foy0twLZtwHPPiQCtuUBQVhZw773u2yibiIgcYkiZQX//+9+xceNGLFq0CA899BAmTRL/aDp48CCeeuopvPHGG0hMTMSjjz7qkMUSERGRGc4u65k3z9CUVpbFheiyZUjMyHCPPiS9Aauqz7+GJAGTa46gKFqDKdVHkFZTjkb/YAR2ikBEYGc7ziv9URgzET1KJXy7uzDu3CmknjmKiLZG/SFV3Z245vAebJq6AFPGRTi31M0os6nmUBnGx4/H0VDLTa6NSRIwbVy4fn31R46itqUTAPSZTeaYvO7Go+cBz2gabitvK3kDbG+GfdNNwKFDhgyis2cNv4dnzwJ+fiKLSHcMSz2kiIjIKw0pGPTqq6/iqquuwv/+9z+Tn8+YMQMffvghrrrqKrz66qsMBhERETmTs8t6UlPFhaYuE6GrS/RQycwE5s5FikZjGlBwRR+SefPQuWUHJACSDPxh++to9QtAQ0AIzgRHIKa5DucCQnA6OBJHIuPxWdpcLJo6Fl8eOo244z9gfP1JnAsIRURbEyDLOB0cifTT5eg5shvLf/cn8RjOKnUzKsXr7NZiRmUhjqbbFgxSKhQmpXhV9W2QJEALYG+89WCVyetuzBOahtvKm0regEE0w45Dyl//Ctx/P/DGG8C774oAXU+PKCObNEn8Ts6ezalhREQjzJCCQWfOnMFDDz1k8f5FixbhwQcfHMpDEBER0UCslPXYUqxtU1nPkiUiQKDLSJBl0UNl3z6RcaHRiH07OlzThyQ1FaenzYD2sy8Q0t6C2KazgAScCwjFyZBR+CL5EoS3iwv4yafLUFRdhla/ZjxeWwrfH/LR4OuPiqh41Lc1IbCzDU3+wYgKVuHPQTVQn60ETnY6r9TNaCS4n68CaaeOIHVMMkpGJw24622XjDMpxevs1kICUDoqEQ0BIVb3NXndjXlC03BbDcfvxnAaSjPs3/5WZP4YN8O+4ALXZTgREZFLDSkYNHHiRNTU1Fi8v7q6GhMnThzKQxAREZnSjVA+eFD81b+jQ1ykqdXiYnMk/oV7OMp6FApx4WmuaW1Vlfngj7GsLBEIclIfkmO1rXg+ciqmjCnHDcW9F8wyENHWhLrAUAR2dSCh/hS0kgIKWYt/ZK9DTUgUGgJCIMtAWKASY0L8Ua25BCfSpuJHez5GWEDvP5PeeEO815xZ6tZbihcXHoCiqkYsLcjGuxnzBwwILb14nEkpnp+vAjKA3eMyBnxIk9fdmCc0DbeVN5W8eWszbCIicokh/Yvs4Ycfxrp161BQ0L8B4f79+/HCCy9g1apVQ3kIIiIioaQEWLcO+POfxYVqVZXIVGlvF/+tqgK2bgX+9CexXUmJq1c8fIwaEBuX9dhSBgPYUdajUABLlwIrVwKTJxt6k1giSWK7lSvFfk4MBC1ctws/1J7H5xNnoMPXT3/fuYAQNASEQNXTBRlAdHMtRrecQ3DHeSTXViKp9gSCO1rR2NaFTcHJSHv0d7ht+UKEXX6peF+Vloqx3MblRs4odestxQsP9ENUsB/8tD346f7P8JOCbCTUn0LfjtI+EnBdQCsu+OQ9kenRJbJX4sIDsDs+HeVR8QM+pP5178sTmobbarh+N4aDNzbDJiIil7ErM+hvf/tbv5+NHz8emZmZuPrqq5GSkgIAKCkpwZdffomMjAwcPnzYMSslIqKRydoIZXNkWTQ7Lix0ejaK2xjusp7UVPFVVycuJIuLRQ+V9naRMREcPGCWVv/eJtH9e9fYyPhi+OKqQ6gMi0GDvxpjWupQozY8fmV4DPy03Qg/3yR+0Js5pJC1KA4MRUdXN97/87P4/dzxIvPM+I9d1dXA+PHOLXXrLcWb0b4X2QdPo6tHi4zqI8ioPoJqdSSOh8eg00cJf203JjSfxh3xPsAp08ye8Mtn4FRnKnxONdv+upvj7k3DbeVNJW/e2AybiIhcxq5g0F//+leL933++ef4/PPPTX6Wn5+P/fv345FHHhnU4oiIyE7eVkKlG6FsPDlHJy5ONHTV9akpK+tfqpSbK7I7li3z7oCQq8p6IiPFRaQdF5I29TaJCrL5eH0vhieePQ4AaPIPxg+jEvDm1GtxSdVBTDx7HEFd7Tg4RoO4htMY03oODf5qnAkKR6evH1Q93bj4eBFwHKhvK0N4gBIICgJaW8WB6+uBe+5xbnCxtxRPHRqK+fgCeyrOoba5A5IEjG2pQ2xLHWQZiFKrMCMpAmr/PiVevcHPf59rs+91N8cTmobbwptK3rytGTYREbmUXcGgo0ePOmsdREQ0FCUlorFoUVG/chKTMqrsbM8aH2zrCGVAnHdFhbjYM74Yzc8Xx1m6dHjXPpyMGhADEOc/fToSMzKwecUsPPh+AfKO15sEX3q0MqbGh+FpXfBlGMp67OptYmNAqO/FcFBnm/6+4+GxaAgMRfbEmcieONNkP03tCcysLEDK2WOQjH5lJAmoqm9DeKAfEBoKnD8PREQAKSnD8x7qLcVTZ2Tg6pwc1O/9HlXnzqOzWws/XwXiwwMRFmgUBDIzElxXzmXT626NuzcNt4WH/G7YxNuaYRMRkUvZFQxKSEhw1jqIiGgwvLmEyu4RytGi/EGjAaZPFxlFvX1UkJsr9vOEANhgDWNZz2BLvOzpbfLB8plmt+mr78WwqscwHavDx0xz5F7lUfEoj4pHWFsTLjlRrM8cCujpQpMqSAQ7QkOB06dF6dtwNwzuLcULX1qH8EGU4iVGBQ38ug/EzZuG28xbSt68qRk2ERG53JCmiRERkQt5ewnVUEYoZ2SI7Y1HKOfkeHcwaBjKeoZS4jWo3iY2BJj6Xgx3+Cih6hYBIePAkCUNASEmmUM+Cgm/njcBs66cALz9NrBjh9jQVRfMgyjFM5YSHTLoXkwADE3DMzIsZx8aM5Op5HLeUvKmVovPbMCkGfbabUds2t2tmmETEZHLDTkY1N3djY8++gh79+5FfX09tFqtyf2SJOGVV14Z6sMQEVFf3lxCxRHKg+PEsp6hlngNurfJAPpeDLf6BSCk4zwAGKZwDTT1zAgvmC1wQNNwl/KGkjdvaoZNREQuN6Rg0Llz55CVlYXi4mLIsgxJkiD3XmDobjMYRETkBF5SQmWx3MgBI5Q/WD5TjFDWBYN0I5S9eWqOE8t6hlriNejeJgNIiQ4xuRg+PCoBMc11AICY5jqMa6hBZXiMTccyvmAu37Mf5787pO/VE37JbMTZdBQvN8RMJZfxhpI3b2qGTURELjekYNCf//xnlJaW4uWXX8bcuXOh0WiQnZ2NcePG4fHHH8eRI0eQnZ3tqLUSEZGOh5dQDbTOlyvzEa7bmCOU7eOEsh5HlHgNureJDYwvhvfGp2H20Xx9U+gZlYU4GRmLAKUPJAk439lj9YJ55ZUTsPiFXZiw5T1MqWmEBEArSXiqQAHN+t12TzsjN+LpJW/e1AybiIhcbkjBoE8//RR33HEH7r77btTVib/C+fj44IILLsBbb72FuXPn4uGHH8b69esdslgiIoLHl1DZss6Pdv6Am5KDxehsjlAeHAeW9TiixGtQvU1sZDo9S8bh0eOReuYoZACTa46gW5qG+++/CQCsXjCvvHICVry9H3GVhzG55ghkGZABlIxKQENAyKCmnZEb8uSSN29phk1ERC43pGBQTU0Npk+fLg7kKw7VbjSectGiRVi9ejWDQUREjuThJVS2rFPq7MCeik5cPWkMRygPlQPKehxR4tW3nMsSk94mdjCenvXdpwpMeH+jfhT7bY37gJNTgAEumBe/sAtxlYex5MBWk3Hzu8eJ8prBTDsjN+aJJW/e0gybiIhcbkjBoIiICLS2tgIA1Go1lEolTpw4ob9fqVSivr5+aCskIiJTxcWG2x5WQmXrOtsVvqhtPo/6850I5whll3NUiZfdvU1g/xj7lOgQpPzsGiCo0a4L5vI9+zFhy3uYXHPEJBC0Z1w6yqPi9d/bO+2MyOG8oRk2ERG53JCCQRMnTsShQ4cAAAqFAlOnTsVrr72Gu+66Cz09PXjjjTeQlJTkkIUSEVGv5mbDbQ8robJ1na1+AQjtPI+q+jaEc4SyyzmqxMu0nMt6b5OhjLEHYPcF8/m9BzGlptEkcaIoOhmfpF7e79D2TDsjcjhvaIZNREQuN6Rg0NVXX42nn34azz//PFQqFR544AEsXboUERERkCQJbW1teOmllxy1ViIiAkwzXTyshMrWdR4elYCxLXXo7NZyhLIbcGSJl3E5l6XeJkMdYw/A7gvmzm4tJIgeQYDICPok9XLIUv8LZnumnRE5hac3wyYiIpcbUjBo1apVePDBB6HqvZhYsmQJfH198eabb8LX1xc33XQTfvKTnzhkoURE1EulMgRuPKyEytZ17o1Pw5xj++Hn23shzhHKLjeYEi9rUqJDLGbWDHWMvZ4dF8x+vgpoJQkloxKwe1yGSWlYX/ZOOyNyGk9uhk1ERC41pGCQJEn6QJDO4sWLsXjx4iEtioiIrFCrRfkLIDJfPKiEytZ1NgSEoCQqAdeG9warOELZ5ewp8RoKR4yx78eGC+bwS2bjqQIFGgIGLv2yd9oZkdN5YjNsIiJyKbuCQW+88cagHuSOO+4Y1H5ERGRGWpqhxMXDSqjsKTdquvRyhJ3eIX4wgkYo29sweTjZUuI1VI4YY2+RlQvmOABJL+xy2rQzIiIiIndiVzDorrvugiRJkK3VJPchSRKDQUREjjR7NpCdbQh0eFgJla3r/O2KhcA2xYgZoTzkhsnDyFqJ11A5Yoz9YDm6FI6IiIjIXdkVDMrt24CRiIiGX2SkKHkqLBTfe1gJlV3lRiNkhLJDGiZ7CUeNsR+M4SqFIyIiInI1SbYnzcfJdu7cidWrV+P7779HdXU1PvzwQyxatEh/vyzLePTRR7FhwwY0NDRg1qxZWL9+PSZMmGDzYzQ1NSE0NBSNjY0ICXGPtHsiIruVlABr1xq+VyrF5KQMkbFgUwlVl1FGxcqVLsmcsancSKs1PxHKFh4yQnmxHeVJVhsme4HSmiYsWPu1zdtnr5ztlJItZ5bCERERETmLrTGPITWQdrTW1lZkZGTgnnvuMduE+qmnnsKzzz6L119/HePHj8cjjzyC+fPn49ChQ/Afhik4RERuIzVVBDo8vITKpnIjLx+h7JSGyR7MkWPsh7oOb36eiYiIaGRzq2DQNddcg2uuucbsfbIsY+3atfjzn/+MhQsXAhANrceMGYOPPvoIS5cuNbtfR0cHOoxGJzc1NTl+4URErjBCSqj0vHSEslMbJnso9u4hIiIici63CgZZc/ToUdTU1ODKK6/U/yw0NBSXXHIJ9uzZYzEY9MQTT+Cxxx4brmUSEQ0fhUKUhpkroaqqMh/8MeYhJVT9eNkIZVc2THZX7N1DRERE5FweEwyqqakBAIwZM8bk52PGjNHfZ87DDz+MBx54QP99U1MT4uPjnbNIIqLh5uUlVCOBKxsmu7PEqCD8/YY0vPXtcRw8KbJ608aG4qeXJrB3D3mO2lqRyXjwINDcLDI1VSpArfbITEYiIvIeHhMMGiyVSgWVSuXqZRAROZeXllCNBAvSorF22xGbtu3RyliQFu3kFbnesdpWPLDpAPIrG0yygvafaMCh6ib8m1lB5O5KSiwH6NvbRYlvVRWQnc0APRERuYTHBIOio8U/fk+fPo2YmBj9z0+fPo0pU6a4aFVERG7Gy0qoRgJ3aZjsLo7Vtur7BQEiAGZcQnfgRAMWrtuFzStmMSBE7sfe6YeyDBQWii9PLd0lIiKP5DH/txk/fjyio6Px1Vdf6X/W1NSEvXv3YsaMGS5cGRER0dCsWTIFwSpf+Cgks/ePpIbJD2w6YLFxNCCCQy0d3Xjw/YJhXhnRALRaYMMG84GguDhg7lxg/nzx37i4/tvk5or9tVpnr5SIiMi9MoNaWlpQVlam//7o0aM4cOAAIiIiMG7cOKxcuRJ///vfMWHCBP1o+djYWCxatMh1iyYiIhoiNkwWSmuakF/ZMOB2PVoZecfrUVrT5PWT1ciDbNpkmO4IiB5tmZki4ycpSXyvI8tARYUIAOXlGUrJ8vPFcSwMRiEiInIUtwoG5eXlISsrS/+9rvHznXfeiddeew0PPfQQWltbcd9996GhoQGXXXYZtm7dCn9/f1ctmYiIyCESo4LwwfKZKK1pQnbxaTS2dSE0QIkFadFeXxqms7W4Bj4KyWq5nI6PQkJ28WkGg8g9lJSYZgQplWLaY4bI5iutacLW4ho0tXUjJMAXC9KikaLRABoNMH26yAjq6p0UmJsr9mMPISIiciJJlq2NnfE+TU1NCA0NRWNjI0JC+A9IIiIid/G3LYfw5rfH0NUz8D9NlD4Sbr80EX+5ftIwrIxoAOvWib4/gMgAWr4cyMiw2Ay9RytjWkK4oRl6QQGwfr0hQ2jyZGDFCtedDxEReSxbYx4e0zOIiIiIvFtIgC9sSAoCIC6oQwOUzl0QkS3q6sTUMJ3MTH0gaOG6XSioagQgAkBdPbI+803XDP1YbavIBMrMNByjqEgcl4iIyEkYDCIiIiK3sCAt2qYSMUBcWC9Ii3byiohssHOn6fj43pYHdjdDnzvXcKcsi+MSERE5CYNBRERE5BZSokNw0bgwi1PVdHwUEjITwkdMLyVyc8XFhttxcUBSkr4Z+kDBTeNm6NBogLFjzR+XiIjIwRgMIiIiIrexZskUBKt8LQaEfBQSglW+ePrmjGFeGZEFzc2G28nJgCTpm6HbQtcMHZIk9tdpaXHwQomIiAzcapoYERGRK5md+MNpVcMqMSoIm1fMwoPvFyDveH2/prtT48PwtK7pLpE76Ogw3FapAABNbd1QSECPDbsrJKCxrctkfwBAe7vj1khERNQHg0FERDTiWZr4s3bbEdOJPzQsEqOC8MHymSitaUJ28Wk0tnUhNECJBWnRLA0j96NSGQI3vYGhQTdDNw4s+fs7cJFERESmGAwiIqIRTTfxp6WjG4DIPjH+a75u4s/mFbMYEBpmKdEhzMwi96dWA41iYhjKygBZNDdfu+2ITbvrm6HLsthfJzjYCYslIiIS2DOIiIhGNLsn/kCUk63ddhh/23IIa7cdFs1fiWhkSksz3K6qAioqBtcMvbwcOHnS/HGJiIgcjJlBREQ0Yukm/gxEN/Enp+Q0ns8tYzkZERnMng1kZxvGy+fmAhoN1iyZos86NBds7tcMfft2w52SJI5LRETkJMwMIiKiEcueiT8KCVj+n3wUVIlykB6tjK4eWX+RpysnO1bb6rT1EpEbiowE0tMN3+flAQUF+mboU+PDAIjgj9JH0n/mTI0PM5SfFhSI/XTS08VxiYiInISZQURENGLZM/FHloHObi0s9YQ1Lif7YPlMRy6TiNzdvHlAYaG4LcvAhg3AsmVIzMgYuBl6QYHYXpZNj0dEROREDAYRkUUcs03ezp6JP7ZspisnK61p4u8K0UiSmgpkZYkSMQDo6gLWrwcyM4G5c5Gi0Zh+JuiaRW/fLjKCjANBWVnieERERE7EYBAR9cMx2zRS2DPxx1Y+CgnZxacZDCIaaZYsEVPF8vPF97IM7NsnvuLiAI1GjKHv6BDNoquq+h9j2jRxHCIiIidjzyAiMqEbs82+KDQS2Drxx7auQoJCAhrbuoa2MCLyPAoFsGyZyOzpq6oK2LED+OIL8V9zgaCsLODee8VxiIiInIz/tyEiE4MZs03kydYsmYJgla/FgJCPQoKfrwI29pmGVgZCA5QOXCEReQyFAli6FFi5Epg8WUwFs0aSxHYrV4r9GAgiIqJhwjIxItKzd8w2+6KQN9BN/Hnw/QLkHa83KY3s0cqYGh+GX2ZpcM9reQMfDGKfBWnRTl41Ebm11FTxVVcH7NwJFBcDLS1Aezvg7w8EBwNpaWJ8PKeGERGRCzAYRER6ujHblrKCjLEvCnmTxKigASf+XDQuDAVVjVZ/P3wUEqbGhxmmBBG5Wm2tCEYcPAg0N4t+NSoVoFYzGDEcIiOBG24QX0RERG6EwSAi0rNnzDb7opA3SokOsRjgXLNkChau22WxjNJHISFY5Yunb85w9jKJBlZSAuTkAEVFppOqAJGd0tgo+tZkZwPp6WKUOSdYERERjRgsTCYiPXvGbLMvCo00unKyqfFhAETwR+kj6XsNTY0Pw+YVszhpj1xLqwXefRdYuxYoLOwfCOpLlsV2a9eK/bTa4VglERERuRgzg4hIz54x2+yLQiORLeVkRC6j1QIbNhhGmxuLiwOSkw2jzcvK+k+0ys0VGUPLlrGRMRERkZdjMIiI9HRjttkXhcg6a+VkRC6zaZNpIEiSgMxMMbI8Kcl0spUsAxUVIgCUl2fIIMrPF8dZunR4105ERETDisEgIjLBvihERB6opEQEdnSUSpHhkyE+q0trmrC1uAZNbd0ICfDFgrRopGg0gEYDTJ8uMoq6evvA5eaK/dhDiIiIyGsxGEREJmwZs/30zRnsi0JE5E5ycgy3JUkfCDpW24oHNh1AfmWDyef52m1HMC0hHP++OQOJGRli+/XrDRlCOTkMBhEREXkxBoOIqB936oti9q/ZLM8hIjKoqxNTw3QyM/WBIF2mJyAC+sbTIg+caMDCdbtE4/OMDLHfvn3izqIicVyOnSciIvJKDAYRkUWu7Iti01+zmZ1ERATs3Gk6NSwrCwDwwKYDFkt+AREcaunoxoPvF+CD5TOBuXMNwSBZFse94QYnL56IiIhcgaMiiMjt6P6aXVDVCEBcsHT1yPoLGt1fs4/VtrpymURE7qG42HA7Lg5ISkJpTRPyKxusDgMAxOdr3vF6lNY0if5BY8eaPy4RERF5FQaDiMjt2PPXbCKiEa+52XA7ORmQJGwtroGPQrK8jxEfhYTs4tOi11BysuGOlhYHL5SIiIjcBYNBRORWBvXXbCKikayjw3BbpQIANLV1w8ZYEBQS0NjWZbI/AKC93UELJCIiInfDYBARuZVB/TWbiGgkMw7g9AaGQgJ8MUBMXU8rA6EBSpP9AQD+/g5aIBEREbkbNpAmIrei+2t2z8Cbmv4128txqhoRWaRWA42ixxrKygBZxoK0aKzddsSm3Xu0YnvIsthfJzjYCYslIiIid8BgEBG5lUH/NdtLcaoaEQ0oLQ2oqhK3q6qAigqkaDS4aFwYCqoarZbd+igkTI0PwwXRahEIOnnS9LhERETklVgmRkRuZUFa9ID9gnT0f832UpyqRkQ2mT1bNH/Wyc0FAKxZMgXBKl+Lpbc+CgnBKl88fXOG+MH27YY7JUkcl4iIiLwSg0FE5FZSokNw0biwAfsG+SgkZCaEi79meylOVSMim0RGAunphu/z8oCCAiRGBWHzilmYGh8GQHxuKn0k/efr1PgwbF4xS2QXFhSI/XTS08VxiYiIyCuxTIyI3M6aJVOwcN0ui4GQfn/N9kK6qWoDMZ6qxh5CRCPYvHlAYaG4LcvAhg3AsmVIzMjAB8tnorSmCdnFp9HY1oXQACUWpEUbgukFBWJ7WTY9HhEREXktBoOIyO3o/pr94PsFyDteb9Irp0crY2p8GJ728l45uqlqtpTM6aaqMRhENIKlpgJZWfoSMXR1AevXA5mZwNy5SNFoTD8jdM2it28XGUHGgaCsLHE8IiIi8loMBhGRW0qMChr4r9lejFPViMhuS5aIqWL5+eJ7WQb27RNfcXGARiPG0Hd0AOXlhqbTxqZNE8chIiIir8ZgEJEX84Zx5CnRIR63ZkfgVDUisptCASxbBmzaZMgQ0qmqMh/8MZaVJQJBCraUJCIi8nYMBhF5IY4j93wL0qKxdtsRm7b19qlqRGQHhQJYuhTIyABycoCiItMSsL4kSTSLnjePpWFEREQjCINBRF5GN468paMbgAgUGJca6caR6yfIkFvSTVUrqGq02jfIRyFhanzYiCidIyI7pKaKr7o6YOdOoLgYaGkB2tsBf38gOBhISxPj4zk1jIiIaMSRZNnan4u8T1NTE0JDQ9HY2Ij/3979R0V13/kff90BBFR+GE0kBpCIiVBBNGJcY+sKdSPZnETTHo05+WU3MV2L2xrrnmyaH5pvTpLdbZp60ljbdfOjbfY0wZymdptEqwKyNeYHQVEsuuLPUIUsJDBgBJH5fP+4mRlGfg0qMMM8H+fM8c7cez98Ru65M758fz6f2NjQG3qCoe9bP9/ld4Dw1vKbBrBn6KuOwV5Pq6oR7AEAAACQ/M88GBQODCHu5ch7W4Gq43LkCFzuVdWmJcVLssOfiDBLYQ5LkjQtKZ4gCAAAAECfMUwMGEJYjnzoCfVV1QAAAABcfoRBwBDCcuRD14CvqlZXZ88zcuCA1NRkL0UdGSnFxDDPCAAAABDkCIOAIYTlyHHJKiu7X4GopUVqbLSXp966lRWIAAAAgCDFnEHAEJKXkeDXEDHJnjfoeN0Zrdv+v8wdBMnlkt54Q1q3Ttq3r+elqCV7/7599vFvvGGfDwAAACAoUBkEDCH+Lkfu9sf9p+Qy0rrthzV9/Cj9ZFEWkxGHIpdL2rhRKivrvC8xUZo40R4i1toqVVXZlUEdFRXZFUPLlkkO/o8BAAAACHQsLQ8MMb0tR94dlikPYW+8YQc6bpYlZWdLOTnShAn2czdjpKNH7eNLS30riHJypCVLBq7fAAAAAHz4m3kQBgFD0PG6M1q9qVylJ75QmMOSw5La2v1bYWxaUrzeWn7TAPQSAaGy0h7q5RYRYVf4ZGVJkg7WOLWlokbOs+cVGx2uvIwE70TW5eV2RVFbh4nIV65kDiEAAABgkBAGdYMwCKHEvRz58fpmvb3nlN/nbVn5DZacDxXr19tz/0h2BdDy5VJWlo7XndGqgr0qO9ngCRRdxp5rymdIYXm5tGGDt0JoyhQpP3/w3g8AAAAQwvzNPJjcARjC0hJi9YN512n86BEKc1i9nyC7OmhrRW0/9wwBob7eXjXMLTvbEwQtWL9L5dWNkuwAqK3deIYd7v20QQvW79LxujN2BVF2treN/fvtdgEAAAAELMIgIAQ4z56Xn1mQHJbUeLat9wMR/EpKOs/5I2lVwd4e55xqdxk1t57X6k3l9gtz53p3GmO3CwAAACBgEQYBISA2Olz+ziXtMlJcdET/dgiBoaLCu52YKE2YoIM1TpWdbOh18vF2l1HpiS90sMYppaZK11zTdbsAAAAAAg5hEBAC8jIS/F5ZrN1llJeR0M89QkBoavJuT5woWZa2VNT0fUihZdnnuzU3X+aOAgAAALicCIOAEJCWEKsbkuN7/Ud+mMNS9vhRmpQQM0A9w6BqbfVuR0ZKuoQhhV+dL0lqablMHQQAAADQH8IHuwMABsYLi6dqwfpd3c4FE+awNDIyXM8vyhqE3mFQREZ6g5uvgqGLHlLYMViKirq4/tTV2fMNHThgVy21ttp9jImRMjKkOXOk0aMvrm0AAAAAHoRBQIhIGTNCm/Nna/WmcpWe+KLTcuHTkuL1vHu5cISGmBip0V4xTFVVkrGHCK7bftiv0z1DCo2xz3cbObJv/aislAoL7ZXIzAVJVEuL3cfqamnrVikzU8rNldLT+/YzAAAAAHgQBgEhJGXMCL21/CYdrHFqa0WtGs+2KS46QnkZCQwNC0UZGXbIItl/Hj2qtNRU3ZAcr/Lqxh7nmQpzWJqWFG9fN1VV0l//6tuuP1wuqaBAKiry73hjpH377EdOjrR4seRgtDMAAADQV4RBQAhKS4hVWkLsYHcDg23OHLvaxl2NU1Qkpab2fUhhcbF3p2XZ7fbG5ZI2bpTKyjrvS0y0J6SOjLSHilVVeUMrt6Iiu2Jo2TICIQAAAKCPCIMAIFSNHm0Pu9q3z35eWirNmKGUrCz/hxSWl9vnuWVm+jevT0GBbxBkWVJ2tl3xM2GC/dzNGOnoUTsAKi31hldlZXY7S5Zc+t8FAAAAEEIIgwAglOXmesMgY+xqnWXLlJKV1fuQwvJy+/iO8/zk5vb+MysrfYeGRUTYFT5ZdqXRwRqntlTUyHn2vGKjw5WXkaC01FQpNVWaMcP+mW1frWJWVGSf18McQl22R2UcAAAAQphlzIWzdQ5tTqdTcXFxamxsVGws/xgAAL3xhm84467SmTvXDmAurNI5csQeGtaxSkeyq3r8qdJZv94bQFmWtHy5lJWl43VntKpgr8pONnSqRpo+fpR+0rEaacMG78+eMkXKz+/0Y/xuDwAAABgi/M08CIMAINT1Nn9Paqp3/p4jRzrP3yNJ06dLDz7Y+/w99fXSY495g5wZM6QHH9TxujN+zVO0OX+2HeD8539KH39s77Qs6ZlnfIan9bk9AAAAYAjwN/MIqlk3165dK8uyfB5paWmD3S0ACG4Ohz1MKyen877qamnnTulPf7L/7CoIysnxLwiSpJKSztVEklYV7O02uJHsap7m1vNavancfmHuXO9OY+x2O+hzewAAAEAICbo5gyZPnqzt27d7noeHB91bAIDA43DYQ7yysqTCQmn/ft/Q5kKWZU8WnZvb43w9nVRUeLcTE6UJE3Swxqmykw29ntruMio98YUO1jjtOYSuuca7pH1FhXTHHZJ0ce0xhxAAAABCSNAlKeHh4UpISBjsbgDA0JSebj/q6+1qm4oKqblZammRoqKkkSOljAx7+Xh/Vg27UFOTd3viRMmytKWiRmEOq9sqno7CHJa2VtTa4c3Eid4wqLnZc8xFtwcAAACEiKALgw4fPqxx48YpKipKs2bN0nPPPafk5ORuj29tbVVra6vnudPpHIhuAhgIdXV2YHHggB0ytLbac9vExFxaYAH77+2OOzzVNpdNh/uxIiMlSc6z5+WwpHY/TndYUuPZNp/zJdlh1Vcuuj0AAAAgRARVGDRz5ky99tprmjRpkk6fPq2nnnpK3/jGN1RRUaGYmJguz3nuuef01FNPDXBPAfSrysruhzK1tEiNjfbcNlu3XtxQJvSfyEhvcPNVMBQbHS4/ingk2auBxUVH+Jwvya5a+spFtwcAAACEiKAKg2655RbP9pQpUzRz5kyNHz9eBQUFeuCBB7o859FHH9WqVas8z51Op5KSkvq9rwD6gcslFRT4LoPeE2PsJcz37bMnKl682L9JjgfbUK54iomxwzpJqqqSjFFeRoLWbT/s1+ntLvt4GWOf7zZypGfzotoDAAAAQkhQhUEXio+P1/XXX6+qjv8guEBkZKQiOw4lABCcelv+fOJE7/LnVVWdV70qKrJDiGXLAjcQCoWKp4wM7++mulo6elRpqam6ITle5dWNPc7zE+awNC0pXpMSYuzfsXu+IHe7X0lLiO17ewAAAEAICeowqLm5WUeOHNG999472F0B0N8KCnyDIMuSsrPtip8JE+znbsZIR4/aAVBpqTdYKSuz21myZGD73ptQqXiS7KqmrVu9v5OiIik1VS8snqoF63d1uxx8mMPSyMhwPb8oy36huNi707Lsdjvoc3sAAABACAmSfz3YVq9erZ07d+r48eN6//33dccddygsLEx33XXXYHcNQH+qrPQNSiIipOXLpQcflFJTdbC2Seu2/6/+33//Reu2/68O1jZJqan2/uXL7ePdiors9gKFu+KpqyAoMVGaO1eaP9/+MzGx8zFFRfb5Lld/9/TyGD3armpyKy2VysuVMmaENufP1rSkeEl2WBMRZinMYYd805LitTl/tlLGjJDKy+3z3DIzOw2b61N7AAAAQIixjLlwLELgWrJkiUpKSlRfX68rr7xSX//61/XMM88oNTXV7zacTqfi4uLU2Nio2FiWEgaCwvr1dhWMZFeBLF8uZWXpeN0ZrSrYq7KTDQpzWHJY9oTA7S6j6eNH6SeLsrzhwYYN3mqUKVOk/PzBez8dvfGGbxB0MRVPkn18oFU8daeyUlq3zvs8IsIevpdlV+kcrHFqa0WtGs+2KS46QnkZCd6hXOXldvjV1mEFsJUrexwu12N7AAAAwBDib+YRVGHQ5UAYBASZ+nrpsce8wceMGdKDD+p43Rm/hgF5qj/+8z+ljz+2d1qW9Mwzgz8Jsx+hyJaKGjnPnldsdLjyMhKUlvDVfesiQpGA0l0INneuXdV1YQh25Ig9NCyYQzAAAACgn/mbeQT1nEEAQkBJSed//EtaVbC32yBIsquDmlvPa/Wmcr21/CY7ZHCHQcbY7d5xRz93vheFhd5ty/IEQd1VPK3bfthb8ZSVZR/fseKpsDB4wqDFi+0Jsd3zQBlj/34+/tgeDpea6p0Q/MiRzhOCS9L06XY7AAAAAPokqOYMAhCCKiq824mJ0oQJOljjVNnJhh5XipLsQKj0xBc6WOO0w4Vrrum63cFQX2+vGuaWne0Jghas36Xyanv59XaXUVu78bzXvZ82aMH6XTped8auIMrO9raxf7/dbjBwOOww66twz0d1tbRzp/SnP9l/dhUE5eTYc0IFy8TZAAAAQADhWzSAwNbU5N2eOFGyLG2pqPFMBNybMIelrRW1duXNxIneHc3Nl7mjfXQZKp4k2RVPbu6Kp2DhcNhDvFautOdxsnr5nVqWfdzKlfZ5BEEAAADARWGYGIDA1trq3Y6MlCQ5z56Xw5La/TjdYUmNZ9t8zpcktbRcvj5ejB4qnnrTseIpzV3x9Ne/etsd7OFvfZWebj/q6+0wq6LCDutaWqSoKGnkSCkjw14+frDneQIAAACGAMIgAIEtMtIb3HwVDMVGh6uXEWIeLiPFRUf4nC/JDhkGUw8VT70Nf5O8FU9pCbH2+e4waLArni7F6NF2kBVsYRYAAAAQZKixBxDYYjosAV5VJRmjvIwEvwITya6iyctIsIdQVVV5d4wceZk72kc9VDz5I2ArngAAAAAEPMIgAIEtI8O7XV0tHT2qtIRY3ZAc3+u8QWEOS9njR2lSQoy9IpW7eubCdgdDxwBnKFU8AQAAAAh4hEEAAtucOb4TCxcVSZJeWDxVIyPDuw2EwhyWRkaG6/lFWfYLxcXenZZltzuYhmrFEwAAAICARxgEILCNHi1lZnqfl5ZK5eVKGTNCm/Nna1pSvCQ7/IkIszzh0LSkeG3On62UMSOk8nL7PLfMzMGfiHioVjwBAAAACHhMIA0g8OXmSvv22dvGSBs3SsuWKSUrS28tv0kHa5zaWlGrxrNtiouOUF5Ggh2USHYQtHGj7zLuubkD/x4uNGeOtHWrt19FRVJqql5YPFUL1u/qdnn5gK94AgAAABDwCIMABL70dCknxzNETG1t0oYNUna2NHeu0lJT7VW13NxDp4qL7YqgjkFQTo7d3mBzVzy5Q67SUmnGDKVkZWlz/myt3lSu0hNfKMxhyWHZcwS1u4ymJcXr+UVZgVvxBAAAACDgWcYYP6crHRqcTqfi4uLU2Nio2NjY3k8AEBhcLrvCp6ys877ERCk11Z6UubXVHjpVXd35uOnTpQcflBwBMkK2slJat877PCJCWrZMyrKrfvyqeGpr856/cmVgBF0AAAAABoW/mQdhEIDg4XJJBQXeCqG+yMmRFi8OnCDI7Y03fN+PZXkqnpSa6jt5tjF20HVhxVNLi10RNGqU1NRkB2KRkfYk1RkZ9tAxKoYAAACAIY8wqBuEQcAQUFkpFRZK+/f7DgG7kGXZQ6dycwO3YuZSKp6++EI6dcoOuNLSfIOjjoLh7wEAAADAJSMM6gZhEDCE1NdLJSVSRYXU3GxXyERF2curB1NFTF8rnoyRjh61VxEbN65zBVFPArVCCgAAAMAlIwzqBmEQgIDlT8WTMdLBg3aANG6cPTTMLTFRmjjRW0lUVdX13Ek33GDPTUQgBAAAAAwp/mYerCYGAIEiPd1+9FTx1NAgXXut/VzyzjGUkyNNmNB5jqGjR+2Ko45zDJWV2ZVIS5YM+FsEAAAAMPioDAKAYOHH6mNbKmrkPHtesdHhystIUFrCV/c5Vh8DAAAAhjwqgwBgqCks9G5blicIOl53RqsK9qrsZIPCHJYcluQy0rrthzV9/Cj9ZFGWUrKy7OM3bPBWCBUWEgYBAAAAIYgJIwAgGNTX23MJuWVne4KgBet3qby6UZLU7jJqazdqd9mBz95PG7Rg/S4drztjVxBlZ3vb2L/fbhcAAABASCEMAoBgUFLiO6l0To4kaVXBXjW3nveEPxdqdxk1t57X6k3l9gtz53p3GmO3CwAAACCkEAYBQDCoqPBuJyZKEyboYI1TZScbug2C3NpdRqUnvtDBGqe9DP0113TdLgAAAICQQBgEAMGgqcm7PXGiZFnaUlGjMIfV/TkdhDksba2otecamjjRu6O5+TJ3FAAAAECgIwwCgGDQ2urdjoyUJDnPnpefWZAcltR4ts3nfEn2svUAAAAAQgphEAAEg44BzlfBUGx0uHoZIebhMlJcdITP+ZKkqKjL1EEAAAAAwYIwCACCQUyMd7uqSjJGeRkJvc4X5Nbuso+XMfb5biNHXuaOAgAAAAh0hEEAEAwyMrzb1dXS0aNKS4jVDcnxvc4bFOawlD1+lCYlxEhHjkh//WvX7QIAAAAICYRBABAM5syxJ392KyqSJL2weKpGRoZ3GwiFOSyNjAzX84uy7BeKi707LctuFwAAAEBIIQwCgGAwerSUmel9XloqlZcrZcwIbc6frWlJ8ZLs8CcizPKEQ9OS4rU5f7ZSxoyQysvt89wyM+12AQAAAISU8MHuAADAT7m50r599rYx0saN0rJlSsnK0lvLb9LBGqe2VtSq8Wyb4qIjlJeRYA8Nk+wgaONG+7yO7QEAAAAIOYRBABAs0tOlnBzPEDG1tUkbNkjZ2dLcuUpLTVVaQqz3ePdk0cXFdkVQxyAoJ8duDwAAAEDIIQwCgGCyeLHU2CiVldnPjZE+/th+JCZKqan2MvStrfZk0dXVnduYPt1uBwAAAEBIIgwCgGDicEjLlkkFBd4KIbfq6q7Dn45ycuwgyMGUcQAAAECoIgwCgGDjcEhLlkhZWVJhobR/v+8QsAtZlj1ZdG4uQ8MAAAAAEAYBQNBKT7cf9fVSSYlUUSE1N0stLVJUlDRypJSRYS8fz6phAAAAAL5iGdPTfycPPU6nU3FxcWpsbFRsbGzvJwAAAAAAAAQBfzMPJo0AAAAAAAAIIYRBAAAAAAAAIYQwCAAAAAAAIIQQBgEAAAAAAIQQwiAAAAAAAIAQQhgEAAAAAAAQQgiDAAAAAAAAQghhEAAAAAAAQAghDAIAAAAAAAghhEEAAAAAAAAhhDAIAAAAAAAghBAGAQAAAAAAhBDCIAAAAAAAgBBCGAQAAAAAABBCCIMAAAAAAABCCGEQAAAAAABACCEMAgAAAAAACCGEQQAAAAAAACGEMAgAAAAAACCEEAYBAAAAAACEkPDB7gD8VFcnlZRIBw5ITU1Sa6sUGSnFxEgZGdKcOdLo0YPdSwAAAAAAEOAIgwJdZaVUWCjt3y8Z47uvpUVqbJSqq6WtW6XMTCk3V0pPH5y+AgAAAACAgEcYFKhcLqmgQCoq8u94Y6R9++xHTo60eLHkYBQgAAAAAADwRRgUiFwuaeNGqays877ERGniRHuIWGurVFVlVwZ1VFRkVwwtW0YgBAAAAAAAfBAGBaKCAt8gyLKk7Gy74mfCBPu5mzHS0aN2AFRa6h1KVlZmt7NkycD2HQAAAAAABDTCoEBTWek7NCwiwq7wycqSJB2scWpLRY2cZ88rNjpceRkJSktNlVJTpRkz7Iqitjb73KIi+zzmEAIAAAAAAF8hDAo0hYXebcvyBEHH685oVcFelZ1sUJjDksOSXEZat/2wpo8fpZ8sylJKVpZ9/IYN3gqhwkLCIAAAAAAA4BGUE8qsX79eKSkpioqK0syZM/XRRx8Ndpcuj/p6e9Uwt+xsTxC0YP0ulVc3SpLaXUZt7UbtLjvw2ftpgxas36XjdWfsSqDsbG8b+/fb7QIAAAAAACgIw6A333xTq1at0po1a1RWVqasrCzNnz9fn3322WB37dKVlPguH5+TI0laVbBXza3nPeHPhdpdRs2t57V6U7n9wty53p3G2O0CAAAAAAAoCMOgF154QcuWLdN3vvMdfe1rX9MvfvELDR8+XK+88spgd+3SVVR4txMTpQkTdLDGqbKTDd0GQW7tLqPSE1/oYI3Tnj/ommu6bhcAAAAAAIS0oAqDzp07p08++UTz5s3zvOZwODRv3jzt3r27y3NaW1vldDp9HgGrqcm7PXGiZFnaUlGjMIfV/TkdhDksba2otecamjjRu6O5+TJ3FAAAAAAABKugCoPq6urU3t6usWPH+rw+duxY1dTUdHnOc889p7i4OM8jKSlpILp6cVpbvduRkZIk59nz8jMLksOSGs+2+ZwvSWppuUwdBAAAAAAAwS6owqCL8eijj6qxsdHz+PTTTwe7S93rGOB8FQzFRoerlxFiHi4jxUVH+JwvSYqKukwdBAAAAAAAwS6owqAxY8YoLCxMtbW1Pq/X1tYqISGhy3MiIyMVGxvr8whYMTHe7aoqyRjlZST0Ol+QW7vLPl7G2Oe7jRx5mTsKAAAAAACCVVCFQcOGDdP06dO1Y8cOz2sul0s7duzQrFmzBrFnl0lGhne7ulo6elRpCbG6ITm+13mDwhyWsseP0qSEGOnIEemvf+26XQAAAAAAENKCKgySpFWrVmnjxo361a9+pcrKSi1fvlxnzpzRd77zncHu2qWbM8ee/NmtqEiS9MLiqRoZGd5tIBTmsDQyMlzPL8qyXygu9u60LLtdAAAAAAAABWEYdOedd+r555/Xk08+qalTp2rv3r3asmVLp0mlg9Lo0VJmpvd5aalUXq6UMSO0OX+2piXFS7LDn4gwyxMOTUuK1+b82UoZM0IqL7fPc8vMtNsFAAAAAACQZBlj/JyeeGhwOp2Ki4tTY2NjYM4fVFkprVvnfR4RIS1bJmXZVT8Ha5zaWlGrxrNtiouOUF5Ggj00TLKDoI0bpbY27/krV0rp6QPWfQAAAAAAMDj8zTzCB7BP8Ed6upST4xkiprY2acMGKTtbmjtXaampSkvo8At1TxZdXGxXBHXM9nJyCIIAAAAAAIAPwqBAtHix1NgolZXZz42RPv7YfiQmSqmp9jL0ra32ZNHV1Z3bmD7dbgcAAAAAAKADwqBA5HDYQ8MKCrwVQm7V1V2HPx3l5NhBkCPopoQCAAAAAAD9jDAoUDkc0pIl9lxBhYXS/v2+Q8AuZFn2ZNG5uQwNAwAAAAAA3SIMCnTp6fajvl4qKZEqKqTmZqmlRYqKkkaOlDIy7OXjWTUMAAAAAAD0gtXEAAAAAAAAhgB/Mw8mlQEAAAAAAAghhEEAAAAAAAAhhDAIAAAAAAAghITcBNLuKZKcTucg9wQAAAAAAODycWcdvU0PHXJhUFNTkyQpKSlpkHsCAAAAAABw+TU1NSkuLq7b/SG3mpjL5dKpU6cUExMjy7IuuT2n06mkpCR9+umnrE6GbnGdwB9cJ/AH1wn8wXUCf3CdwB9cJ+gN10hgMcaoqalJ48aNk8PR/cxAIVcZ5HA4lJiYeNnbjY2N5cJHr7hO4A+uE/iD6wT+4DqBP7hO4A+uE/SGayRw9FQR5MYE0gAAAAAAACGEMAgAAAAAACCEEAZdosjISK1Zs0aRkZGD3RUEMK4T+IPrBP7gOoE/uE7gD64T+IPrBL3hGglOITeBNAAAAAAAQCijMggAAAAAACCEEAYBAAAAAACEEMIgAAAAAACAEEIYBAAAAAAAEEIIgwAAAAAAAEIIYVAv1q5dK8uyfB5paWk9nrNp0yalpaUpKipKmZmZevfddweotxgsKSkpna4Ty7KUn5/f5fGvvfZap2OjoqIGuNfoTyUlJbrttts0btw4WZal3//+9z77jTF68skndfXVVys6Olrz5s3T4cOHe213/fr1SklJUVRUlGbOnKmPPvqon94BBkJP10lbW5seeeQRZWZmasSIERo3bpzuu+8+nTp1qsc2L+ZzC4Gtt/vJ0qVLO/3O8/Lyem2X+8nQ0tt10tX3FMuy9OMf/7jbNrmfDC3PPfecZsyYoZiYGF111VVauHChDh065HNMS0uL8vPzNXr0aI0cOVLf/va3VVtb22O7F/udBoGpt+vk888/1z/90z9p0qRJio6OVnJysr7//e+rsbGxx3Yv9rMK/YcwyA+TJ0/W6dOnPY8///nP3R77/vvv66677tIDDzygPXv2aOHChVq4cKEqKioGsMcYaB9//LHPNbJt2zZJ0qJFi7o9JzY21uecEydODFR3MQDOnDmjrKwsrV+/vsv9//7v/64XX3xRv/jFL/Thhx9qxIgRmj9/vlpaWrpt880339SqVau0Zs0alZWVKSsrS/Pnz9dnn33WX28D/ayn6+TLL79UWVmZnnjiCZWVlel3v/udDh06pNtvv73XdvvyuYXA19v9RJLy8vJ8fue//e1ve2yT+8nQ09t10vH6OH36tF555RVZlqVvf/vbPbbL/WTo2Llzp/Lz8/XBBx9o27Ztamtr080336wzZ854jnn44Yf13//939q0aZN27typU6dO6Vvf+laP7V7MdxoErt6uk1OnTunUqVN6/vnnVVFRoddee01btmzRAw880Gvbff2sQj8z6NGaNWtMVlaW38cvXrzY3HrrrT6vzZw503z3u9+9zD1DIPvBD35gUlNTjcvl6nL/q6++auLi4ga2Uxg0kszbb7/tee5yuUxCQoL58Y9/7HmtoaHBREZGmt/+9rfdtnPjjTea/Px8z/P29nYzbtw489xzz/VLvzGwLrxOuvLRRx8ZSebEiRPdHtPXzy0El66uk/vvv98sWLCgT+1wPxna/LmfLFiwwOTm5vZ4DPeToe2zzz4zkszOnTuNMfZ3kYiICLNp0ybPMZWVlUaS2b17d5dtXOx3GgSPC6+TrhQUFJhhw4aZtra2bo+5mM8q9C8qg/xw+PBhjRs3ThMmTNDdd9+tkydPdnvs7t27NW/ePJ/X5s+fr927d/d3NxEgzp07p9dff13/8A//IMuyuj2uublZ48ePV1JSkhYsWKADBw4MYC8xmI4dO6aamhqfe0VcXJxmzpzZ7b3i3Llz+uSTT3zOcTgcmjdvHveXENLY2CjLshQfH9/jcX353MLQUFxcrKuuukqTJk3S8uXLVV9f3+2x3E9QW1urd955x6//yed+MnS5h/VcccUVkqRPPvlEbW1tPveGtLQ0JScnd3tvuJjvNAguF14n3R0TGxur8PDwHtvqy2cV+h9hUC9mzpzpKX3bsGGDjh07pm984xtqamrq8viamhqNHTvW57WxY8eqpqZmILqLAPD73/9eDQ0NWrp0abfHTJo0Sa+88oo2b96s119/XS6XSzfddJOqq6sHrqMYNO77QV/uFXV1dWpvb+f+EsJaWlr0yCOP6K677lJsbGy3x/X1cwvBLy8vT7/+9a+1Y8cO/du//Zt27typW265Re3t7V0ez/0Ev/rVrxQTE9Pr8B/uJ0OXy+XSypUrNXv2bGVkZEiyv58MGzas03849HRvuJjvNAgeXV0nF6qrq9PTTz+thx56qMe2+vpZhf7Xc3QH3XLLLZ7tKVOmaObMmRo/frwKCgr8+t8UhJ6XX35Zt9xyi8aNG9ftMbNmzdKsWbM8z2+66Salp6frl7/8pZ5++umB6CaAINLW1qbFixfLGKMNGzb0eCyfW6FnyZIlnu3MzExNmTJFqampKi4u1je/+c1B7BkC1SuvvKK7776718UruJ8MXfn5+aqoqGAOKPSot+vE6XTq1ltv1de+9jWtXbu2x7b4rAo8VAb1UXx8vK6//npVVVV1uT8hIaHTjPu1tbVKSEgYiO5hkJ04cULbt2/Xgw8+2KfzIiIiNG3atG6vKwwt7vtBX+4VY8aMUVhYGPeXEOQOgk6cOKFt27b1WBXUld4+tzD0TJgwQWPGjOn2d879JLT9z//8jw4dOtTn7yoS95OhYsWKFfrjH/+ooqIiJSYmel5PSEjQuXPn1NDQ4HN8T/eGi/lOg+DQ3XXi1tTUpLy8PMXExOjtt99WREREn9rv7bMK/Y8wqI+am5t15MgRXX311V3unzVrlnbs2OHz2rZt23yqQDB0vfrqq7rqqqt066239um89vZ27d+/v9vrCkPLtddeq4SEBJ97hdPp1IcfftjtvWLYsGGaPn26zzkul0s7duzg/jKEuYOgw4cPa/v27Ro9enSf2+jtcwtDT3V1terr67v9nXM/CW0vv/yypk+frqysrD6fy/0kuBljtGLFCr399tsqLCzUtdde67N/+vTpioiI8Lk3HDp0SCdPnuz23nAx32kQ2Hq7TiT7d3zzzTdr2LBh+sMf/tBrlWFXevuswgAY5AmsA94Pf/hDU1xcbI4dO2Z27dpl5s2bZ8aMGWM+++wzY4wx9957r/mXf/kXz/G7du0y4eHh5vnnnzeVlZVmzZo1JiIiwuzfv3+w3gIGSHt7u0lOTjaPPPJIp30XXidPPfWU2bp1qzly5Ij55JNPzJIlS0xUVJQ5cODAQHYZ/aipqcns2bPH7Nmzx0gyL7zwgtmzZ49nFah//dd/NfHx8Wbz5s1m3759ZsGCBebaa681Z8+e9bSRm5trfvazn3mev/HGGyYyMtK89tpr5i9/+Yt56KGHTHx8vKmpqRnw94fLo6fr5Ny5c+b22283iYmJZu/eveb06dOeR2trq6eNC6+T3j63EHx6uk6amprM6tWrze7du82xY8fM9u3bzQ033GCuu+4609LS4mmD+8nQ19vnjjHGNDY2muHDh5sNGzZ02Qb3k6Ft+fLlJi4uzhQXF/t8pnz55ZeeY/7xH//RJCcnm8LCQlNaWmpmzZplZs2a5dPOpEmTzO9+9zvPc3++0yB49HadNDY2mpkzZ5rMzExTVVXlc8z58+c97XS8Tvz9rMLAIgzqxZ133mmuvvpqM2zYMHPNNdeYO++801RVVXn2/+3f/q25//77fc4pKCgw119/vRk2bJiZPHmyeeeddwa41xgMW7duNZLMoUOHOu278DpZuXKlSU5ONsOGDTNjx441f//3f2/KysoGsLfob0VFRUZSp4f7OnC5XOaJJ54wY8eONZGRkeab3/xmp2tn/PjxZs2aNT6v/exnP/NcOzfeeKP54IMPBugdoT/0dJ0cO3asy32STFFRkaeNC6+T3j63EHx6uk6+/PJLc/PNN5srr7zSREREmPHjx5tly5Z1CnW4nwx9vX3uGGPML3/5SxMdHW0aGhq6bIP7ydDW3WfKq6++6jnm7Nmz5nvf+54ZNWqUGT58uLnjjjvM6dOnO7XT8Rx/vtMgePR2nXR3r5Fkjh075tOO+xx/P6swsCxjjLnMxUYAAAAAAAAIUMwZBAAAAAAAEEIIgwAAAAAAAEIIYRAAAAAAAEAIIQwCAAAAAAAIIYRBAAAAAAAAIYQwCAAAAAAAIIQQBgEAAAAAAIQQwiAAAAAAAIAQQhgEAACC2rFjx7Rw4UJdeeWVsixLS5cuHewuAQAABLTwwe4AAADApVi6dKn27dunxx57TAkJCUpNTe23n7Vu3TrFx8cHXeBUUFCg9957T2VlZfrLX/6i8+fP69ixY0pJSRnsrgEAgEFgGWPMYHcCAADgYrS2tio6OlorVqzQiy++2O8/LyUlRSkpKSouLu73n3U5zZ07Vx9++KGysrLU0NCgQ4cOEQYBABDCGCYGAACCVm1trYwxuuKKKwa7K5esra1NLS0t/dL2r3/9azU1NemDDz7QvHnz+uVnAACA4EEYBAAAgtLSpUs1fvx4SdJTTz0ly7JkWZanaufNN9/U17/+dcXExGj48OGaOXOm3nrrrU7tvPnmm7r99tuVnJysyMhIjRkzRgsXLtS+fft8jrMsSydOnNDOnTs9P8uyLB0/ftyzv6vhY6+99ppPvyRp7dq1sixLBw4c0KpVq5SYmKioqCh98MEHkuyKp2effVaTJ09WVFSU4uPjddttt2nPnj0X9XeVnJys8HBmBwAAADa+FQAAgKD03e9+V1OnTtXDDz+sO+64Q9/61rckSenp6Xr88cf1zDPPKC8vT08//bQcDofefvttLVq0SC+99JLy8/M97bz00ksaPXq0HnroISUkJOjIkSP6j//4D82ePVtlZWW67rrrJEm/+c1v9PDDD2vMmDF67LHHPOdfeeWVF/0e7r77bkVHR+uHP/yhLMvS1Vdfrba2NuXl5en999/XvffeqxUrVqixsVEbN27U7NmzVVJSouzs7Iv+mQAAAIRBAAAgKM2aNUtXX321Hn74YU2ZMkX33HOPJKmsrEzPPPOMHn30UT377LOe47///e9r4cKFevTRR3XfffcpJiZGkrRlyxaNGDHCp+377rtPU6dO1U9/+lP9/Oc/lyTdc889evzxxzV27FjPz7pU8fHx2r59u0/Vzk9/+lMVFxdry5Ytmj9/vuf1733ve8rIyNDq1auDbs4iAAAQWBgmBgAAhpT/+q//kmVZuv/++1VXV+fzuP3229XU1KTdu3d7jncHQcYYOZ1O1dXV6corr9SkSZP04Ycf9mtfV65c2Wn41uuvv660tDRNnz7dp+/nzp3T3/3d3+nPf/6zzp4926/9AgAAQxuVQQAAYEiprKyUMUZpaWndHlNbW+vZ3rNnj5544gkVFxfrzJkzPsdde+21/dZPSbr++us7vVZZWamzZ8/2OPysrq5OSUlJ/dk1AAAwhBEGAQCAIcUYI8uy9N577yksLKzLYyZPnixJOnnypObMmaPY2Fg98cQTmjRpkkaMGCHLsrRy5Uo1Nzdfcn/Onz/f7b7hw4d32f/MzEy98MIL3Z53KfMUAQAAEAYBAIAh5brrrtOWLVuUnJys9PT0Ho99++231dzcrD/84Q/Kycnx2VdfX6/IyEif1yzL6ratK664Qp9//nmn148ePdqH3tv9/7//+z/l5ubK4WBEPwAAuPz4hgEAAIaUe++9V5L0ox/9SO3t7Z32dxwi5q4cMsb4HLNx40bV1NR0OnfkyJFdBj6SPeRr9+7d+vLLLz2vffHFF3r11Vf71P/77rtPNTU13VYGdew/AADAxaAyCAAADCkzZszQ2rVrtXbtWk2dOlWLFi3SuHHjdPr0aX3yySd69913de7cOUnSLbfcouHDh3uWcB81apR27dqld999V6mpqZ2GeP3N3/yNXn75ZT3xxBNKT0+Xw+HQbbfdphEjRmjFihW65557lJubq3vvvVcNDQ3auHGjxo8f32Ww1J0f/OAH2rZtm/75n/9ZhYWFys3NVWxsrE6ePKkdO3YoKipKRUVFffo7KSkpUUlJiSSptLRUkvTSSy8pPj5ekvT444/3qT0AABDcCIMAAMCQs2bNGmVnZ+vFF1/UunXrdObMGV111VXKyMjQiy++6DkuNTVV7733nn70ox/p2WefVVhYmGbPnq2dO3dqxYoVOn78uE+7zzzzjD7//HOtX79eDQ0NMsbo2LFjGjFihO6++26dOnVKL730klatWqUJEyboySeflMPh6NOqZBEREXrnnXf085//XL/5zW+0Zs0aSdK4ceN044036v777+/z30dhYaGeeuopn9d+8pOfeLYJgwAACC2WubAuGgAAAAAAAEMWcwYBAAAAAACEEIaJAQAABCF/5iGKi4tTdHT0APQGAAAEE4aJAQAABKGelrl3e/XVV7V06dL+7wwAAAgqVAYBAAAEoW3btvV6zOTJkwegJwAAINhQGQQAAAAAABBCmEAaAAAAAAAghBAGAQAAAAAAhBDCIAAAAAAAgBBCGAQAAAAAABBCCIMAAAAAAABCCGEQAAAAAABACCEMAgAAAAAACCH/HwoXO9PM2H8NAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "data = make_data(feature_size=(100,3))\n", + "true_errors = np.where(data['true_labels'] != data['lables'])[0]\n", + "plot_data(data[['feature_1','lables']], circles=true_errors, title=\"Messy Regression dataset\", xlabel=\"feature_1\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The figure above represents a toy dataset we'll use to demostrate label scoring for regression dataset. In this example, lables are ploted w.r.t. one of the features of the dataset. \n", + "\n", + "Like many real-world datasets, the given label happen to be incorrect for some of the examples(**circled in red**) in this dataset. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Using cleanlab to generate label quality scores" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
feature_1feature_2feature_3lablestrue_labels
017.9868571.292315-4.46331915.61585215.615852
115.4469431.789677-4.15882311.87779713.877797
218.5907541.828643-3.37542317.84397417.843974
322.0921191.598861-3.41929723.07168421.071684
415.0633871.919357-7.06650412.71624010.716240
\n", + "
" + ], + "text/plain": [ + " feature_1 feature_2 feature_3 lables true_labels\n", + "0 17.986857 1.292315 -4.463319 15.615852 15.615852\n", + "1 15.446943 1.789677 -4.158823 11.877797 13.877797\n", + "2 18.590754 1.828643 -3.375423 17.843974 17.843974\n", + "3 22.092119 1.598861 -3.419297 23.071684 21.071684\n", + "4 15.063387 1.919357 -7.066504 12.716240 10.716240" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# start with checking the dataset generated\n", + "data.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# Note that \"true_labels\" will not be available in real-life dataset. We have added here only for comparision.\n", + "X = data[['feature_'+str(i+1) for i in range(3)]]\n", + "y = data['lables']\n", + "\n", + "# initialize your favourite model and generate predictions \n", + "yourFavouriteModel = LinearRegression()\n", + "yourFavouriteModel = yourFavouriteModel.fit(X,y)\n", + "predictions = yourFavouriteModel.predict(X)\n", + "\n", + "# get label quality score for each example in the dataset \n", + "label_quality = get_label_quality_scores(labels=np.array(data['lables']), pred_labels=predictions)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_data(\n", + " data[['feature_1','lables']], \n", + " circles=true_errors ,\n", + " color=label_quality, \n", + " title=\"Messy Regression dataset with label quality scores\", \n", + " colorbar=True, \n", + " xlabel = \"feature_1\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In the above plot, we have colored each datapoint considering its label quality score. \\\n", + "Datapoints in the plot are same as earlier plot in the notebook. **Red circle** represents that these datapoint were incorrectly marked when compared to true_label. \n", + "\n", + "Low scores for datapoints marked in **Red circle** and High scores for other datapoints justifies that method can identify the errors in the dataset. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.10.8 ('ENV': 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.10.8" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "1ed33b5e6ac3d9870092cd802185bba6fb7a8302b6022e7097221f18c33cb7b2" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 7f9372bc1139079fedea6d8b4213ce690dc176d2 Mon Sep 17 00:00:00 2001 From: krmayankb Date: Thu, 10 Nov 2022 12:44:24 -0800 Subject: [PATCH 033/258] unit tests added --- cleanlab/regression/rank.py | 5 ++++- tests/test_regression.py | 27 +++++++++++++++++++++++++++ 2 files changed, 31 insertions(+), 1 deletion(-) create mode 100644 tests/test_regression.py diff --git a/cleanlab/regression/rank.py b/cleanlab/regression/rank.py index 2fdde78299..54c38577f1 100644 --- a/cleanlab/regression/rank.py +++ b/cleanlab/regression/rank.py @@ -1,6 +1,6 @@ import numpy as np -""" generate label quality score for regression dataset""" +""" generate label quality score for regression dataset """ def get_label_quality_scores(labels: np.ndarray, pred_labels: np.ndarray) -> np.ndarray: @@ -39,6 +39,9 @@ def get_label_quality_scores(labels: np.ndarray, pred_labels: np.ndarray) -> np. array([0.36787944, 1. , 0.13533528, 0.90483742]) """ + if not isinstance(labels, np.ndarray) or not isinstance(pred_labels, np.ndarray): + raise TypeError("labels and pred_labels must be of type np.ndarray") + assert ( labels.shape == pred_labels.shape ), f"shape of label {labels.shape} and predicted labels {pred_labels.shape} are not same." diff --git a/tests/test_regression.py b/tests/test_regression.py new file mode 100644 index 0000000000..71de96cf3c --- /dev/null +++ b/tests/test_regression.py @@ -0,0 +1,27 @@ +import numpy as np +import pandas as pd +import pytest + +from cleanlab.regression.rank import get_label_quality_scores + +# To be used for all the tests +labels = np.array([1, 2, 3, 4]) +pred_labels = np.array([1, 3, 4, 5]) + + +def test_output_shape_type(): + scores = get_label_quality_scores(labels=labels, pred_labels=pred_labels) + assert labels.shape == scores.shape + assert isinstance(scores, np.ndarray) + + +@pytest.mark.parametrize("format", [pd.Series, pd.DataFrame, list]) +def test_type_error_for_input_types(format): + with pytest.raises(TypeError) as error: + _ = get_label_quality_scores(labels=format(labels), pred_labels=format(pred_labels)) + + +def test_assertion_error_for_input_shape(): + with pytest.raises(AssertionError) as error: + _ = get_label_quality_scores(labels=labels[:-1], pred_labels=pred_labels) + _ = get_label_quality_scores(labels=labels, pred_labels=pred_labels[:-1]) From 581c1f05263b25be10cf8509ae613b1e39b138c3 Mon Sep 17 00:00:00 2001 From: krmayankb Date: Thu, 10 Nov 2022 12:47:49 -0800 Subject: [PATCH 034/258] reindexed tutorial, punctuation fix for docstring --- cleanlab/regression/rank.py | 2 +- docs/source/tutorials/index.rst | 3 ++- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/cleanlab/regression/rank.py b/cleanlab/regression/rank.py index 54c38577f1..6f8ad48323 100644 --- a/cleanlab/regression/rank.py +++ b/cleanlab/regression/rank.py @@ -1,6 +1,6 @@ import numpy as np -""" generate label quality score for regression dataset """ +""" Generates label quality scores for every sample in regression dataset """ def get_label_quality_scores(labels: np.ndarray, pred_labels: np.ndarray) -> np.ndarray: diff --git a/docs/source/tutorials/index.rst b/docs/source/tutorials/index.rst index d0f89d7489..78e4efac5f 100644 --- a/docs/source/tutorials/index.rst +++ b/docs/source/tutorials/index.rst @@ -14,6 +14,7 @@ Tutorials multiannotator multilabel_classification token_classification + regression pred_probs_cross_val faq - regression + From 13ab45e381a87e08732ab657914bede36ea127e8 Mon Sep 17 00:00:00 2001 From: krmayankb Date: Tue, 15 Nov 2022 15:51:04 -0800 Subject: [PATCH 035/258] plots changed in tutorial notebook --- docs/source/tutorials/regression.ipynb | 99 ++++++++++++-------------- 1 file changed, 47 insertions(+), 52 deletions(-) diff --git a/docs/source/tutorials/regression.ipynb b/docs/source/tutorials/regression.ipynb index 46f3b5ee38..92bc78ff13 100644 --- a/docs/source/tutorials/regression.ipynb +++ b/docs/source/tutorials/regression.ipynb @@ -30,7 +30,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -43,15 +43,15 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ - "def make_data(feature_size = (20, 3), \n", - " means = [8, 20, -10], \n", - " stds = [2, 5, 3], \n", + "def make_data(feature_size = (20, 2), \n", + " means = [8, -10], \n", + " stds = [2, 5], \n", " bias = 0.8,\n", - " coeff = [2, 0.1, 0.5],\n", + " coeff = [2, 0.1],\n", " error = [-2, 0, 2], \n", " prob_error = [0.2, 0.6, 0.2], \n", " seed = 42\n", @@ -88,12 +88,9 @@ " title, \n", " alpha=0.6, \n", " color = '#1f77b4', \n", - " xlabel = \"feature\", \n", " colorbar = False):\n", " \n", " plt.figure(figsize=(14, 5))\n", - " plt.xlabel(xlabel, size=13)\n", - " plt.ylabel('label',size=13)\n", " data = data.to_numpy()\n", " plt.scatter(data[:,0], data[:,1], c = color, s=60)\n", " for i in circles:\n", @@ -114,14 +111,14 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 10, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -129,16 +126,20 @@ } ], "source": [ - "data = make_data(feature_size=(100,3))\n", + "data = make_data(feature_size=(100, 2))\n", "true_errors = np.where(data['true_labels'] != data['lables'])[0]\n", - "plot_data(data[['feature_1','lables']], circles=true_errors, title=\"Messy Regression dataset\", xlabel=\"feature_1\")" + "plot_data(data[['feature_1','feature_2']], \n", + " circles=true_errors, \n", + " color=data['lables'], \n", + " colorbar=True, \n", + " title=\"Messy Regression dataset\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "The figure above represents a toy dataset we'll use to demostrate label scoring for regression dataset. In this example, lables are ploted w.r.t. one of the features of the dataset. \n", + "The figure above represents a toy dataset we'll use to demonstrate label scoring for regression dataset. In this example, datapoints are ploted on 2-D space (in this case feature_1 vs feature_2). Each datapoint is colored based on given label. \n", "\n", "Like many real-world datasets, the given label happen to be incorrect for some of the examples(**circled in red**) in this dataset. " ] @@ -152,7 +153,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -178,7 +179,6 @@ " \n", " feature_1\n", " feature_2\n", - " feature_3\n", " lables\n", " true_labels\n", " \n", @@ -187,57 +187,52 @@ " \n", " 0\n", " 17.986857\n", - " 1.292315\n", - " -4.463319\n", - " 15.615852\n", - " 15.615852\n", + " -1.707685\n", + " 19.079171\n", + " 17.079171\n", " \n", " \n", " 1\n", " 15.446943\n", - " 1.789677\n", - " -4.158823\n", - " 11.877797\n", - " 13.877797\n", + " -1.210323\n", + " 15.036620\n", + " 15.036620\n", " \n", " \n", " 2\n", " 18.590754\n", - " 1.828643\n", - " -3.375423\n", - " 17.843974\n", - " 17.843974\n", + " -1.171357\n", + " 18.219397\n", + " 18.219397\n", " \n", " \n", " 3\n", " 22.092119\n", - " 1.598861\n", - " -3.419297\n", - " 23.071684\n", - " 21.071684\n", + " -1.401139\n", + " 21.490981\n", + " 21.490981\n", " \n", " \n", " 4\n", " 15.063387\n", - " 1.919357\n", - " -7.066504\n", - " 12.716240\n", - " 10.716240\n", + " -1.080643\n", + " 14.782744\n", + " 14.782744\n", " \n", " \n", "\n", "" ], "text/plain": [ - " feature_1 feature_2 feature_3 lables true_labels\n", - "0 17.986857 1.292315 -4.463319 15.615852 15.615852\n", - "1 15.446943 1.789677 -4.158823 11.877797 13.877797\n", - "2 18.590754 1.828643 -3.375423 17.843974 17.843974\n", - "3 22.092119 1.598861 -3.419297 23.071684 21.071684\n", - "4 15.063387 1.919357 -7.066504 12.716240 10.716240" + " feature_1 feature_2 lables true_labels\n", + "0 17.986857 -1.707685 19.079171 17.079171\n", + "1 15.446943 -1.210323 15.036620 15.036620\n", + "2 18.590754 -1.171357 18.219397 18.219397\n", + "3 22.092119 -1.401139 21.490981 21.490981\n", + "4 15.063387 -1.080643 14.782744 14.782744" ] }, - "execution_count": 5, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" } @@ -249,12 +244,12 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ "# Note that \"true_labels\" will not be available in real-life dataset. We have added here only for comparision.\n", - "X = data[['feature_'+str(i+1) for i in range(3)]]\n", + "X = data[['feature_'+str(i+1) for i in range(2)]]\n", "y = data['lables']\n", "\n", "# initialize your favourite model and generate predictions \n", @@ -268,12 +263,12 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 17, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -284,12 +279,11 @@ ], "source": [ "plot_data(\n", - " data[['feature_1','lables']], \n", + " data[['feature_1','feature_2']], \n", " circles=true_errors ,\n", " color=label_quality, \n", " title=\"Messy Regression dataset with label quality scores\", \n", - " colorbar=True, \n", - " xlabel = \"feature_1\")" + " colorbar=True)" ] }, { @@ -297,7 +291,8 @@ "metadata": {}, "source": [ "In the above plot, we have colored each datapoint considering its label quality score. \\\n", - "Datapoints in the plot are same as earlier plot in the notebook. **Red circle** represents that these datapoint were incorrectly marked when compared to true_label. \n", + "Datapoints in the plot are same as earlier plot in the notebook. \\\n", + "**Red circle** represents that these datapoint were incorrectly marked when compared to true_label. \n", "\n", "Low scores for datapoints marked in **Red circle** and High scores for other datapoints justifies that method can identify the errors in the dataset. " ] From 0eac77616732ceefd2d4e66c4f30a97d57459b43 Mon Sep 17 00:00:00 2001 From: krmayankb Date: Wed, 7 Dec 2022 22:30:18 -0700 Subject: [PATCH 036/258] typo fix --- docs/source/tutorials/regression.ipynb | 132 ++++++++++++++++++++++--- 1 file changed, 118 insertions(+), 14 deletions(-) diff --git a/docs/source/tutorials/regression.ipynb b/docs/source/tutorials/regression.ipynb index 92bc78ff13..b4770e47d1 100644 --- a/docs/source/tutorials/regression.ipynb +++ b/docs/source/tutorials/regression.ipynb @@ -30,7 +30,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -43,7 +43,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 21, "metadata": {}, "outputs": [], "source": [ @@ -72,7 +72,7 @@ " labels = true_labels + np.random.choice(error, feature_size[0], p=prob_error)\n", " \n", " data_dict = {\n", - " \"lables\" : labels, # You have these labels, which have some errors.\n", + " \"labels\" : labels, # You have these labels, which have some errors.\n", " \"true_labels\" : true_labels, # You never get to see these perfect labels.\n", " } \n", " for idx, feature in enumerate(features): # adding names to each features \n", @@ -111,7 +111,111 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 22, + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
exam_1exam_2exam_3bonus_or_penaltytrue_labelslabels
0537793076.256.2
18164801085.565.5
2748897087.467.4
3619478077.757.7
4489091077.877.8
\n", + "
" + ], + "text/plain": [ + " exam_1 exam_2 exam_3 bonus_or_penalty true_labels labels\n", + "0 53 77 93 0 76.2 56.2\n", + "1 81 64 80 10 85.5 65.5\n", + "2 74 88 97 0 87.4 67.4\n", + "3 61 94 78 0 77.7 57.7\n", + "4 48 90 91 0 77.8 77.8" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "path = \"/Users/krmayank/Desktop/Work/cleanlab/experiments/student_score_regression.csv\"\n", + "data = pd.read_csv(path, index_col=0)\n", + "data.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 23, "metadata": {}, "outputs": [ { @@ -127,10 +231,10 @@ ], "source": [ "data = make_data(feature_size=(100, 2))\n", - "true_errors = np.where(data['true_labels'] != data['lables'])[0]\n", + "true_errors = np.where(data['true_labels'] != data['labels'])[0]\n", "plot_data(data[['feature_1','feature_2']], \n", " circles=true_errors, \n", - " color=data['lables'], \n", + " color=data['labels'], \n", " colorbar=True, \n", " title=\"Messy Regression dataset\")" ] @@ -153,7 +257,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 24, "metadata": {}, "outputs": [ { @@ -179,7 +283,7 @@ " \n", " feature_1\n", " feature_2\n", - " lables\n", + " labels\n", " true_labels\n", " \n", " \n", @@ -224,7 +328,7 @@ "" ], "text/plain": [ - " feature_1 feature_2 lables true_labels\n", + " feature_1 feature_2 labels true_labels\n", "0 17.986857 -1.707685 19.079171 17.079171\n", "1 15.446943 -1.210323 15.036620 15.036620\n", "2 18.590754 -1.171357 18.219397 18.219397\n", @@ -232,7 +336,7 @@ "4 15.063387 -1.080643 14.782744 14.782744" ] }, - "execution_count": 11, + "execution_count": 24, "metadata": {}, "output_type": "execute_result" } @@ -244,13 +348,13 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 25, "metadata": {}, "outputs": [], "source": [ "# Note that \"true_labels\" will not be available in real-life dataset. We have added here only for comparision.\n", "X = data[['feature_'+str(i+1) for i in range(2)]]\n", - "y = data['lables']\n", + "y = data['labels']\n", "\n", "# initialize your favourite model and generate predictions \n", "yourFavouriteModel = LinearRegression()\n", @@ -258,12 +362,12 @@ "predictions = yourFavouriteModel.predict(X)\n", "\n", "# get label quality score for each example in the dataset \n", - "label_quality = get_label_quality_scores(labels=np.array(data['lables']), pred_labels=predictions)" + "label_quality = get_label_quality_scores(labels=np.array(data['labels']), pred_labels=predictions)" ] }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 26, "metadata": {}, "outputs": [ { From 1a65c9a209b9e66d6032d80a28a666460cb82f57 Mon Sep 17 00:00:00 2001 From: krmayankb Date: Thu, 8 Dec 2022 23:03:45 -0700 Subject: [PATCH 037/258] cleanlab outlier based scoring method added --- cleanlab/regression/rank.py | 116 ++++++++++++++++++++++++++++++++++-- 1 file changed, 111 insertions(+), 5 deletions(-) diff --git a/cleanlab/regression/rank.py b/cleanlab/regression/rank.py index 6f8ad48323..dcd9460c64 100644 --- a/cleanlab/regression/rank.py +++ b/cleanlab/regression/rank.py @@ -1,9 +1,16 @@ import numpy as np +from cleanlab.outlier import OutOfDistribution +from sklearn.neighbors import NearestNeighbors """ Generates label quality scores for every sample in regression dataset """ -def get_label_quality_scores(labels: np.ndarray, pred_labels: np.ndarray) -> np.ndarray: +def get_label_quality_scores( + labels: np.ndarray, + pred_labels: np.ndarray, + *, + method: str = "residual", +) -> np.ndarray: """ Returns label quality score for each example in the regression dataset. @@ -13,14 +20,16 @@ def get_label_quality_scores(labels: np.ndarray, pred_labels: np.ndarray) -> np. Parameters ---------- - labels: + labels : np.ndarray Raw labels from original dataset. Array of shape ``(N, )`` consisting given labels, where N is number of datapoints in the regression dataset. - pred_labels: + pred_labels : np.ndarray Predicated labels from regressor fitted on the dataset. Array of shape ``(N,)`` consisting predicted labels, where N is number of datapoints in the regression dataset. + method : {"residual", "TO_BE_NAMED"}, default="residual" #TODO - update name once finalised + Returns ------- label_quality_scores: @@ -39,6 +48,7 @@ def get_label_quality_scores(labels: np.ndarray, pred_labels: np.ndarray) -> np. array([0.36787944, 1. , 0.13533528, 0.90483742]) """ + # TODO - add error trigger function in utils. if not isinstance(labels, np.ndarray) or not isinstance(pred_labels, np.ndarray): raise TypeError("labels and pred_labels must be of type np.ndarray") @@ -46,6 +56,102 @@ def get_label_quality_scores(labels: np.ndarray, pred_labels: np.ndarray) -> np. labels.shape == pred_labels.shape ), f"shape of label {labels.shape} and predicted labels {pred_labels.shape} are not same." + scoring_funcs = { + "residual": get_residual_score_for_each_label, + "TO_BE_NAMED": get_score_to_named_for_each_label, # TODO - update name once finalised + } + + # TODO - update name once finalised + try: + scoring_func = scoring_funcs[method] + except KeyError: + raise ValueError( + f""" + {method} is not a valid scoring method. + Please choose a valid scoring technique: residual, TO_BE_NAMED. + """ + ) + + # Calculate scores + label_quality_score = scoring_func(labels, pred_labels) + return label_quality_score + + +def get_residual_score_for_each_label( + labels: np.ndarray, + pred_labels: np.ndarray, +) -> np.ndarray: + """Returns the residual based label-quality scores for each datapoints. + + This is function to compute label-quality scores for regression datasets, + where lower score indicate labels less likely to be correct. + + Residual based scores can work better for datasets where independent variables + are based out of normal distribution. + + Parameters + ---------- + labels: np.ndarray + Labels in the same format expected by the :py:func:`get_label_quality_scores ` function. + + pred_labels: np.ndarray + Predicted labels in the same format expected by the :py:func:`get_label_quality_scores ` function. + + Returns + ------- + label_quality_scores: np.ndarray + Contains one score (between 0 and 1) per example. + Lower scores indicate more likely mislabled examples. + + """ residual = pred_labels - labels - quality_scores = np.exp(-abs(residual)) - return quality_scores + label_quality_scores = np.exp(-abs(residual)) + return label_quality_scores + + +# TODO - change name of the function +def get_score_to_named_for_each_label( + label: np.ndarray, + pred_labels: np.ndarray, + *, + variance: float = 10, +) -> np.ndarray: + """Returns label-quality scores. + + This is function to compute label-quality scores for regression datasets, + where lower score indicate labels less likely to be correct. + + Parameters + ---------- + labels: np.ndarray + Labels in the same format expected by the :py:func:`get_label_quality_scores ` function. + + pred_labels: np.ndarray + Predicted labels in the same format expected by the :py:func:`get_label_quality_scores ` function. + + variance: float, default = 10 + Manipulates variance of the distribution of residual. + + Returns + ------- + label_quality_scores: np.ndarray + Contains one score (between 0 and 1) per example. + Lower scores indicate more likely mislabled examples. + """ + + neighbors = int(np.ceil(0.1 * label.shape[0])) + print(neighbors) + knn = NearestNeighbors(n_neighbors=neighbors, metric="euclidean") + + residual = pred_labels - label + + label = (label - label.mean()) / label.std() + residual = np.sqrt(variance) * ((residual - residual.mean()) / residual.std()) + + # 2D features by combining labels and residual + features = np.array([label, residual]).T + + knn.fit(features) + ood = OutOfDistribution(params={"knn": knn}) + label_quality_scores = ood.score(features=features) + return label_quality_scores From e8a9a495a3a7d87a92dfc1963c086ccd9f44b805 Mon Sep 17 00:00:00 2001 From: krmayankb Date: Fri, 9 Dec 2022 11:25:30 -0700 Subject: [PATCH 038/258] regression_utils created --- cleanlab/internal/regression_utils.py | 28 +++++++++++++++++++++++++++ cleanlab/regression/rank.py | 10 +++------- 2 files changed, 31 insertions(+), 7 deletions(-) create mode 100644 cleanlab/internal/regression_utils.py diff --git a/cleanlab/internal/regression_utils.py b/cleanlab/internal/regression_utils.py new file mode 100644 index 0000000000..57c99baedb --- /dev/null +++ b/cleanlab/internal/regression_utils.py @@ -0,0 +1,28 @@ +""" +Helper function internally used in cleanlab.regression +""" + +import numpy as np + + +def assert_valid_inputs( + labels: np.ndarray, + pred_labels: np.ndarray, + method: str, +) -> None: + """Checks that ``labels``, ``pred_labels``, ``method`` are correctly formatted.""" + + # Check if labels and pred_labels are np.ndarray + if not isinstance(labels, np.ndarray) or not isinstance(pred_labels, np.ndarray): + raise TypeError("labels and pred_labels must be of type np.ndarray") + + # Check if labels and pred_labels are of same shape + assert ( + labels.shape == pred_labels.shape + ), f"shape of label {labels.shape} and predicted labels {pred_labels.shape} are not same." + + # Check if method passed is string + if not isinstance(method, str): + raise TypeError( + f"Passed method is not of correct type. Expected string, got {type(method)}" + ) diff --git a/cleanlab/regression/rank.py b/cleanlab/regression/rank.py index dcd9460c64..8d53af9adf 100644 --- a/cleanlab/regression/rank.py +++ b/cleanlab/regression/rank.py @@ -1,6 +1,7 @@ import numpy as np from cleanlab.outlier import OutOfDistribution from sklearn.neighbors import NearestNeighbors +from cleanlab.internal.regression_utils import assert_valid_inputs """ Generates label quality scores for every sample in regression dataset """ @@ -48,13 +49,8 @@ def get_label_quality_scores( array([0.36787944, 1. , 0.13533528, 0.90483742]) """ - # TODO - add error trigger function in utils. - if not isinstance(labels, np.ndarray) or not isinstance(pred_labels, np.ndarray): - raise TypeError("labels and pred_labels must be of type np.ndarray") - - assert ( - labels.shape == pred_labels.shape - ), f"shape of label {labels.shape} and predicted labels {pred_labels.shape} are not same." + # Check if inputs are valid + assert_valid_inputs(labels=labels, pred_labels=pred_labels, method=method) scoring_funcs = { "residual": get_residual_score_for_each_label, From 98930fcdaf3ce6592aa6d6c771b4091f55450f68 Mon Sep 17 00:00:00 2001 From: krmayankb Date: Mon, 12 Dec 2022 09:40:36 -0800 Subject: [PATCH 039/258] pred_labels changed to predictions --- cleanlab/internal/regression_utils.py | 8 ++++---- cleanlab/regression/rank.py | 25 ++++++++++++------------- 2 files changed, 16 insertions(+), 17 deletions(-) diff --git a/cleanlab/internal/regression_utils.py b/cleanlab/internal/regression_utils.py index 57c99baedb..04576c4012 100644 --- a/cleanlab/internal/regression_utils.py +++ b/cleanlab/internal/regression_utils.py @@ -7,19 +7,19 @@ def assert_valid_inputs( labels: np.ndarray, - pred_labels: np.ndarray, + predictions: np.ndarray, method: str, ) -> None: """Checks that ``labels``, ``pred_labels``, ``method`` are correctly formatted.""" # Check if labels and pred_labels are np.ndarray - if not isinstance(labels, np.ndarray) or not isinstance(pred_labels, np.ndarray): + if not isinstance(labels, np.ndarray) or not isinstance(predictions, np.ndarray): raise TypeError("labels and pred_labels must be of type np.ndarray") # Check if labels and pred_labels are of same shape assert ( - labels.shape == pred_labels.shape - ), f"shape of label {labels.shape} and predicted labels {pred_labels.shape} are not same." + labels.shape == predictions.shape + ), f"shape of label {labels.shape} and predicted labels {predictions.shape} are not same." # Check if method passed is string if not isinstance(method, str): diff --git a/cleanlab/regression/rank.py b/cleanlab/regression/rank.py index 8d53af9adf..3784d290b0 100644 --- a/cleanlab/regression/rank.py +++ b/cleanlab/regression/rank.py @@ -8,7 +8,7 @@ def get_label_quality_scores( labels: np.ndarray, - pred_labels: np.ndarray, + predictions: np.ndarray, *, method: str = "residual", ) -> np.ndarray: @@ -25,7 +25,7 @@ def get_label_quality_scores( Raw labels from original dataset. Array of shape ``(N, )`` consisting given labels, where N is number of datapoints in the regression dataset. - pred_labels : np.ndarray + predictions : np.ndarray Predicated labels from regressor fitted on the dataset. Array of shape ``(N,)`` consisting predicted labels, where N is number of datapoints in the regression dataset. @@ -43,14 +43,14 @@ def get_label_quality_scores( >>> import numpy as np >>> from cleanlab.regression.rank import get_label_quality_scores >>> labels = np.array([1,2,3,4]) - >>> pred_labels = np.array([2,2,5,4.1]) - >>> label_quality_scores = get_label_quality_scores(labels, pred_labels) + >>> predictions = np.array([2,2,5,4.1]) + >>> label_quality_scores = get_label_quality_scores(labels, predictions) >>> label_quality_scores array([0.36787944, 1. , 0.13533528, 0.90483742]) """ # Check if inputs are valid - assert_valid_inputs(labels=labels, pred_labels=pred_labels, method=method) + assert_valid_inputs(labels=labels, predictions=predictions, method=method) scoring_funcs = { "residual": get_residual_score_for_each_label, @@ -69,13 +69,13 @@ def get_label_quality_scores( ) # Calculate scores - label_quality_score = scoring_func(labels, pred_labels) + label_quality_score = scoring_func(labels, predictions) return label_quality_score def get_residual_score_for_each_label( labels: np.ndarray, - pred_labels: np.ndarray, + predictions: np.ndarray, ) -> np.ndarray: """Returns the residual based label-quality scores for each datapoints. @@ -90,7 +90,7 @@ def get_residual_score_for_each_label( labels: np.ndarray Labels in the same format expected by the :py:func:`get_label_quality_scores ` function. - pred_labels: np.ndarray + predictions: np.ndarray Predicted labels in the same format expected by the :py:func:`get_label_quality_scores ` function. Returns @@ -100,7 +100,7 @@ def get_residual_score_for_each_label( Lower scores indicate more likely mislabled examples. """ - residual = pred_labels - labels + residual = predictions - labels label_quality_scores = np.exp(-abs(residual)) return label_quality_scores @@ -108,7 +108,7 @@ def get_residual_score_for_each_label( # TODO - change name of the function def get_score_to_named_for_each_label( label: np.ndarray, - pred_labels: np.ndarray, + predictions: np.ndarray, *, variance: float = 10, ) -> np.ndarray: @@ -122,7 +122,7 @@ def get_score_to_named_for_each_label( labels: np.ndarray Labels in the same format expected by the :py:func:`get_label_quality_scores ` function. - pred_labels: np.ndarray + predictions: np.ndarray Predicted labels in the same format expected by the :py:func:`get_label_quality_scores ` function. variance: float, default = 10 @@ -136,10 +136,9 @@ def get_score_to_named_for_each_label( """ neighbors = int(np.ceil(0.1 * label.shape[0])) - print(neighbors) knn = NearestNeighbors(n_neighbors=neighbors, metric="euclidean") - residual = pred_labels - label + residual = predictions - label label = (label - label.mean()) / label.std() residual = np.sqrt(variance) * ((residual - residual.mean()) / residual.std()) From e4e6307ad555a0347eae20166f72d6bc46e5ee84 Mon Sep 17 00:00:00 2001 From: krmayankb Date: Thu, 22 Dec 2022 00:23:12 -0800 Subject: [PATCH 040/258] unit tests for new scoring method --- cleanlab/regression/rank.py | 19 ++++++++-------- tests/test_regression.py | 43 +++++++++++++++++++++++++++++++------ 2 files changed, 46 insertions(+), 16 deletions(-) diff --git a/cleanlab/regression/rank.py b/cleanlab/regression/rank.py index 3784d290b0..f53a0fb47e 100644 --- a/cleanlab/regression/rank.py +++ b/cleanlab/regression/rank.py @@ -10,7 +10,7 @@ def get_label_quality_scores( labels: np.ndarray, predictions: np.ndarray, *, - method: str = "residual", + method: str = "TO_BE_NAMED", # TODO update name once finalised ) -> np.ndarray: """ Returns label quality score for each example in the regression dataset. @@ -64,13 +64,13 @@ def get_label_quality_scores( raise ValueError( f""" {method} is not a valid scoring method. - Please choose a valid scoring technique: residual, TO_BE_NAMED. + Please choose a valid scoring technique: {scoring_funcs.keys()}. """ ) # Calculate scores - label_quality_score = scoring_func(labels, predictions) - return label_quality_score + label_quality_scores = scoring_func(labels, predictions) + return label_quality_scores def get_residual_score_for_each_label( @@ -106,8 +106,9 @@ def get_residual_score_for_each_label( # TODO - change name of the function +# TODO - change name of function in test def get_score_to_named_for_each_label( - label: np.ndarray, + labels: np.ndarray, predictions: np.ndarray, *, variance: float = 10, @@ -135,16 +136,16 @@ def get_score_to_named_for_each_label( Lower scores indicate more likely mislabled examples. """ - neighbors = int(np.ceil(0.1 * label.shape[0])) + neighbors = int(np.ceil(0.1 * labels.shape[0])) knn = NearestNeighbors(n_neighbors=neighbors, metric="euclidean") - residual = predictions - label + residual = predictions - labels - label = (label - label.mean()) / label.std() + labels = (labels - labels.mean()) / labels.std() residual = np.sqrt(variance) * ((residual - residual.mean()) / residual.std()) # 2D features by combining labels and residual - features = np.array([label, residual]).T + features = np.array([labels, residual]).T knn.fit(features) ood = OutOfDistribution(params={"knn": knn}) diff --git a/tests/test_regression.py b/tests/test_regression.py index 71de96cf3c..8a8154047c 100644 --- a/tests/test_regression.py +++ b/tests/test_regression.py @@ -2,26 +2,55 @@ import pandas as pd import pytest -from cleanlab.regression.rank import get_label_quality_scores +from cleanlab.regression import rank # To be used for all the tests labels = np.array([1, 2, 3, 4]) -pred_labels = np.array([1, 3, 4, 5]) - +predictions = np.array([1, 3, 4, 5]) +# test with deafault parameters def test_output_shape_type(): - scores = get_label_quality_scores(labels=labels, pred_labels=pred_labels) + scores = rank.get_label_quality_scores(labels=labels, predictions=predictions) assert labels.shape == scores.shape assert isinstance(scores, np.ndarray) +# test for acceptable datatypes @pytest.mark.parametrize("format", [pd.Series, pd.DataFrame, list]) def test_type_error_for_input_types(format): with pytest.raises(TypeError) as error: - _ = get_label_quality_scores(labels=format(labels), pred_labels=format(pred_labels)) + _ = rank.get_label_quality_scores(labels=format(labels), predictions=format(predictions)) +# test for input shapes def test_assertion_error_for_input_shape(): with pytest.raises(AssertionError) as error: - _ = get_label_quality_scores(labels=labels[:-1], pred_labels=pred_labels) - _ = get_label_quality_scores(labels=labels, pred_labels=pred_labels[:-1]) + _ = rank.get_label_quality_scores(labels=labels[:-1], predictions=predictions) + _ = rank.get_label_quality_scores(labels=labels, predictions=predictions[:-1]) + + +# TODO - change name once finalised +# test individual scoring functions +@pytest.mark.parametrize( + "scoring_funcs", + [rank.get_residual_score_for_each_label, rank.get_score_to_named_for_each_label], +) +def test_individual_scoring_functions(scoring_funcs): + scores = scoring_funcs(labels=labels, predictions=predictions) + assert labels.shape == scores.shape + assert isinstance(scores, np.ndarray) + + +# TODO - change name once finalised +# test for method argument +@pytest.mark.parametrize( + "method", + [ + "residual", + "TO_BE_NAMED", + ], +) +def test_method_pass_get_label_quality_scores(method): + scores = rank.get_label_quality_scores(labels=labels, predictions=predictions, method=method) + assert labels.shape == scores.shape + assert isinstance(scores, np.ndarray) From af2454b06f2c0198b598f55fc231f13c00ef8cfc Mon Sep 17 00:00:00 2001 From: krmayankb Date: Fri, 23 Dec 2022 12:46:08 -0800 Subject: [PATCH 041/258] init merge conflict resolved --- cleanlab/__init__.py | 1 + 1 file changed, 1 insertion(+) diff --git a/cleanlab/__init__.py b/cleanlab/__init__.py index 753e47e82a..fffef7d53e 100644 --- a/cleanlab/__init__.py +++ b/cleanlab/__init__.py @@ -8,5 +8,6 @@ from . import multiannotator from . import outlier from . import token_classification + from . import multilabel_classification from . import regression From be8afaaca28fc1302e5c4bb0a16b14cc7068c6d6 Mon Sep 17 00:00:00 2001 From: krmayankb Date: Thu, 22 Dec 2022 01:15:43 -0800 Subject: [PATCH 042/258] tutorial draft1 --- docs/source/tutorials/regression.ipynb | 476 ++++++++++++++----------- 1 file changed, 268 insertions(+), 208 deletions(-) diff --git a/docs/source/tutorials/regression.ipynb b/docs/source/tutorials/regression.ipynb index b4770e47d1..682a81ffb2 100644 --- a/docs/source/tutorials/regression.ipynb +++ b/docs/source/tutorials/regression.ipynb @@ -1,117 +1,215 @@ { "cells": [ { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ - "# Label Quality Scores for Regression with Noisy Labels\n", - "In this tutorial, you will learn how to use cleanlab on regression dataset to: \n", - "- find label issue in your regression dataset\n", - "- generate label quality scores for each example in the dataset. " + "# Label Quality Scores for Regression with Noisy Labels " ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ - "## Install dependencies and import them \n", - "You can use pip to install all packages required for this tutorial as follows:" + "This quickstart tutorial shows how to use cleanlab for finding label errors in regression data. Using the approach mentioned here, you can find label error in any regression dataset irrespective of modality i.e., tabular, text, image etc. \n", + "\n", + "**This example will take you through following:**\n", + "- Generate label quality scores for each datapoint in the dataset. \n", + "- Find label issue for regression dataset. " ] }, { - "cell_type": "code", - "execution_count": null, + "attachments": {}, + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ - "!pip install cleanlab\n", - "!pip install scikit-learn" + "Quickstart \n", + "\n", + "Cleanlab uses two inputs to generates scores for labels in the dataset:\n", + "- `labels`: NumPy array of given labels in the dataset. labels[i] should contain label for `i`-th datapoint. \n", + "- `predictions`: NumPy array of predictions generated through your favourite regressor. predictions[i] should contain predicted value for `i`-th datapoint. \n", + "\n", + "If you already have predictions from your regressor, you can generate label quality scores for each datapoint using the code below: \n", + "\n", + "
\n", + "\n", + "```python \n", + "\n", + "from cleanlab.regression.rank import get_label_quality_scores\n", + "label_quality_scores = get_label_quality_scores(labels, predictions)\n", + "\n", + "```\n", + "
\n", + "" ] }, { - "cell_type": "code", - "execution_count": 1, + "attachments": {}, + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ - "import numpy as np \n", - "import pandas as pd \n", - "from cleanlab.regression.rank import get_label_quality_scores\n", - "from sklearn.linear_model import LinearRegression\n", - "import matplotlib.pyplot as plt " + "# 0. Visualization (can skip these details)" ] }, { - "cell_type": "code", - "execution_count": 21, + "attachments": {}, + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ - "def make_data(feature_size = (20, 2), \n", - " means = [8, -10], \n", - " stds = [2, 5], \n", - " bias = 0.8,\n", - " coeff = [2, 0.1],\n", - " error = [-2, 0, 2], \n", - " prob_error = [0.2, 0.6, 0.2], \n", - " seed = 42\n", - ") -> pd.DataFrame:\n", - " \"\"\"\n", - " feature_size: Tuple of (datapoints, features)\n", - " \"\"\"\n", - " assert (len(means) == feature_size[1]), (f\"length of mean {len(means)} is not same as features requested{feature_size[0]}\")\n", - " assert (len(stds) == feature_size[1]), (f\"length of stds {len(stds)} is not same as features requested{feature_size[0]}\")\n", - " np.random.seed(seed) \n", + "This is added just for reference. We will use this function to plot dataset, highlight points using label quality scores and true_errors.\n", + "You can skip this part and move to next section. " + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "
See the code for visualization **(click to expand)** \n", "\n", - " features = []\n", - " for i in range(feature_size[1]):\n", - " values = coeff[i] * np.random.normal(loc=means[i], scale=stds[i], size=feature_size[0])\n", - " features.append(values)\n", - " \n", - " true_labels = sum(map(np.array, features))+ bias\n", - " labels = true_labels + np.random.choice(error, feature_size[0], p=prob_error)\n", - " \n", - " data_dict = {\n", - " \"labels\" : labels, # You have these labels, which have some errors.\n", - " \"true_labels\" : true_labels, # You never get to see these perfect labels.\n", - " } \n", - " for idx, feature in enumerate(features): # adding names to each features \n", - " data_dict[\"feature_\"+str(idx+1)] = feature\n", - " data = pd.DataFrame.from_dict(data_dict)\n", - " col = list(data.columns)\n", - " new_col = col[2:] + col[:2]\n", - " data = data.reindex(columns=new_col)\n", - " return data\n", + "```python \n", + "# Note: this pulldown is for docs.cleanlab.ai, if running on local Jupyter or colab, please ignore it. \n", "\n", - "def plot_data(data, \n", - " circles, \n", - " title, \n", - " alpha=0.6, \n", - " color = '#1f77b4', \n", - " colorbar = False):\n", - " \n", + "def plot_data(\n", + " data_x, data_y, circles, title, alpha=0.6, color=\"#1f77b4\", colorbar=False, xlabel=\"\", ylabel=\"\"\n", + "):\n", " plt.figure(figsize=(14, 5))\n", - " data = data.to_numpy()\n", - " plt.scatter(data[:,0], data[:,1], c = color, s=60)\n", + " data_x = data_x.to_numpy()\n", + " data_y = data_y.to_numpy()\n", + " plt.scatter(data_x, data_y, c=color, s=30)\n", " for i in circles:\n", " plt.plot(\n", - " data[i][0],\n", - " data[i][1],\n", + " data_x[i],\n", + " data_y[i],\n", " \"o\",\n", " markerfacecolor=\"none\",\n", " markeredgecolor=\"red\",\n", - " markersize=14,\n", + " markersize=10,\n", " markeredgewidth=2.5,\n", - " alpha=alpha\n", + " alpha=alpha,\n", " )\n", " plt.title(title, fontsize=20)\n", - " \n", - " if colorbar: plt.colorbar(orientation = 'vertical')\n" + " plt.xlabel(xlabel)\n", + " plt.ylabel(ylabel)\n", + "\n", + " if colorbar:\n", + " plt.colorbar(orientation=\"vertical\")\n", + "\n", + "```\n", + "
" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def plot_data(\n", + " data_x, data_y, circles, title, alpha=0.6, color=\"#1f77b4\", colorbar=False, xlabel=\"\", ylabel=\"\"\n", + "):\n", + " plt.figure(figsize=(14, 5))\n", + " data_x = data_x.to_numpy()\n", + " data_y = data_y.to_numpy()\n", + " plt.scatter(data_x, data_y, c=color, s=30)\n", + " for i in circles:\n", + " plt.plot(\n", + " data_x[i],\n", + " data_y[i],\n", + " \"o\",\n", + " markerfacecolor=\"none\",\n", + " markeredgecolor=\"red\",\n", + " markersize=10,\n", + " markeredgewidth=2.5,\n", + " alpha=alpha,\n", + " )\n", + " plt.title(title, fontsize=20)\n", + " plt.xlabel(xlabel)\n", + " plt.ylabel(ylabel)\n", + "\n", + " if colorbar:\n", + " plt.colorbar(orientation=\"vertical\")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1. Install dependencies and import them \n", + "You can use `pip` to install all packages required for this tutorial as follows:\n", + "\n", + "`!pip install cleanlab xgboost`" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "!pip install cleanlab xgboost" + ] + }, + { + "cell_type": "code", + "execution_count": 94, + "metadata": { + "nbsphinx": "hidden" + }, + "outputs": [], + "source": [ + "# Package installation (hidden on docs website).\n", + "# Package versions we used: xgboost==1.7.2\n", + "\n", + "dependencies = [\"cleanlab\", \"xgboost\"]\n", + "\n", + "if \"google.colab\" in str(get_ipython()): # Check if it's running in Google Colab\n", + " %pip install cleanlab # for colab\n", + " cmd = \" \".join([dep for dep in dependencies if dep != \"cleanlab\"])\n", + " %pip install $cmd\n", + "else:\n", + " missing_dependencies = []\n", + " for dependency in dependencies:\n", + " try:\n", + " __import__(dependency)\n", + " except ImportError:\n", + " missing_dependencies.append(dependency)\n", + "\n", + " if len(missing_dependencies) > 0:\n", + " print(\"Missing required dependencies:\")\n", + " print(*missing_dependencies, sep=\", \")\n", + " print(\"\\nPlease install them before running the rest of this notebook.\")" + ] + }, + { + "cell_type": "code", + "execution_count": 95, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "from cleanlab.regression.rank import get_label_quality_scores\n", + "import xgboost as xgb\n", + "import matplotlib.pyplot as plt\n", + "\n", + "np.set_printoptions(suppress=True)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 2. Import dataset and Generate predictions" ] }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 107, "metadata": {}, "outputs": [ { @@ -138,7 +236,7 @@ " exam_1\n", " exam_2\n", " exam_3\n", - " bonus_or_penalty\n", + " notes\n", " true_labels\n", " labels\n", " \n", @@ -149,43 +247,43 @@ " 53\n", " 77\n", " 93\n", - " 0\n", + " NaN\n", + " 76.2\n", " 76.2\n", - " 56.2\n", " \n", " \n", " 1\n", " 81\n", " 64\n", " 80\n", - " 10\n", + " great participation +10\n", + " 85.5\n", " 85.5\n", - " 65.5\n", " \n", " \n", " 2\n", " 74\n", " 88\n", " 97\n", - " 0\n", + " NaN\n", + " 87.4\n", " 87.4\n", - " 67.4\n", " \n", " \n", " 3\n", " 61\n", " 94\n", " 78\n", - " 0\n", + " NaN\n", + " 77.7\n", " 77.7\n", - " 57.7\n", " \n", " \n", " 4\n", " 48\n", " 90\n", " 91\n", - " 0\n", + " NaN\n", " 77.8\n", " 77.8\n", " \n", @@ -194,15 +292,15 @@ "" ], "text/plain": [ - " exam_1 exam_2 exam_3 bonus_or_penalty true_labels labels\n", - "0 53 77 93 0 76.2 56.2\n", - "1 81 64 80 10 85.5 65.5\n", - "2 74 88 97 0 87.4 67.4\n", - "3 61 94 78 0 77.7 57.7\n", - "4 48 90 91 0 77.8 77.8" + " exam_1 exam_2 exam_3 notes true_labels labels\n", + "0 53 77 93 NaN 76.2 76.2\n", + "1 81 64 80 great participation +10 85.5 85.5\n", + "2 74 88 97 NaN 87.4 87.4\n", + "3 61 94 78 NaN 77.7 77.7\n", + "4 48 90 91 NaN 77.8 77.8" ] }, - "execution_count": 22, + "execution_count": 107, "metadata": {}, "output_type": "execute_result" } @@ -215,14 +313,14 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 108, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -230,149 +328,78 @@ } ], "source": [ - "data = make_data(feature_size=(100, 2))\n", - "true_errors = np.where(data['true_labels'] != data['labels'])[0]\n", - "plot_data(data[['feature_1','feature_2']], \n", - " circles=true_errors, \n", - " color=data['labels'], \n", - " colorbar=True, \n", - " title=\"Messy Regression dataset\")" + "# Generate true errors\n", + "true_errors = np.where(data.labels != data.true_labels)[0]\n", + "plot_data(\n", + " data_x=data[\"exam_3\"], \n", + " data_y=data[\"labels\"],\n", + " circles=true_errors,\n", + " title=\"Messy Regression dataset\",\n", + " xlabel=\"exam_3 feature\",\n", + " ylabel=\"label (Y value)\",\n", + ")" ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ - "The figure above represents a toy dataset we'll use to demonstrate label scoring for regression dataset. In this example, datapoints are ploted on 2-D space (in this case feature_1 vs feature_2). Each datapoint is colored based on given label. \n", + "In the dataframe displayed above, `labels` represents the noisy labels and `true_labels` represents the ground truth. Please note that, ground truth are usually not available in real dataset, we have added it here for comparision and to demonstrate our method. `notes` also has text information, we will model this a categorical variable. \n", "\n", - "Like many real-world datasets, the given label happen to be incorrect for some of the examples(**circled in red**) in this dataset. " + "We will use `xgboost` as regressor for this tutorial. xgboost provides easy to use interface to process categorical variable. This is demonstrated in the code below:" ] }, { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": 109, "metadata": {}, + "outputs": [], "source": [ - "## Using cleanlab to generate label quality scores" + "# XGBOOST automatically factors categorical variable, you just need to mark the columns as category\n", + "data.notes = data.notes.astype(\"category\")\n", + "\n", + "# XGBOOST takes data and label seperately, so you will need to divide data accordingly.\n", + "X = data.drop([\"labels\", \"true_labels\"], axis=1)\n", + "y = data[\"labels\"]\n", + "\n", + "# convert data to format \"DMatrix\" to make it compatible with XGBOOST.\n", + "xgboost_data = xgb.DMatrix(data=X, label=y, enable_categorical=True)\n", + "\n", + "# declare parameters and train the model.\n", + "params = {\"booster\": \"gblinear\", \"objective\": \"reg:squarederror\"}\n", + "boost = xgb.train(params=params, dtrain=xgboost_data, num_boost_round=50)" ] }, { - "cell_type": "code", - "execution_count": 24, + "attachments": {}, + "cell_type": "markdown", "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", - "
feature_1feature_2labelstrue_labels
017.986857-1.70768519.07917117.079171
115.446943-1.21032315.03662015.036620
218.590754-1.17135718.21939718.219397
322.092119-1.40113921.49098121.490981
415.063387-1.08064314.78274414.782744
\n", - "
" - ], - "text/plain": [ - " feature_1 feature_2 labels true_labels\n", - "0 17.986857 -1.707685 19.079171 17.079171\n", - "1 15.446943 -1.210323 15.036620 15.036620\n", - "2 18.590754 -1.171357 18.219397 18.219397\n", - "3 22.092119 -1.401139 21.490981 21.490981\n", - "4 15.063387 -1.080643 14.782744 14.782744" - ] - }, - "execution_count": 24, - "metadata": {}, - "output_type": "execute_result" - } - ], "source": [ - "# start with checking the dataset generated\n", - "data.head()" + "## 3. Using cleanlab to generate label quality scores" ] }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 110, "metadata": {}, "outputs": [], "source": [ - "# Note that \"true_labels\" will not be available in real-life dataset. We have added here only for comparision.\n", - "X = data[['feature_'+str(i+1) for i in range(2)]]\n", - "y = data['labels']\n", - "\n", - "# initialize your favourite model and generate predictions \n", - "yourFavouriteModel = LinearRegression()\n", - "yourFavouriteModel = yourFavouriteModel.fit(X,y)\n", - "predictions = yourFavouriteModel.predict(X)\n", + "# using trained xgboost model to get predictions\n", + "predictions = boost.predict(xgboost_data)\n", "\n", - "# get label quality score for each example in the dataset \n", - "label_quality = get_label_quality_scores(labels=np.array(data['labels']), pred_labels=predictions)" + "# get label quality score for each example in the dataset using cleanlab\n", + "label_quality_scores = get_label_quality_scores(labels=np.array(y), predictions=predictions)" ] }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 111, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -383,11 +410,15 @@ ], "source": [ "plot_data(\n", - " data[['feature_1','feature_2']], \n", - " circles=true_errors ,\n", - " color=label_quality, \n", - " title=\"Messy Regression dataset with label quality scores\", \n", - " colorbar=True)" + " data_x=data[\"exam_3\"], \n", + " data_y=data[\"labels\"],\n", + " circles=true_errors,\n", + " color=label_quality_scores,\n", + " title=\"Messy Regression dataset with label quality scores\",\n", + " colorbar=True,\n", + " xlabel=\"exam_3 feature\",\n", + " ylabel=\"label (Y value)\",\n", + ")" ] }, { @@ -402,8 +433,37 @@ ] }, { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": 112, + "metadata": { + "nbsphinx": "hidden" + }, + "outputs": [], + "source": [ + "# Note: This cell is only for docs.cleanlab.ai, if running on local Jupyter or Colab, please ignore it.\n", + "from sklearn.metrics import roc_auc_score\n", + "\n", + "label_quality_scores = get_label_quality_scores(np.array(y), predictions=predictions)\n", + "\n", + "true_errors = (data.labels != data.true_labels).astype(int)\n", + "label_quality_scores_residual = get_label_quality_scores(\n", + " np.array(y), predictions=predictions, method=\"residual\"\n", + ")\n", + "\n", + "if roc_auc_score(true_errors, 1 - label_quality_scores) < 0.5:\n", + " raise ValueError(\"Label quality scores did not perform well enough\")\n", + "\n", + "if roc_auc_score(true_errors, 1 - label_quality_scores) <= roc_auc_score(\n", + " true_errors, 1 - label_quality_scores_residual\n", + "):\n", + " raise ValueError(\"Label quality scores did not outperform alternative scores\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, "metadata": {}, + "outputs": [], "source": [] } ], From ea2f723ab24af83b6c52da3e98d24dc6dfbe0a43 Mon Sep 17 00:00:00 2001 From: krmayankb Date: Thu, 22 Dec 2022 01:16:36 -0800 Subject: [PATCH 043/258] tutorial draft1 --- docs/source/tutorials/regression.ipynb | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/source/tutorials/regression.ipynb b/docs/source/tutorials/regression.ipynb index 682a81ffb2..cc02658e80 100644 --- a/docs/source/tutorials/regression.ipynb +++ b/docs/source/tutorials/regression.ipynb @@ -331,7 +331,7 @@ "# Generate true errors\n", "true_errors = np.where(data.labels != data.true_labels)[0]\n", "plot_data(\n", - " data_x=data[\"exam_3\"], \n", + " data_x=data[\"exam_3\"],\n", " data_y=data[\"labels\"],\n", " circles=true_errors,\n", " title=\"Messy Regression dataset\",\n", @@ -410,7 +410,7 @@ ], "source": [ "plot_data(\n", - " data_x=data[\"exam_3\"], \n", + " data_x=data[\"exam_3\"],\n", " data_y=data[\"labels\"],\n", " circles=true_errors,\n", " color=label_quality_scores,\n", From f9af6ebf271d3c9f7281f12da73cb2ae68efc70c Mon Sep 17 00:00:00 2001 From: krmayankb Date: Fri, 23 Dec 2022 13:07:04 -0800 Subject: [PATCH 044/258] merge conflict --- cleanlab/__init__.py | 1 - 1 file changed, 1 deletion(-) diff --git a/cleanlab/__init__.py b/cleanlab/__init__.py index fffef7d53e..753e47e82a 100644 --- a/cleanlab/__init__.py +++ b/cleanlab/__init__.py @@ -8,6 +8,5 @@ from . import multiannotator from . import outlier from . import token_classification - from . import multilabel_classification from . import regression From 00bcf61c301d425a1fb6748ca2baaab47b25fcc0 Mon Sep 17 00:00:00 2001 From: krmayankb Date: Fri, 23 Dec 2022 14:56:32 -0800 Subject: [PATCH 045/258] default modified for method in docstring --- cleanlab/regression/rank.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cleanlab/regression/rank.py b/cleanlab/regression/rank.py index f53a0fb47e..a6176a8de3 100644 --- a/cleanlab/regression/rank.py +++ b/cleanlab/regression/rank.py @@ -29,7 +29,7 @@ def get_label_quality_scores( Predicated labels from regressor fitted on the dataset. Array of shape ``(N,)`` consisting predicted labels, where N is number of datapoints in the regression dataset. - method : {"residual", "TO_BE_NAMED"}, default="residual" #TODO - update name once finalised + method : {"residual", "TO_BE_NAMED"}, default="TO_BE_NAMED" #TODO - update name once finalised Returns ------- From 542e30f6840a0f138a0052558cfdca0f56dbd288 Mon Sep 17 00:00:00 2001 From: Mayank Kumar Date: Fri, 23 Dec 2022 15:01:21 -0800 Subject: [PATCH 046/258] grammatical correction in rank.py MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Elías Snorrason --- cleanlab/regression/rank.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cleanlab/regression/rank.py b/cleanlab/regression/rank.py index a6176a8de3..4318d664df 100644 --- a/cleanlab/regression/rank.py +++ b/cleanlab/regression/rank.py @@ -15,7 +15,7 @@ def get_label_quality_scores( """ Returns label quality score for each example in the regression dataset. - Each score is continous value in range [0,1] + Each score is a continous value in the range [0,1] 1 - clean label (given label is likely correct). 0 - dirty label (given label is likely incorrect). From 3958b583299b8be18bbd61ba2276516fe328cf0f Mon Sep 17 00:00:00 2001 From: Mayank Kumar Date: Fri, 23 Dec 2022 15:24:02 -0800 Subject: [PATCH 047/258] Update cleanlab/regression/rank.py MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Elías Snorrason --- cleanlab/regression/rank.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/cleanlab/regression/rank.py b/cleanlab/regression/rank.py index 4318d664df..dc98059253 100644 --- a/cleanlab/regression/rank.py +++ b/cleanlab/regression/rank.py @@ -115,8 +115,8 @@ def get_score_to_named_for_each_label( ) -> np.ndarray: """Returns label-quality scores. - This is function to compute label-quality scores for regression datasets, - where lower score indicate labels less likely to be correct. + This function computes label-quality scores for regression datasets, + where a lower score indicates labels that are less likely to be correct. Parameters ---------- From db0bb5d8147a204af6495e5c537aa0f226bfac33 Mon Sep 17 00:00:00 2001 From: krmayankb Date: Fri, 23 Dec 2022 16:55:11 -0800 Subject: [PATCH 048/258] =?UTF-8?q?rank.py=20updates=201.=20added=20typing?= =?UTF-8?q?=20hints=20for=20scoring=20funcs=202.=20Removed=20try-except=20?= =?UTF-8?q?block=20for=20raising=20value=20error.=203.=20grammatical=20cor?= =?UTF-8?q?rections=204.=20knn=20and=20neighbors=20construction=20moved=20?= =?UTF-8?q?closer=20to=20first=20usage.=20Co-authored-by:=20El=C3=ADas=20S?= =?UTF-8?q?norrason=20?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- cleanlab/regression/rank.py | 21 +++++++++------------ 1 file changed, 9 insertions(+), 12 deletions(-) diff --git a/cleanlab/regression/rank.py b/cleanlab/regression/rank.py index dc98059253..99c42aba3e 100644 --- a/cleanlab/regression/rank.py +++ b/cleanlab/regression/rank.py @@ -2,6 +2,7 @@ from cleanlab.outlier import OutOfDistribution from sklearn.neighbors import NearestNeighbors from cleanlab.internal.regression_utils import assert_valid_inputs +from typing import Dict, Callable """ Generates label quality scores for every sample in regression dataset """ @@ -52,15 +53,14 @@ def get_label_quality_scores( # Check if inputs are valid assert_valid_inputs(labels=labels, predictions=predictions, method=method) - scoring_funcs = { + scoring_funcs: Dict[str, Callable[[np.ndarray, np.ndarray], np.ndarray]] = { "residual": get_residual_score_for_each_label, "TO_BE_NAMED": get_score_to_named_for_each_label, # TODO - update name once finalised } # TODO - update name once finalised - try: - scoring_func = scoring_funcs[method] - except KeyError: + scoring_func = scoring_funcs.get(method, None) + if not scoring_func: raise ValueError( f""" {method} is not a valid scoring method. @@ -121,10 +121,10 @@ def get_score_to_named_for_each_label( Parameters ---------- labels: np.ndarray - Labels in the same format expected by the :py:func:`get_label_quality_scores ` function. + Labels in the same format as expected by the :py:func:`get_label_quality_scores ` function. predictions: np.ndarray - Predicted labels in the same format expected by the :py:func:`get_label_quality_scores ` function. + Predicted labels in the same format as expected by the :py:func:`get_label_quality_scores ` function. variance: float, default = 10 Manipulates variance of the distribution of residual. @@ -135,19 +135,16 @@ def get_score_to_named_for_each_label( Contains one score (between 0 and 1) per example. Lower scores indicate more likely mislabled examples. """ - - neighbors = int(np.ceil(0.1 * labels.shape[0])) - knn = NearestNeighbors(n_neighbors=neighbors, metric="euclidean") - residual = predictions - labels - labels = (labels - labels.mean()) / labels.std() residual = np.sqrt(variance) * ((residual - residual.mean()) / residual.std()) # 2D features by combining labels and residual features = np.array([labels, residual]).T - knn.fit(features) + neighbors = int(np.ceil(0.1 * labels.shape[0])) + knn = NearestNeighbors(n_neighbors=neighbors, metric="euclidean").fit(features) ood = OutOfDistribution(params={"knn": knn}) + label_quality_scores = ood.score(features=features) return label_quality_scores From 0ea2981a917fd70e8db52a8078b543c86b9edd38 Mon Sep 17 00:00:00 2001 From: krmayankb Date: Fri, 23 Dec 2022 19:15:43 -0800 Subject: [PATCH 049/258] outre: code updated for name for second method --- cleanlab/regression/rank.py | 12 +++++------- tests/test_regression.py | 6 ++---- 2 files changed, 7 insertions(+), 11 deletions(-) diff --git a/cleanlab/regression/rank.py b/cleanlab/regression/rank.py index 99c42aba3e..fe263f88ca 100644 --- a/cleanlab/regression/rank.py +++ b/cleanlab/regression/rank.py @@ -11,7 +11,7 @@ def get_label_quality_scores( labels: np.ndarray, predictions: np.ndarray, *, - method: str = "TO_BE_NAMED", # TODO update name once finalised + method: str = "outre", # TODO update name once finalised ) -> np.ndarray: """ Returns label quality score for each example in the regression dataset. @@ -30,7 +30,7 @@ def get_label_quality_scores( Predicated labels from regressor fitted on the dataset. Array of shape ``(N,)`` consisting predicted labels, where N is number of datapoints in the regression dataset. - method : {"residual", "TO_BE_NAMED"}, default="TO_BE_NAMED" #TODO - update name once finalised + method : {"residual", "outre"}, default="outre" Returns ------- @@ -55,10 +55,9 @@ def get_label_quality_scores( scoring_funcs: Dict[str, Callable[[np.ndarray, np.ndarray], np.ndarray]] = { "residual": get_residual_score_for_each_label, - "TO_BE_NAMED": get_score_to_named_for_each_label, # TODO - update name once finalised + "outre": get_outre_score_for_each_label, } - # TODO - update name once finalised scoring_func = scoring_funcs.get(method, None) if not scoring_func: raise ValueError( @@ -105,15 +104,14 @@ def get_residual_score_for_each_label( return label_quality_scores -# TODO - change name of the function # TODO - change name of function in test -def get_score_to_named_for_each_label( +def get_outre_score_for_each_label( labels: np.ndarray, predictions: np.ndarray, *, variance: float = 10, ) -> np.ndarray: - """Returns label-quality scores. + """Returns OUTRE based label-quality scores. This function computes label-quality scores for regression datasets, where a lower score indicates labels that are less likely to be correct. diff --git a/tests/test_regression.py b/tests/test_regression.py index 8a8154047c..dc29315f96 100644 --- a/tests/test_regression.py +++ b/tests/test_regression.py @@ -29,11 +29,10 @@ def test_assertion_error_for_input_shape(): _ = rank.get_label_quality_scores(labels=labels, predictions=predictions[:-1]) -# TODO - change name once finalised # test individual scoring functions @pytest.mark.parametrize( "scoring_funcs", - [rank.get_residual_score_for_each_label, rank.get_score_to_named_for_each_label], + [rank.get_residual_score_for_each_label, rank.get_outre_score_for_each_label], ) def test_individual_scoring_functions(scoring_funcs): scores = scoring_funcs(labels=labels, predictions=predictions) @@ -41,13 +40,12 @@ def test_individual_scoring_functions(scoring_funcs): assert isinstance(scores, np.ndarray) -# TODO - change name once finalised # test for method argument @pytest.mark.parametrize( "method", [ "residual", - "TO_BE_NAMED", + "outre", ], ) def test_method_pass_get_label_quality_scores(method): From 9ab2092af94779c13a8745112f47d827f89b96de Mon Sep 17 00:00:00 2001 From: krmayankb Date: Fri, 23 Dec 2022 22:42:56 -0800 Subject: [PATCH 050/258] Support for array_like labels and predictions --- cleanlab/internal/regression_utils.py | 26 +++++++++++----- cleanlab/regression/rank.py | 43 ++++++++++++++++++--------- 2 files changed, 48 insertions(+), 21 deletions(-) diff --git a/cleanlab/internal/regression_utils.py b/cleanlab/internal/regression_utils.py index 04576c4012..a62e85aca5 100644 --- a/cleanlab/internal/regression_utils.py +++ b/cleanlab/internal/regression_utils.py @@ -10,19 +10,31 @@ def assert_valid_inputs( predictions: np.ndarray, method: str, ) -> None: - """Checks that ``labels``, ``pred_labels``, ``method`` are correctly formatted.""" + """Checks that ``labels``, ``predictions``, ``method`` are correctly formatted.""" # Check if labels and pred_labels are np.ndarray if not isinstance(labels, np.ndarray) or not isinstance(predictions, np.ndarray): - raise TypeError("labels and pred_labels must be of type np.ndarray") + raise TypeError("labels and predictions must be of type np.ndarray") - # Check if labels and pred_labels are of same shape + # Check if labels and predictions are of same shape assert ( labels.shape == predictions.shape ), f"shape of label {labels.shape} and predicted labels {predictions.shape} are not same." - # Check if method passed is string - if not isinstance(method, str): - raise TypeError( - f"Passed method is not of correct type. Expected string, got {type(method)}" + # Check if method is among allowed scoring method + scoring_methods = ["residual", "outre"] + if method not in scoring_methods: + raise ValueError( + f"Passed method is not among allowed method. Expected either of {scoring_methods}, got {method}" + ) + + +def check_dimensions(labels: np.ndarray, predictions: np.ndarray) -> None: + if labels.ndim != 1: + raise ValueError( + f"labels have dimensions {labels.ndim}, Expected 1-D array as input for labels" + ) + if predictions.ndim != 1: + raise ValueError( + f"predictions have dimensions {labels.ndim}, Expected 1-D array as input for predictions" ) diff --git a/cleanlab/regression/rank.py b/cleanlab/regression/rank.py index fe263f88ca..c6250ae4af 100644 --- a/cleanlab/regression/rank.py +++ b/cleanlab/regression/rank.py @@ -1,17 +1,20 @@ import numpy as np from cleanlab.outlier import OutOfDistribution from sklearn.neighbors import NearestNeighbors -from cleanlab.internal.regression_utils import assert_valid_inputs -from typing import Dict, Callable +from cleanlab.internal.regression_utils import assert_valid_inputs, check_dimensions +from typing import Dict, Callable, Optional +from cleanlab.typing import LabelLike """ Generates label quality scores for every sample in regression dataset """ +EPS = 1e-30 + def get_label_quality_scores( - labels: np.ndarray, - predictions: np.ndarray, + labels: Optional[LabelLike], + predictions: Optional[LabelLike], *, - method: str = "outre", # TODO update name once finalised + method: str = "outre", ) -> np.ndarray: """ Returns label quality score for each example in the regression dataset. @@ -22,7 +25,7 @@ def get_label_quality_scores( Parameters ---------- - labels : np.ndarray + labels : array_like Raw labels from original dataset. Array of shape ``(N, )`` consisting given labels, where N is number of datapoints in the regression dataset. @@ -53,6 +56,11 @@ def get_label_quality_scores( # Check if inputs are valid assert_valid_inputs(labels=labels, predictions=predictions, method=method) + # Convert to numpy array and check if they are 1-D array. + labels = np.asarray(labels) + predictions = np.asarray(predictions) + check_dimensions(labels, predictions) + scoring_funcs: Dict[str, Callable[[np.ndarray, np.ndarray], np.ndarray]] = { "residual": get_residual_score_for_each_label, "outre": get_outre_score_for_each_label, @@ -104,12 +112,13 @@ def get_residual_score_for_each_label( return label_quality_scores -# TODO - change name of function in test def get_outre_score_for_each_label( labels: np.ndarray, predictions: np.ndarray, *, - variance: float = 10, + residual_scale: float = 10, + frac_neighbors: float = 0.1, + neighbor_metric: str = "euclidean", ) -> np.ndarray: """Returns OUTRE based label-quality scores. @@ -124,8 +133,14 @@ def get_outre_score_for_each_label( predictions: np.ndarray Predicted labels in the same format as expected by the :py:func:`get_label_quality_scores ` function. - variance: float, default = 10 - Manipulates variance of the distribution of residual. + residual_scale: float, default = 10 + Manipulates scale of the distribution of residual. + + frac_neighbors: float, default = 0.1 + Fraction of datapoints that should be considered as n_neighbors to NearestNeighbors. + + neighbor_metric: str, default = "euclidean" + The parameter is passed to sklearn NearestNeighbors. # TODO add reference to sklearn.NearestNeighbor? Returns ------- @@ -134,14 +149,14 @@ def get_outre_score_for_each_label( Lower scores indicate more likely mislabled examples. """ residual = predictions - labels - labels = (labels - labels.mean()) / labels.std() - residual = np.sqrt(variance) * ((residual - residual.mean()) / residual.std()) + labels = (labels - labels.mean()) / (labels.std() + EPS) + residual = residual_scale * ((residual - residual.mean()) / (residual.std() + EPS)) # 2D features by combining labels and residual features = np.array([labels, residual]).T - neighbors = int(np.ceil(0.1 * labels.shape[0])) - knn = NearestNeighbors(n_neighbors=neighbors, metric="euclidean").fit(features) + neighbors = int(np.ceil(frac_neighbors * labels.shape[0])) + knn = NearestNeighbors(n_neighbors=neighbors, metric=neighbor_metric).fit(features) ood = OutOfDistribution(params={"knn": knn}) label_quality_scores = ood.score(features=features) From c078d67e3ed340e14669cf079076074e393a3b25 Mon Sep 17 00:00:00 2001 From: Mayank Kumar Date: Fri, 23 Dec 2022 22:21:46 -0800 Subject: [PATCH 051/258] Apply Docstring suggestions from code review Co-authored-by: Jonas Mueller <1390638+jwmueller@users.noreply.github.com> --- cleanlab/regression/rank.py | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/cleanlab/regression/rank.py b/cleanlab/regression/rank.py index c6250ae4af..e0efe5521c 100644 --- a/cleanlab/regression/rank.py +++ b/cleanlab/regression/rank.py @@ -27,11 +27,10 @@ def get_label_quality_scores( ---------- labels : array_like Raw labels from original dataset. - Array of shape ``(N, )`` consisting given labels, where N is number of datapoints in the regression dataset. + 1D array of shape ``(N, )`` containing the given labels for each example (aka. Y-value, response, target, dependent variable, ...), where N is number of examples in the dataset. predictions : np.ndarray - Predicated labels from regressor fitted on the dataset. - Array of shape ``(N,)`` consisting predicted labels, where N is number of datapoints in the regression dataset. + 1D array of shape ``(N,)`` containing the predicted label for each example in the dataset. These should be out-of-sample predictions from a trained regression model, which you can obtain for every example in your dataset via :ref:`cross-validation `. method : {"residual", "outre"}, default="outre" @@ -40,7 +39,7 @@ def get_label_quality_scores( label_quality_scores: Array of shape ``(N, )`` of scores between 0 and 1, one per datapoint in the dataset. - Lower scores indicate datapoint more likely to contain a label issue. + Lower scores indicate datapoints more likely to contain a label issue. Examples -------- @@ -84,7 +83,7 @@ def get_residual_score_for_each_label( labels: np.ndarray, predictions: np.ndarray, ) -> np.ndarray: - """Returns the residual based label-quality scores for each datapoints. + """Returns a residual label-quality score for each datapoint. This is function to compute label-quality scores for regression datasets, where lower score indicate labels less likely to be correct. From d1518da1172be6e174d372c29f6b9af595df12c8 Mon Sep 17 00:00:00 2001 From: krmayankb Date: Fri, 23 Dec 2022 23:13:07 -0800 Subject: [PATCH 052/258] doctring for method modified --- cleanlab/regression/rank.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/cleanlab/regression/rank.py b/cleanlab/regression/rank.py index e0efe5521c..d57cd5ffec 100644 --- a/cleanlab/regression/rank.py +++ b/cleanlab/regression/rank.py @@ -27,12 +27,13 @@ def get_label_quality_scores( ---------- labels : array_like Raw labels from original dataset. - 1D array of shape ``(N, )`` containing the given labels for each example (aka. Y-value, response, target, dependent variable, ...), where N is number of examples in the dataset. + 1D array of shape ``(N, )`` containing the given labels for each example (aka. Y-value, response, target, dependent variable, ...), where N is number of examples in the dataset. predictions : np.ndarray 1D array of shape ``(N,)`` containing the predicted label for each example in the dataset. These should be out-of-sample predictions from a trained regression model, which you can obtain for every example in your dataset via :ref:`cross-validation `. method : {"residual", "outre"}, default="outre" + String specifying which method to use for scoring the quality of each label and identifying which labels appear most noisy. Returns ------- From a819fe4fcbab3268ebd6e8c46fad2b22ce9b60da Mon Sep 17 00:00:00 2001 From: krmayankb Date: Fri, 23 Dec 2022 23:17:38 -0800 Subject: [PATCH 053/258] datapoint -> example --- cleanlab/regression/rank.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/cleanlab/regression/rank.py b/cleanlab/regression/rank.py index d57cd5ffec..6ebe33af64 100644 --- a/cleanlab/regression/rank.py +++ b/cleanlab/regression/rank.py @@ -38,9 +38,9 @@ def get_label_quality_scores( Returns ------- label_quality_scores: - Array of shape ``(N, )`` of scores between 0 and 1, one per datapoint in the dataset. + Array of shape ``(N, )`` of scores between 0 and 1, one per example in the dataset. - Lower scores indicate datapoints more likely to contain a label issue. + Lower scores indicate examples more likely to contain a label issue. Examples -------- @@ -84,7 +84,7 @@ def get_residual_score_for_each_label( labels: np.ndarray, predictions: np.ndarray, ) -> np.ndarray: - """Returns a residual label-quality score for each datapoint. + """Returns a residual label-quality score for each example. This is function to compute label-quality scores for regression datasets, where lower score indicate labels less likely to be correct. @@ -137,7 +137,7 @@ def get_outre_score_for_each_label( Manipulates scale of the distribution of residual. frac_neighbors: float, default = 0.1 - Fraction of datapoints that should be considered as n_neighbors to NearestNeighbors. + Fraction of examples that should be considered as n_neighbors to NearestNeighbors. neighbor_metric: str, default = "euclidean" The parameter is passed to sklearn NearestNeighbors. # TODO add reference to sklearn.NearestNeighbor? From ac52da7294cfde7c47ca17760f85a19a5a8e9953 Mon Sep 17 00:00:00 2001 From: krmayankb Date: Sat, 24 Dec 2022 02:27:34 -0800 Subject: [PATCH 054/258] check_valid_inputs update 1. added support for list, np.ndarray, pd.Series, pd.DataFrame 2. check if inputs are numeric --- cleanlab/internal/regression_utils.py | 64 +++++++++++++++++++++++---- 1 file changed, 55 insertions(+), 9 deletions(-) diff --git a/cleanlab/internal/regression_utils.py b/cleanlab/internal/regression_utils.py index a62e85aca5..a7bfb4bbd1 100644 --- a/cleanlab/internal/regression_utils.py +++ b/cleanlab/internal/regression_utils.py @@ -3,23 +3,35 @@ """ import numpy as np +import pandas as pd +from pandas.api.types import is_numeric_dtype +from cleanlab.typing import LabelLike +from typing import Optional def assert_valid_inputs( - labels: np.ndarray, - predictions: np.ndarray, + labels: Optional[LabelLike], + predictions: Optional[LabelLike], method: str, ) -> None: """Checks that ``labels``, ``predictions``, ``method`` are correctly formatted.""" - # Check if labels and pred_labels are np.ndarray - if not isinstance(labels, np.ndarray) or not isinstance(predictions, np.ndarray): - raise TypeError("labels and predictions must be of type np.ndarray") + supported_types = (list, np.ndarray, pd.Series, pd.DataFrame) - # Check if labels and predictions are of same shape - assert ( - labels.shape == predictions.shape - ), f"shape of label {labels.shape} and predicted labels {predictions.shape} are not same." + # Check if labels and predictions are of supported types + if not isinstance(labels, supported_types) and not isinstance(predictions, supported_types): + raise TypeError( + f"Expected labels and predictions to be either of {supported_types}, Got labels of type {type(labels)}, and predictions of type {type(predictions)}", + ) + + # check if labels and predictions are 1-D and numeric + check_dimension_and_datatype(check_input=labels, text = "labels") + check_dimension_and_datatype(check_input=predictions, text = "predictions") + + # check if number of examples are same. + assert len(labels) == len( + predictions + ), f"Length of labels {len(labels)} and predictions {len(predictions)} are not same." # Check if method is among allowed scoring method scoring_methods = ["residual", "outre"] @@ -29,6 +41,40 @@ def assert_valid_inputs( ) +def check_dimension_and_datatype(check_input: Optional[LabelLike], text : str): + # check if input is empty + if not len(check_input): + raise ValueError( + f"{text} is Empty, check input." + ) + + if isinstance(check_input, list): + if isinstance(check_input[0], list): + raise ValueError(f"{text} must be 1-D. List of List is not supported.") + elif not all(isinstance(x, (int, float)) for x in check_input): + raise ValueError( + f"All element of {text} must be of type numeric i.e., integer or float" + ) + + elif isinstance(check_input, pd.DataFrame): + if check_input.shape[1] != 1: + raise ValueError( + f"{text} must be 1-D. For DataFrame, second dimension must be 1, got {check_input.shape}." + ) + elif check_input.shape[1] == 1: + if not is_numeric_dtype(check_input): + raise ValueError(f"{text} must be 1-D and numeric type. got {check_input.dtype}.") + elif isinstance(check_input, (np.ndarray, pd.Series)): + if len(check_input.shape) != 1: + raise ValueError(f"{text} must be 1-D {type(check_input)}, got {check_input.shape}") + elif len(check_input.shape) == 1: + if isinstance(check_input, pd.Series) and not is_numeric_dtype(check_input): + raise ValueError(f"{text} must be 1-D and numeric type. got {check_input.dtype}.") + elif isinstance(check_input, np.ndarray): + if not all(isinstance(x, (int, float)) for x in check_input.tolist()): + raise ValueError(f"{text} must be 1-d and numeric type i.e., integer or float.") + + def check_dimensions(labels: np.ndarray, predictions: np.ndarray) -> None: if labels.ndim != 1: raise ValueError( From 8394ee16d6510f534592d0e918f06abe39ac75f4 Mon Sep 17 00:00:00 2001 From: krmayankb Date: Tue, 27 Dec 2022 15:51:12 -0800 Subject: [PATCH 055/258] tutorial removed --- docs/source/tutorials/index.rst | 1 - docs/source/tutorials/regression.ipynb | 497 ------------------------- 2 files changed, 498 deletions(-) delete mode 100644 docs/source/tutorials/regression.ipynb diff --git a/docs/source/tutorials/index.rst b/docs/source/tutorials/index.rst index 78e4efac5f..d040963629 100644 --- a/docs/source/tutorials/index.rst +++ b/docs/source/tutorials/index.rst @@ -14,7 +14,6 @@ Tutorials multiannotator multilabel_classification token_classification - regression pred_probs_cross_val faq diff --git a/docs/source/tutorials/regression.ipynb b/docs/source/tutorials/regression.ipynb deleted file mode 100644 index cc02658e80..0000000000 --- a/docs/source/tutorials/regression.ipynb +++ /dev/null @@ -1,497 +0,0 @@ -{ - "cells": [ - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Label Quality Scores for Regression with Noisy Labels " - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "This quickstart tutorial shows how to use cleanlab for finding label errors in regression data. Using the approach mentioned here, you can find label error in any regression dataset irrespective of modality i.e., tabular, text, image etc. \n", - "\n", - "**This example will take you through following:**\n", - "- Generate label quality scores for each datapoint in the dataset. \n", - "- Find label issue for regression dataset. " - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Quickstart \n", - "\n", - "Cleanlab uses two inputs to generates scores for labels in the dataset:\n", - "- `labels`: NumPy array of given labels in the dataset. labels[i] should contain label for `i`-th datapoint. \n", - "- `predictions`: NumPy array of predictions generated through your favourite regressor. predictions[i] should contain predicted value for `i`-th datapoint. \n", - "\n", - "If you already have predictions from your regressor, you can generate label quality scores for each datapoint using the code below: \n", - "\n", - "
\n", - "\n", - "```python \n", - "\n", - "from cleanlab.regression.rank import get_label_quality_scores\n", - "label_quality_scores = get_label_quality_scores(labels, predictions)\n", - "\n", - "```\n", - "
\n", - "" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# 0. Visualization (can skip these details)" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "This is added just for reference. We will use this function to plot dataset, highlight points using label quality scores and true_errors.\n", - "You can skip this part and move to next section. " - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "
See the code for visualization **(click to expand)** \n", - "\n", - "```python \n", - "# Note: this pulldown is for docs.cleanlab.ai, if running on local Jupyter or colab, please ignore it. \n", - "\n", - "def plot_data(\n", - " data_x, data_y, circles, title, alpha=0.6, color=\"#1f77b4\", colorbar=False, xlabel=\"\", ylabel=\"\"\n", - "):\n", - " plt.figure(figsize=(14, 5))\n", - " data_x = data_x.to_numpy()\n", - " data_y = data_y.to_numpy()\n", - " plt.scatter(data_x, data_y, c=color, s=30)\n", - " for i in circles:\n", - " plt.plot(\n", - " data_x[i],\n", - " data_y[i],\n", - " \"o\",\n", - " markerfacecolor=\"none\",\n", - " markeredgecolor=\"red\",\n", - " markersize=10,\n", - " markeredgewidth=2.5,\n", - " alpha=alpha,\n", - " )\n", - " plt.title(title, fontsize=20)\n", - " plt.xlabel(xlabel)\n", - " plt.ylabel(ylabel)\n", - "\n", - " if colorbar:\n", - " plt.colorbar(orientation=\"vertical\")\n", - "\n", - "```\n", - "
" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "def plot_data(\n", - " data_x, data_y, circles, title, alpha=0.6, color=\"#1f77b4\", colorbar=False, xlabel=\"\", ylabel=\"\"\n", - "):\n", - " plt.figure(figsize=(14, 5))\n", - " data_x = data_x.to_numpy()\n", - " data_y = data_y.to_numpy()\n", - " plt.scatter(data_x, data_y, c=color, s=30)\n", - " for i in circles:\n", - " plt.plot(\n", - " data_x[i],\n", - " data_y[i],\n", - " \"o\",\n", - " markerfacecolor=\"none\",\n", - " markeredgecolor=\"red\",\n", - " markersize=10,\n", - " markeredgewidth=2.5,\n", - " alpha=alpha,\n", - " )\n", - " plt.title(title, fontsize=20)\n", - " plt.xlabel(xlabel)\n", - " plt.ylabel(ylabel)\n", - "\n", - " if colorbar:\n", - " plt.colorbar(orientation=\"vertical\")" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 1. Install dependencies and import them \n", - "You can use `pip` to install all packages required for this tutorial as follows:\n", - "\n", - "`!pip install cleanlab xgboost`" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "!pip install cleanlab xgboost" - ] - }, - { - "cell_type": "code", - "execution_count": 94, - "metadata": { - "nbsphinx": "hidden" - }, - "outputs": [], - "source": [ - "# Package installation (hidden on docs website).\n", - "# Package versions we used: xgboost==1.7.2\n", - "\n", - "dependencies = [\"cleanlab\", \"xgboost\"]\n", - "\n", - "if \"google.colab\" in str(get_ipython()): # Check if it's running in Google Colab\n", - " %pip install cleanlab # for colab\n", - " cmd = \" \".join([dep for dep in dependencies if dep != \"cleanlab\"])\n", - " %pip install $cmd\n", - "else:\n", - " missing_dependencies = []\n", - " for dependency in dependencies:\n", - " try:\n", - " __import__(dependency)\n", - " except ImportError:\n", - " missing_dependencies.append(dependency)\n", - "\n", - " if len(missing_dependencies) > 0:\n", - " print(\"Missing required dependencies:\")\n", - " print(*missing_dependencies, sep=\", \")\n", - " print(\"\\nPlease install them before running the rest of this notebook.\")" - ] - }, - { - "cell_type": "code", - "execution_count": 95, - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np\n", - "import pandas as pd\n", - "from cleanlab.regression.rank import get_label_quality_scores\n", - "import xgboost as xgb\n", - "import matplotlib.pyplot as plt\n", - "\n", - "np.set_printoptions(suppress=True)" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# 2. Import dataset and Generate predictions" - ] - }, - { - "cell_type": "code", - "execution_count": 107, - "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", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
exam_1exam_2exam_3notestrue_labelslabels
0537793NaN76.276.2
1816480great participation +1085.585.5
2748897NaN87.487.4
3619478NaN77.777.7
4489091NaN77.877.8
\n", - "
" - ], - "text/plain": [ - " exam_1 exam_2 exam_3 notes true_labels labels\n", - "0 53 77 93 NaN 76.2 76.2\n", - "1 81 64 80 great participation +10 85.5 85.5\n", - "2 74 88 97 NaN 87.4 87.4\n", - "3 61 94 78 NaN 77.7 77.7\n", - "4 48 90 91 NaN 77.8 77.8" - ] - }, - "execution_count": 107, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "path = \"/Users/krmayank/Desktop/Work/cleanlab/experiments/student_score_regression.csv\"\n", - "data = pd.read_csv(path, index_col=0)\n", - "data.head()" - ] - }, - { - "cell_type": "code", - "execution_count": 108, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Generate true errors\n", - "true_errors = np.where(data.labels != data.true_labels)[0]\n", - "plot_data(\n", - " data_x=data[\"exam_3\"],\n", - " data_y=data[\"labels\"],\n", - " circles=true_errors,\n", - " title=\"Messy Regression dataset\",\n", - " xlabel=\"exam_3 feature\",\n", - " ylabel=\"label (Y value)\",\n", - ")" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "In the dataframe displayed above, `labels` represents the noisy labels and `true_labels` represents the ground truth. Please note that, ground truth are usually not available in real dataset, we have added it here for comparision and to demonstrate our method. `notes` also has text information, we will model this a categorical variable. \n", - "\n", - "We will use `xgboost` as regressor for this tutorial. xgboost provides easy to use interface to process categorical variable. This is demonstrated in the code below:" - ] - }, - { - "cell_type": "code", - "execution_count": 109, - "metadata": {}, - "outputs": [], - "source": [ - "# XGBOOST automatically factors categorical variable, you just need to mark the columns as category\n", - "data.notes = data.notes.astype(\"category\")\n", - "\n", - "# XGBOOST takes data and label seperately, so you will need to divide data accordingly.\n", - "X = data.drop([\"labels\", \"true_labels\"], axis=1)\n", - "y = data[\"labels\"]\n", - "\n", - "# convert data to format \"DMatrix\" to make it compatible with XGBOOST.\n", - "xgboost_data = xgb.DMatrix(data=X, label=y, enable_categorical=True)\n", - "\n", - "# declare parameters and train the model.\n", - "params = {\"booster\": \"gblinear\", \"objective\": \"reg:squarederror\"}\n", - "boost = xgb.train(params=params, dtrain=xgboost_data, num_boost_round=50)" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 3. Using cleanlab to generate label quality scores" - ] - }, - { - "cell_type": "code", - "execution_count": 110, - "metadata": {}, - "outputs": [], - "source": [ - "# using trained xgboost model to get predictions\n", - "predictions = boost.predict(xgboost_data)\n", - "\n", - "# get label quality score for each example in the dataset using cleanlab\n", - "label_quality_scores = get_label_quality_scores(labels=np.array(y), predictions=predictions)" - ] - }, - { - "cell_type": "code", - "execution_count": 111, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot_data(\n", - " data_x=data[\"exam_3\"],\n", - " data_y=data[\"labels\"],\n", - " circles=true_errors,\n", - " color=label_quality_scores,\n", - " title=\"Messy Regression dataset with label quality scores\",\n", - " colorbar=True,\n", - " xlabel=\"exam_3 feature\",\n", - " ylabel=\"label (Y value)\",\n", - ")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "In the above plot, we have colored each datapoint considering its label quality score. \\\n", - "Datapoints in the plot are same as earlier plot in the notebook. \\\n", - "**Red circle** represents that these datapoint were incorrectly marked when compared to true_label. \n", - "\n", - "Low scores for datapoints marked in **Red circle** and High scores for other datapoints justifies that method can identify the errors in the dataset. " - ] - }, - { - "cell_type": "code", - "execution_count": 112, - "metadata": { - "nbsphinx": "hidden" - }, - "outputs": [], - "source": [ - "# Note: This cell is only for docs.cleanlab.ai, if running on local Jupyter or Colab, please ignore it.\n", - "from sklearn.metrics import roc_auc_score\n", - "\n", - "label_quality_scores = get_label_quality_scores(np.array(y), predictions=predictions)\n", - "\n", - "true_errors = (data.labels != data.true_labels).astype(int)\n", - "label_quality_scores_residual = get_label_quality_scores(\n", - " np.array(y), predictions=predictions, method=\"residual\"\n", - ")\n", - "\n", - "if roc_auc_score(true_errors, 1 - label_quality_scores) < 0.5:\n", - " raise ValueError(\"Label quality scores did not perform well enough\")\n", - "\n", - "if roc_auc_score(true_errors, 1 - label_quality_scores) <= roc_auc_score(\n", - " true_errors, 1 - label_quality_scores_residual\n", - "):\n", - " raise ValueError(\"Label quality scores did not outperform alternative scores\")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3.10.8 ('ENV': 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.10.8" - }, - "orig_nbformat": 4, - "vscode": { - "interpreter": { - "hash": "1ed33b5e6ac3d9870092cd802185bba6fb7a8302b6022e7097221f18c33cb7b2" - } - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} From 569b2ff16377bfe8968fde74692a45e3bc161f6d Mon Sep 17 00:00:00 2001 From: krmayankb Date: Tue, 27 Dec 2022 22:45:55 -0800 Subject: [PATCH 056/258] support for array_like --- cleanlab/internal/regression_utils.py | 126 +++++++++++++------------- cleanlab/regression/rank.py | 15 +-- 2 files changed, 70 insertions(+), 71 deletions(-) diff --git a/cleanlab/internal/regression_utils.py b/cleanlab/internal/regression_utils.py index a7bfb4bbd1..4e396f2d55 100644 --- a/cleanlab/internal/regression_utils.py +++ b/cleanlab/internal/regression_utils.py @@ -3,84 +3,88 @@ """ import numpy as np -import pandas as pd -from pandas.api.types import is_numeric_dtype -from cleanlab.typing import LabelLike -from typing import Optional +from numpy.typing import ArrayLike +from typing import Tuple, Optional def assert_valid_inputs( - labels: Optional[LabelLike], - predictions: Optional[LabelLike], + labels: ArrayLike, + predictions: ArrayLike, method: str, -) -> None: +) -> Tuple[np.ndarray, np.ndarray]: """Checks that ``labels``, ``predictions``, ``method`` are correctly formatted.""" - supported_types = (list, np.ndarray, pd.Series, pd.DataFrame) + # Load array_like input as numpy array. If not raise error. + try: + labels = np.asarray(labels) + except: + raise ValueError(f"labels must be array_like.") - # Check if labels and predictions are of supported types - if not isinstance(labels, supported_types) and not isinstance(predictions, supported_types): - raise TypeError( - f"Expected labels and predictions to be either of {supported_types}, Got labels of type {type(labels)}, and predictions of type {type(predictions)}", - ) + try: + predictions = np.asarray(predictions) + except: + raise ValueError(f"predictions must be array_like.") + + # Check if labels and predictions are 1-D and numeric + valid_labels = check_dimension_and_datatype(check_input=labels, text="labels") + valid_predictions = check_dimension_and_datatype(check_input=predictions, text="predictions") - # check if labels and predictions are 1-D and numeric - check_dimension_and_datatype(check_input=labels, text = "labels") - check_dimension_and_datatype(check_input=predictions, text = "predictions") + # Check if number of examples are same. + assert ( + valid_labels.shape == valid_predictions.shape + ), f"Number of examples in labels {labels.shape} and predictions {predictions.shape} are not same." - # check if number of examples are same. - assert len(labels) == len( - predictions - ), f"Length of labels {len(labels)} and predictions {len(predictions)} are not same." + # Check if inputs have missing values + check_missing_values(valid_labels, text="labels") + check_missing_values(valid_predictions, text="predictions") # Check if method is among allowed scoring method scoring_methods = ["residual", "outre"] if method not in scoring_methods: raise ValueError( - f"Passed method is not among allowed method. Expected either of {scoring_methods}, got {method}" + f"Passed method is not among allowed methods. Expected either of {scoring_methods}, got {method}." ) + # return 1-D numpy array + return valid_labels, valid_predictions -def check_dimension_and_datatype(check_input: Optional[LabelLike], text : str): - # check if input is empty - if not len(check_input): - raise ValueError( - f"{text} is Empty, check input." - ) - if isinstance(check_input, list): - if isinstance(check_input[0], list): - raise ValueError(f"{text} must be 1-D. List of List is not supported.") - elif not all(isinstance(x, (int, float)) for x in check_input): - raise ValueError( - f"All element of {text} must be of type numeric i.e., integer or float" - ) - - elif isinstance(check_input, pd.DataFrame): - if check_input.shape[1] != 1: - raise ValueError( - f"{text} must be 1-D. For DataFrame, second dimension must be 1, got {check_input.shape}." - ) - elif check_input.shape[1] == 1: - if not is_numeric_dtype(check_input): - raise ValueError(f"{text} must be 1-D and numeric type. got {check_input.dtype}.") - elif isinstance(check_input, (np.ndarray, pd.Series)): - if len(check_input.shape) != 1: - raise ValueError(f"{text} must be 1-D {type(check_input)}, got {check_input.shape}") - elif len(check_input.shape) == 1: - if isinstance(check_input, pd.Series) and not is_numeric_dtype(check_input): - raise ValueError(f"{text} must be 1-D and numeric type. got {check_input.dtype}.") - elif isinstance(check_input, np.ndarray): - if not all(isinstance(x, (int, float)) for x in check_input.tolist()): - raise ValueError(f"{text} must be 1-d and numeric type i.e., integer or float.") - - -def check_dimensions(labels: np.ndarray, predictions: np.ndarray) -> None: - if labels.ndim != 1: - raise ValueError( - f"labels have dimensions {labels.ndim}, Expected 1-D array as input for labels" - ) - if predictions.ndim != 1: +def check_dimension_and_datatype(check_input: np.ndarray, text: str) -> np.ndarray: + """ + Raises errors related to: + 1. If input is empty + 2. If input is not 1-D + 3. If input is not numeric + + If all the checks are passed, it returns the squeezed 1-D array required by the main algorithm. + """ + + assert isinstance( + check_input, np.ndarray + ), f"{text} could not be converted to numpy array, check input." + + # Check if input is empty + if not check_input.size: + raise ValueError(f"{text} is Empty, check input.") + + # Remove axis with length one + check_input = np.squeeze(check_input) + + # Check if input is 1-D + if check_input.ndim != 1: raise ValueError( - f"predictions have dimensions {labels.ndim}, Expected 1-D array as input for predictions" + f"Expected 1-Dimensional inputs for {text}, got {check_input.ndim} dimensions." ) + + # Check if datatype is numeric + if not np.issubdtype(check_input.dtype, np.number): + raise ValueError(f"Expected {text} to be Numeric, got {check_input.dtype}.") + + return check_input + + +def check_missing_values(check_input: np.ndarray, text: str): + """Raise error if there are any missing values in Numpy array.""" + + if np.isnan(check_input).any(): + raise ValueError(f"{text} has missing values, check input.") diff --git a/cleanlab/regression/rank.py b/cleanlab/regression/rank.py index 6ebe33af64..cd6c474c93 100644 --- a/cleanlab/regression/rank.py +++ b/cleanlab/regression/rank.py @@ -1,9 +1,9 @@ import numpy as np from cleanlab.outlier import OutOfDistribution from sklearn.neighbors import NearestNeighbors -from cleanlab.internal.regression_utils import assert_valid_inputs, check_dimensions +from cleanlab.internal.regression_utils import assert_valid_inputs from typing import Dict, Callable, Optional -from cleanlab.typing import LabelLike +from numpy.typing import ArrayLike """ Generates label quality scores for every sample in regression dataset """ @@ -11,8 +11,8 @@ def get_label_quality_scores( - labels: Optional[LabelLike], - predictions: Optional[LabelLike], + labels: ArrayLike, + predictions: ArrayLike, *, method: str = "outre", ) -> np.ndarray: @@ -54,12 +54,7 @@ def get_label_quality_scores( """ # Check if inputs are valid - assert_valid_inputs(labels=labels, predictions=predictions, method=method) - - # Convert to numpy array and check if they are 1-D array. - labels = np.asarray(labels) - predictions = np.asarray(predictions) - check_dimensions(labels, predictions) + labels, predictions = assert_valid_inputs(labels=labels, predictions=predictions, method=method) scoring_funcs: Dict[str, Callable[[np.ndarray, np.ndarray], np.ndarray]] = { "residual": get_residual_score_for_each_label, From 86532b03c1c4cb46dfbf6e412fa4b474a9de4f6c Mon Sep 17 00:00:00 2001 From: krmayankb Date: Tue, 27 Dec 2022 22:47:13 -0800 Subject: [PATCH 057/258] unit tests to factor array_like --- tests/test_regression.py | 55 +++++++++++++++++++++++++++++++++------- 1 file changed, 46 insertions(+), 9 deletions(-) diff --git a/tests/test_regression.py b/tests/test_regression.py index dc29315f96..355752dee3 100644 --- a/tests/test_regression.py +++ b/tests/test_regression.py @@ -1,13 +1,25 @@ import numpy as np -import pandas as pd + +# import pandas as pd import pytest +from typing import Union, Sequence from cleanlab.regression import rank +ArrayLike = Union[np.ndarray, Sequence] + # To be used for all the tests labels = np.array([1, 2, 3, 4]) predictions = np.array([1, 3, 4, 5]) +# Inputs that are not array like +aConstant = 1 +aString = "predictions_non_array" +aDict = {"labels": [1, 2], "predictions": [2, 3]} +aSet = {1, 2, 3, 4} +aBool = True + + # test with deafault parameters def test_output_shape_type(): scores = rank.get_label_quality_scores(labels=labels, predictions=predictions) @@ -15,18 +27,43 @@ def test_output_shape_type(): assert isinstance(scores, np.ndarray) -# test for acceptable datatypes -@pytest.mark.parametrize("format", [pd.Series, pd.DataFrame, list]) -def test_type_error_for_input_types(format): - with pytest.raises(TypeError) as error: - _ = rank.get_label_quality_scores(labels=format(labels), predictions=format(predictions)) +@pytest.mark.parametrize( + "aInput", + [aConstant, aString, aDict, aSet, aBool], +) +def test_labels_are_arraylike(aInput): + with pytest.raises(ValueError) as error: + rank.get_label_quality_scores(labels=aInput, predictions=predictions) + assert error.type == ValueError + + +@pytest.mark.parametrize( + "aInput", + [aConstant, aString, aDict, aSet, aBool], +) +def test_predictionns_are_arraylike(aInput): + with pytest.raises(ValueError) as error: + rank.get_label_quality_scores(labels=labels, predictions=aInput) + assert error.type == ValueError # test for input shapes -def test_assertion_error_for_input_shape(): +def test_input_shape_labels(): + with pytest.raises(AssertionError) as error: + rank.get_label_quality_scores(labels=labels[:-1], predictions=predictions) + assert ( + str(error.value) + == f"Number of examples in labels {labels[:-1].shape} and predictions {predictions.shape} are not same." + ) + + +def test_input_shape_predictions(): with pytest.raises(AssertionError) as error: - _ = rank.get_label_quality_scores(labels=labels[:-1], predictions=predictions) - _ = rank.get_label_quality_scores(labels=labels, predictions=predictions[:-1]) + rank.get_label_quality_scores(labels=labels, predictions=predictions[:-1]) + assert ( + str(error.value) + == f"Number of examples in labels {labels.shape} and predictions {predictions[:-1].shape} are not same." + ) # test individual scoring functions From cb596a94ece1e821877f4fc31ecfd99007947c93 Mon Sep 17 00:00:00 2001 From: Mayank Kumar Date: Tue, 27 Dec 2022 23:58:51 -0800 Subject: [PATCH 058/258] Update docs/source/tutorials/index.rst Co-authored-by: Jonas Mueller <1390638+jwmueller@users.noreply.github.com> --- docs/source/tutorials/index.rst | 1 - 1 file changed, 1 deletion(-) diff --git a/docs/source/tutorials/index.rst b/docs/source/tutorials/index.rst index d040963629..e0d63a7e06 100644 --- a/docs/source/tutorials/index.rst +++ b/docs/source/tutorials/index.rst @@ -16,4 +16,3 @@ Tutorials token_classification pred_probs_cross_val faq - From 27ccc26301891f932cec2c511e941087b32e89ef Mon Sep 17 00:00:00 2001 From: krmayankb Date: Wed, 28 Dec 2022 17:15:06 -0800 Subject: [PATCH 059/258] merge master to regression --- docs/source/tutorials/student_grades.csv | 980 +++++++++++++++++++++++ 1 file changed, 980 insertions(+) create mode 100644 docs/source/tutorials/student_grades.csv diff --git a/docs/source/tutorials/student_grades.csv b/docs/source/tutorials/student_grades.csv new file mode 100644 index 0000000000..347454bb87 --- /dev/null +++ b/docs/source/tutorials/student_grades.csv @@ -0,0 +1,980 @@ +,exam_1,exam_2,exam_3,notes,true_grade,grade +0,53,77,93,,76.2,76.2 +1,81,64,80,great participation +10,85.5,85.5 +2,74,88,97,,87.4,87.4 +3,61,94,78,,77.7,77.7 +4,48,90,91,,77.8,77.8 +5,89,95,72,,84.0,84.0 +6,0,83,97,"cheated on exam, gets 0pts",63.7,63.7 +7,71,82,97,,84.7,84.7 +8,0,56,96,"cheated on exam, gets 0pts",55.2,55.2 +9,75,80,98,missed class frequently -10,75.7,75.7 +10,81,65,82,,76.6,76.6 +11,95,86,53,missed homework frequently -10,65.5,65.5 +12,89,72,98,missed homework frequently -10,77.5,77.5 +13,80,59,65,,67.7,77.7 +14,67,82,98,,83.9,83.9 +15,87,78,95,,87.5,87.5 +16,89,69,98,great participation +10,96.6,96.6 +17,53,72,46,missed class frequently -10,45.9,45.9 +18,46,84,89,missed homework frequently -10,64.6,64.6 +19,70,63,95,great participation +10,87.9,87.9 +20,63,93,94,,84.4,84.4 +21,90,75,90,missed homework frequently -10,75.5,75.5 +22,72,81,95,missed class frequently -10,73.9,73.9 +23,90,83,51,,72.3,72.3 +24,99,53,76,,76.0,76.0 +25,85,49,83,,73.4,73.4 +26,89,71,94,great final presentation +10,95.6,95.6 +27,86,80,89,,85.4,85.4 +28,75,94,79,,82.3,82.3 +29,61,95,94,,84.4,84.4 +30,74,64,91,,77.8,77.8 +31,98,92,96,,95.4,95.4 +32,95,83,78,,84.6,84.6 +33,92,63,91,missed homework frequently -10,72.9,72.9 +34,91,63,48,great participation +10,75.4,75.4 +35,69,94,95,great participation +10,96.9,96.9 +36,81,90,90,missed homework frequently -10,77.3,77.3 +37,98,69,90,,86.1,86.1 +38,82,94,99,missed class frequently -10,82.4,82.4 +39,73,57,96,,77.4,77.4 +40,98,73,86,great final presentation +10,95.7,95.7 +41,0,81,99,"cheated on exam, gets 0pts",63.9,63.9 +42,0,89,100,"cheated on exam, gets 0pts",66.7,66.7 +43,62,83,81,,75.9,75.9 +44,78,84,92,great final presentation +10,95.4,95.4 +45,79,84,92,,85.7,85.7 +46,65,69,92,missed homework frequently -10,67.0,67.0 +47,98,82,47,great final presentation +10,82.8,82.8 +48,92,0,89,"cheated on exam, gets 0pts",63.2,63.2 +49,84,46,95,,77.0,77.0 +50,95,85,98,,93.2,93.2 +51,86,88,90,great final presentation +10,98.2,98.2 +52,65,58,91,,73.3,73.3 +53,79,83,88,,83.8,83.8 +54,0,95,87,"cheated on exam, gets 0pts",63.3,63.3 +55,90,57,97,,82.9,82.9 +56,72,69,81,missed homework frequently -10,64.7,64.7 +57,70,85,96,,84.9,84.9 +58,89,59,79,missed homework frequently -10,66.0,56.0 +59,75,83,69,,75.0,75.0 +60,89,70,90,missed homework frequently -10,73.7,73.7 +61,81,85,95,,87.8,87.8 +62,76,70,73,great participation +10,83.0,83.0 +63,92,62,66,great participation +10,82.6,82.6 +64,94,98,99,,97.2,97.2 +65,96,99,96,great final presentation +10,100.0,100.0 +66,65,85,80,great participation +10,87.0,87.0 +67,90,79,85,great participation +10,94.7,94.7 +68,0,87,77,"cheated on exam, gets 0pts",56.9,56.9 +69,91,75,95,great participation +10,97.8,97.8 +70,88,77,92,,86.3,86.3 +71,86,64,96,,83.4,83.4 +72,88,67,74,,76.1,76.1 +73,76,59,65,,66.5,66.5 +74,96,68,59,great participation +10,82.8,82.8 +75,84,98,51,,75.0,75.0 +76,97,85,75,,84.6,84.6 +77,97,98,80,great final presentation +10,100.0,100.0 +78,89,74,71,,77.3,77.3 +79,72,90,93,,85.8,85.8 +80,49,0,78,"cheated on exam, gets 0pts",45.9,45.9 +81,88,93,78,great participation +10,95.5,95.5 +82,88,80,82,great participation +10,93.2,103.2 +83,75,91,68,great final presentation +10,87.0,87.0 +84,68,99,91,,86.5,86.5 +85,92,87,71,,82.1,72.1 +86,83,97,75,great final presentation +10,94.0,94.0 +87,87,100,94,,93.7,93.7 +88,86,95,77,,85.1,85.1 +89,79,0,76,"cheated on exam, gets 0pts",54.1,54.1 +90,35,100,61,great participation +10,74.9,74.9 +91,99,83,44,great final presentation +10,82.2,82.2 +92,96,77,79,missed class frequently -10,73.5,83.5 +93,78,94,81,,84.0,84.0 +94,58,76,94,great participation +10,87.8,87.8 +95,70,0,63,"cheated on exam, gets 0pts",46.2,46.2 +96,75,46,48,great participation +10,65.5,65.5 +97,77,84,95,,86.3,86.3 +98,81,56,54,,62.7,62.7 +99,76,96,78,great final presentation +10,92.8,102.8 +100,99,53,73,missed homework frequently -10,64.8,64.8 +101,93,91,84,great final presentation +10,98.8,98.8 +102,73,87,86,missed class frequently -10,72.4,72.4 +103,85,99,71,,83.6,83.6 +104,82,79,64,,73.9,73.9 +105,100,100,81,missed homework frequently -10,82.4,82.4 +106,99,87,99,great final presentation +10,100.0,100.0 +107,0,84,93,"cheated on exam, gets 0pts",62.4,62.4 +108,90,81,79,,82.9,82.9 +109,78,0,76,"cheated on exam, gets 0pts",53.8,53.8 +110,92,73,89,,85.1,85.1 +111,74,77,79,missed homework frequently -10,66.9,66.9 +112,98,93,92,,94.1,94.1 +113,87,82,56,,73.1,73.1 +114,96,56,70,,73.6,73.6 +115,85,88,27,,62.7,62.7 +116,81,89,78,missed homework frequently -10,72.2,62.2 +117,77,81,88,great participation +10,92.6,92.6 +118,78,53,96,missed homework frequently -10,67.7,67.7 +119,71,57,96,great participation +10,86.8,86.8 +120,58,97,89,great participation +10,92.1,92.1 +121,53,99,69,missed class frequently -10,63.2,73.2 +122,96,82,86,great participation +10,97.8,97.8 +123,71,90,92,great final presentation +10,95.1,95.1 +124,0,81,97,"cheated on exam, gets 0pts",63.1,63.1 +125,74,94,81,missed homework frequently -10,72.8,72.8 +126,73,73,76,missed class frequently -10,64.2,64.2 +127,0,78,80,"cheated on exam, gets 0pts",55.4,55.4 +128,86,92,86,great participation +10,97.8,97.8 +129,97,94,87,great final presentation +10,100.0,100.0 +130,92,81,97,great final presentation +10,100.0,100.0 +131,93,0,60,"cheated on exam, gets 0pts",51.9,51.9 +132,82,0,79,"cheated on exam, gets 0pts",56.2,56.2 +133,99,62,89,,83.9,83.9 +134,75,0,55,"cheated on exam, gets 0pts",44.5,44.5 +135,77,70,84,,77.7,77.7 +136,84,66,49,great final presentation +10,74.6,74.6 +137,76,81,96,,85.5,85.5 +138,68,63,96,missed class frequently -10,67.7,67.7 +139,71,54,99,missed homework frequently -10,67.1,67.1 +140,84,92,75,missed homework frequently -10,72.8,72.8 +141,90,84,97,great participation +10,100.0,110.0 +142,61,100,94,,85.9,85.9 +143,73,56,91,missed class frequently -10,65.1,65.1 +144,83,88,57,missed homework frequently -10,64.1,74.1 +145,69,77,57,great participation +10,76.6,76.6 +146,79,77,95,great participation +10,94.8,94.8 +147,0,97,90,"cheated on exam, gets 0pts",65.1,65.1 +148,58,68,75,,67.8,67.8 +149,63,82,53,,64.7,64.7 +150,76,78,70,,74.2,74.2 +151,0,82,77,"cheated on exam, gets 0pts",55.4,55.4 +152,91,79,93,great final presentation +10,98.2,98.2 +153,71,65,81,great participation +10,83.2,83.2 +154,71,0,75,"cheated on exam, gets 0pts",51.3,51.3 +155,97,57,67,great participation +10,83.0,83.0 +156,98,77,86,,86.9,86.9 +157,56,80,79,,72.4,72.4 +158,99,90,90,,92.7,92.7 +159,80,83,87,,83.7,83.7 +160,79,75,74,,75.8,75.8 +161,95,81,76,,83.2,83.2 +162,72,87,90,missed class frequently -10,73.7,73.7 +163,72,0,86,"cheated on exam, gets 0pts",56.0,66.0 +164,91,0,94,"cheated on exam, gets 0pts",64.9,64.9 +165,73,84,68,great participation +10,84.3,74.3 +166,0,96,90,"cheated on exam, gets 0pts",64.8,64.8 +167,98,89,71,missed class frequently -10,74.5,74.5 +168,93,65,96,missed class frequently -10,75.8,75.8 +169,79,91,89,missed homework frequently -10,76.6,76.6 +170,89,93,79,,86.2,86.2 +171,96,90,77,,86.6,86.6 +172,0,65,87,"cheated on exam, gets 0pts",54.3,54.3 +173,92,86,78,,84.6,84.6 +174,56,52,78,,63.6,63.6 +175,74,0,85,"cheated on exam, gets 0pts",56.2,66.2 +176,73,80,95,,83.9,83.9 +177,69,93,84,,82.2,82.2 +178,91,99,90,,93.0,93.0 +179,73,92,91,great final presentation +10,95.9,95.9 +180,94,41,91,great participation +10,86.9,86.9 +181,91,96,92,,92.9,92.9 +182,69,94,58,missed homework frequently -10,62.1,62.1 +183,94,79,89,,87.5,87.5 +184,0,92,98,"cheated on exam, gets 0pts",66.8,66.8 +185,89,92,79,,85.9,85.9 +186,92,86,81,,85.8,85.8 +187,82,85,89,,85.7,85.7 +188,82,77,92,missed class frequently -10,74.5,74.5 +189,99,65,87,,84.0,84.0 +190,73,95,67,,77.2,77.2 +191,98,94,90,great participation +10,100.0,100.0 +192,95,78,60,great participation +10,85.9,85.9 +193,90,67,77,missed class frequently -10,67.9,67.9 +194,96,0,90,"cheated on exam, gets 0pts",64.8,64.8 +195,86,80,89,,85.4,85.4 +196,51,78,84,,72.3,72.3 +197,99,75,88,,87.4,87.4 +198,93,58,70,great final presentation +10,83.3,83.3 +199,95,0,72,"cheated on exam, gets 0pts",57.3,57.3 +200,88,71,93,,84.9,84.9 +201,91,92,70,,82.9,82.9 +202,98,92,69,,84.6,74.6 +203,90,0,100,"cheated on exam, gets 0pts",67.0,57.0 +204,89,70,74,,77.3,77.3 +205,97,82,80,,85.7,85.7 +206,78,81,74,missed homework frequently -10,67.3,67.3 +207,77,87,83,,82.4,82.4 +208,86,99,97,,94.3,84.3 +209,92,92,85,great final presentation +10,99.2,99.2 +210,86,80,66,,76.2,76.2 +211,59,70,86,,73.1,73.1 +212,93,75,91,,86.8,86.8 +213,76,54,65,,65.0,65.0 +214,72,78,69,missed homework frequently -10,62.6,62.6 +215,58,90,80,,76.4,76.4 +216,77,84,86,,82.7,82.7 +217,92,66,65,missed homework frequently -10,63.400000000000000,63.400000000000000 +218,88,83,86,great final presentation +10,95.7,95.7 +219,65,0,88,"cheated on exam, gets 0pts",54.7,64.7 +220,89,72,60,great final presentation +10,82.3,82.3 +221,84,79,97,great final presentation +10,97.7,97.7 +222,96,64,65,,74.0,74.0 +223,96,75,92,great final presentation +10,98.1,98.1 +224,62,92,76,,76.6,76.6 +225,94,62,66,,73.2,73.2 +226,85,74,92,,84.5,84.5 +227,73,90,68,missed homework frequently -10,66.1,66.1 +228,81,76,97,great participation +10,95.9,95.9 +229,96,87,80,missed class frequently -10,76.9,76.9 +230,76,65,59,great final presentation +10,75.9,85.9 +231,83,85,90,great participation +10,96.4,96.4 +232,85,100,79,missed class frequently -10,77.1,77.1 +233,75,77,73,missed homework frequently -10,64.8,64.8 +234,84,94,47,missed homework frequently -10,62.2,62.2 +235,84,96,73,great participation +10,93.2,93.2 +236,65,85,50,,65.0,65.0 +237,90,54,80,,75.2,75.2 +238,68,99,99,great final presentation +10,99.7,99.7 +239,95,88,69,,82.5,82.5 +240,0,97,85,"cheated on exam, gets 0pts",63.1,63.1 +241,89,93,70,missed homework frequently -10,72.6,72.6 +242,68,83,76,,75.7,75.7 +243,79,81,89,great final presentation +10,93.6,93.6 +244,73,95,93,,87.6,87.6 +245,87,93,91,great participation +10,100.0,100.0 +246,86,71,68,,74.3,74.3 +247,95,96,64,,82.9,82.9 +248,99,95,67,,85.0,85.0 +249,75,78,97,,84.7,84.7 +250,85,72,70,,75.1,75.1 +251,89,74,85,missed class frequently -10,72.9,72.9 +252,74,94,84,great participation +10,94.0,94.0 +253,95,75,97,great final presentation +10,99.8,99.8 +254,83,93,77,,83.6,73.6 +255,78,58,86,great final presentation +10,85.2,85.2 +256,88,56,80,,75.2,75.2 +257,94,94,72,great participation +10,95.2,95.2 +258,84,87,96,great final presentation +10,99.7,99.7 +259,99,76,95,great participation +10,100.0,100.0 +260,96,94,89,,92.6,92.6 +261,67,80,51,,64.5,64.5 +262,91,92,74,,84.5,84.5 +263,77,96,78,,83.1,83.1 +264,99,86,95,missed class frequently -10,83.5,73.5 +265,72,82,100,great participation +10,96.2,96.2 +266,89,99,73,great final presentation +10,95.6,95.6 +267,67,76,33,,56.1,56.1 +268,46,70,77,,65.6,65.6 +269,46,92,66,,67.8,57.8 +270,87,78,82,missed homework frequently -10,72.3,72.3 +271,80,98,84,great participation +10,97.0,97.0 +272,91,92,95,missed homework frequently -10,82.9,82.9 +273,80,60,80,,74.0,74.0 +274,88,75,59,missed class frequently -10,62.5,62.5 +275,93,73,97,great final presentation +10,98.6,98.6 +276,86,67,76,missed homework frequently -10,66.3,66.3 +277,59,94,80,missed homework frequently -10,67.9,67.9 +278,61,77,88,,76.6,86.6 +279,88,56,82,great participation +10,86.0,86.0 +280,86,89,85,great final presentation +10,96.5,96.5 +281,72,90,98,,87.8,87.8 +282,68,93,73,,77.5,77.5 +283,94,93,91,missed homework frequently -10,82.5,82.5 +284,91,98,97,great participation +10,100.0,100.0 +285,91,0,89,"cheated on exam, gets 0pts",62.9,62.9 +286,58,54,37,,48.4,48.4 +287,93,88,79,missed homework frequently -10,75.9,75.9 +288,0,72,88,"cheated on exam, gets 0pts",56.8,56.8 +289,61,76,87,,75.9,65.9 +290,84,97,99,,93.9,93.9 +291,86,98,95,,93.2,103.2 +292,80,76,66,,73.2,73.2 +293,73,86,40,great final presentation +10,73.7,73.7 +294,0,50,85,"cheated on exam, gets 0pts",49.0,49.0 +295,73,64,87,missed homework frequently -10,65.9,75.9 +296,95,76,41,,67.7,77.7 +297,0,69,90,"cheated on exam, gets 0pts",56.7,56.7 +298,86,45,86,great final presentation +10,83.7,83.7 +299,64,93,70,,75.1,75.1 +300,87,57,76,,73.6,63.600000000000000 +301,61,65,100,missed homework frequently -10,67.8,67.8 +302,87,56,85,,76.9,76.9 +303,83,77,72,missed homework frequently -10,66.8,66.8 +304,78,89,81,,82.5,82.5 +305,95,94,89,,92.3,92.3 +306,84,96,91,great final presentation +10,100.0,90.0 +307,67,93,93,,85.2,95.2 +308,77,79,94,,84.4,84.4 +309,86,74,61,,72.4,72.4 +310,0,71,80,"cheated on exam, gets 0pts",53.3,53.3 +311,79,62,82,,75.1,75.1 +312,66,72,83,missed homework frequently -10,64.6,64.6 +313,79,89,86,great final presentation +10,94.8,94.8 +314,100,98,96,missed homework frequently -10,87.8,87.8 +315,73,82,69,missed class frequently -10,64.1,64.1 +316,76,84,67,,74.8,74.8 +317,0,84,72,"cheated on exam, gets 0pts",54.0,54.0 +318,0,92,56,"cheated on exam, gets 0pts",50.0,50.0 +319,99,83,88,great participation +10,99.8,99.8 +320,91,61,100,,85.6,85.6 +321,83,52,88,missed homework frequently -10,65.7,65.7 +322,83,93,54,,74.4,74.4 +323,0,93,88,"cheated on exam, gets 0pts",63.1,63.1 +324,95,82,54,,74.7,74.7 +325,86,67,98,,85.1,85.1 +326,91,89,83,missed class frequently -10,77.2,77.2 +327,100,73,84,missed homework frequently -10,75.5,75.5 +328,52,95,72,great participation +10,82.9,82.9 +329,64,73,79,great final presentation +10,82.7,82.7 +330,98,51,74,,74.3,74.3 +331,86,91,86,missed class frequently -10,77.5,77.5 +332,97,97,92,missed homework frequently -10,85.0,85.0 +333,88,89,80,missed class frequently -10,75.1,75.1 +334,54,80,81,,72.6,72.6 +335,90,70,68,,75.2,65.2 +336,78,63,75,great final presentation +10,82.3,82.3 +337,93,90,82,,87.7,87.7 +338,66,73,89,,77.3,77.3 +339,82,88,78,great final presentation +10,92.2,92.2 +340,83,87,88,missed homework frequently -10,76.2,86.2 +341,53,100,78,great final presentation +10,87.1,77.1 +342,93,70,97,,87.7,87.7 +343,93,73,82,,82.6,92.6 +344,93,79,97,great participation +10,100.0,100.0 +345,99,86,54,,77.1,77.1 +346,85,80,60,,73.5,73.5 +347,64,86,78,,76.2,76.2 +348,89,97,100,missed class frequently -10,85.8,85.8 +349,95,88,77,,85.7,85.7 +350,96,62,92,great participation +10,94.2,94.2 +351,84,0,80,"cheated on exam, gets 0pts",57.2,57.2 +352,88,71,94,great participation +10,95.3,95.3 +353,92,93,81,,87.9,87.9 +354,93,94,94,,93.7,93.7 +355,86,87,86,missed class frequently -10,76.3,76.3 +356,80,85,84,missed homework frequently -10,73.1,73.1 +357,0,73,89,"cheated on exam, gets 0pts",57.5,57.5 +358,89,78,88,great participation +10,95.3,95.3 +359,66,90,50,,66.8,66.8 +360,81,0,75,"cheated on exam, gets 0pts",54.3,54.3 +361,87,93,76,missed class frequently -10,74.4,74.4 +362,71,76,56,,66.5,66.5 +363,94,70,85,great participation +10,93.2,93.2 +364,90,60,78,,76.2,76.2 +365,66,60,86,,72.2,72.2 +366,73,96,92,,87.5,87.5 +367,0,49,93,"cheated on exam, gets 0pts",51.9,51.9 +368,97,81,100,great participation +10,100.0,100.0 +369,0,54,74,"cheated on exam, gets 0pts",45.8,45.8 +370,86,75,62,,73.1,83.1 +371,89,90,93,great final presentation +10,100.0,100.0 +372,65,94,94,,85.3,85.3 +373,91,99,79,great participation +10,98.6,98.6 +374,69,55,95,,75.2,75.2 +375,77,71,78,,75.6,75.6 +376,99,59,70,missed class frequently -10,65.4,65.4 +377,88,93,92,great final presentation +10,100.0,100.0 +378,81,92,77,,82.7,82.7 +379,84,74,91,great participation +10,93.8,93.8 +380,85,81,87,,84.6,84.6 +381,88,67,92,,83.3,83.3 +382,97,0,94,"cheated on exam, gets 0pts",66.7,66.7 +383,99,67,89,great final presentation +10,95.4,95.4 +384,95,77,87,,86.4,86.4 +385,81,95,77,,83.6,83.6 +386,72,80,69,,73.2,73.2 +387,95,59,90,great participation +10,92.2,92.2 +388,89,95,87,great participation +10,100.0,100.0 +389,81,56,90,great final presentation +10,87.1,87.1 +390,50,67,55,,57.1,57.1 +391,87,0,91,"cheated on exam, gets 0pts",62.5,62.5 +392,79,0,59,"cheated on exam, gets 0pts",47.3,57.3 +393,85,62,75,,74.1,74.1 +394,64,75,90,,77.7,67.7 +395,69,87,94,great participation +10,94.4,94.4 +396,87,77,96,,87.6,87.6 +397,80,92,84,,85.2,85.2 +398,52,80,50,missed class frequently -10,49.6,49.6 +399,83,70,71,,74.3,74.3 +400,77,95,85,,85.6,75.6 +401,72,80,93,,82.8,82.8 +402,89,67,95,great final presentation +10,94.8,84.8 +403,90,87,99,,92.7,92.7 +404,85,79,87,,84.0,84.0 +405,69,95,62,great participation +10,84.0,74.0 +406,69,92,99,missed homework frequently -10,77.9,77.9 +407,97,61,76,missed homework frequently -10,67.8,67.8 +408,0,76,75,"cheated on exam, gets 0pts",52.8,52.8 +409,91,74,88,great participation +10,94.7,94.7 +410,83,92,80,missed class frequently -10,74.5,74.5 +411,82,0,58,"cheated on exam, gets 0pts",47.8,47.8 +412,92,96,90,,92.4,92.4 +413,59,82,61,,66.7,66.7 +414,65,91,72,,75.6,75.6 +415,65,81,75,,73.8,73.8 +416,97,0,92,"cheated on exam, gets 0pts",65.9,65.9 +417,71,86,89,missed class frequently -10,72.7,82.7 +418,94,0,95,"cheated on exam, gets 0pts",66.2,66.2 +419,65,95,68,,75.2,75.2 +420,84,83,60,,74.1,74.1 +421,67,87,95,missed homework frequently -10,74.2,74.2 +422,88,69,100,,87.1,87.1 +423,65,98,93,,86.1,86.1 +424,78,57,85,,74.5,74.5 +425,92,97,44,,74.3,74.3 +426,53,49,88,,65.8,65.8 +427,83,88,88,,86.5,86.5 +428,83,79,93,great participation +10,95.8,95.8 +429,96,91,90,great final presentation +10,100.0,100.0 +430,76,91,100,great participation +10,100.0,100.0 +431,85,92,84,missed homework frequently -10,76.7,76.7 +432,92,90,77,great participation +10,95.4,95.4 +433,83,78,74,,77.9,77.9 +434,97,98,92,,95.3,95.3 +435,88,78,91,great final presentation +10,96.2,96.2 +436,95,41,56,,63.2,53.2 +437,97,86,54,missed homework frequently -10,66.5,66.5 +438,68,73,81,missed class frequently -10,64.7,64.7 +439,94,92,75,great participation +10,95.8,95.8 +440,96,84,74,,83.6,73.6 +441,86,85,89,missed homework frequently -10,76.9,76.9 +442,87,81,86,,84.8,84.8 +443,77,0,87,"cheated on exam, gets 0pts",57.9,57.9 +444,84,83,85,missed class frequently -10,74.1,74.1 +445,0,69,93,"cheated on exam, gets 0pts",57.9,57.9 +446,94,95,90,missed class frequently -10,82.7,82.7 +447,57,78,83,,73.7,73.7 +448,92,74,88,great final presentation +10,95.0,95.0 +449,72,91,92,,85.7,85.7 +450,0,77,81,"cheated on exam, gets 0pts",55.5,45.5 +451,87,83,78,,82.2,82.2 +452,69,85,79,,77.8,77.8 +453,73,74,96,,82.5,82.5 +454,51,65,97,,73.6,73.6 +455,90,99,90,,92.7,92.7 +456,85,0,96,"cheated on exam, gets 0pts",63.9,63.9 +457,71,81,80,,77.6,77.6 +458,88,80,91,missed class frequently -10,76.8,76.8 +459,80,89,88,,85.9,85.9 +460,74,86,93,great participation +10,95.2,95.2 +461,0,72,67,"cheated on exam, gets 0pts",48.4,48.4 +462,89,98,80,great participation +10,98.1,98.1 +463,92,92,76,,85.6,95.6 +464,62,95,52,missed homework frequently -10,57.900000000000000,57.900000000000000 +465,77,78,95,missed homework frequently -10,74.5,74.5 +466,93,91,52,,76.0,76.0 +467,84,97,89,great participation +10,99.9,89.9 +468,94,62,50,missed homework frequently -10,56.8,56.8 +469,56,76,60,,63.6,63.6 +470,80,95,61,,76.9,76.9 +471,90,95,75,great final presentation +10,95.5,95.5 +472,91,92,96,missed class frequently -10,83.3,83.3 +473,66,91,70,missed class frequently -10,65.1,65.1 +474,58,92,93,,82.2,82.2 +475,72,93,98,great participation +10,98.7,98.7 +476,80,96,83,missed homework frequently -10,76.0,76.0 +477,100,69,41,,67.1,67.1 +478,91,98,77,,87.5,87.5 +479,71,77,73,great final presentation +10,83.6,83.6 +480,90,73,91,,85.3,85.3 +481,66,95,86,,82.7,72.7 +482,67,88,89,,82.1,72.1 +483,50,67,94,great final presentation +10,82.7,82.7 +484,84,99,71,,83.3,83.3 +485,80,65,55,,65.5,65.5 +486,67,83,77,,75.8,75.8 +487,94,78,78,,82.8,82.8 +488,72,63,91,great final presentation +10,86.9,86.9 +489,90,94,79,missed homework frequently -10,76.8,76.8 +490,83,90,83,,85.1,85.1 +491,74,79,92,missed homework frequently -10,72.7,72.7 +492,93,75,93,,87.6,87.6 +493,72,88,96,,86.4,76.4 +494,90,100,89,great participation +10,100.0,100.0 +495,72,92,85,great participation +10,93.2,93.2 +496,60,92,55,,67.6,67.6 +497,83,79,67,,75.4,75.4 +498,93,96,94,great final presentation +10,100.0,100.0 +499,63,68,84,,72.9,72.9 +500,77,88,82,missed homework frequently -10,72.3,72.3 +501,94,82,97,great final presentation +10,100.0,100.0 +502,69,86,97,missed homework frequently -10,75.3,75.3 +503,90,77,99,great participation +10,99.7,99.7 +504,0,99,92,"cheated on exam, gets 0pts",66.5,66.5 +505,93,82,88,,87.7,87.7 +506,86,86,85,missed class frequently -10,75.6,75.6 +507,76,92,64,great participation +10,86.0,86.0 +508,94,97,93,great participation +10,100.0,100.0 +509,89,71,94,,85.6,85.6 +510,89,57,47,,62.6,62.6 +511,96,69,92,,86.3,86.3 +512,91,74,88,,84.7,84.7 +513,85,100,78,,86.7,86.7 +514,85,0,59,"cheated on exam, gets 0pts",49.1,49.1 +515,81,94,82,,85.3,85.3 +516,87,64,94,,82.9,82.9 +517,68,56,98,great final presentation +10,86.4,86.4 +518,56,79,85,,74.5,74.5 +519,81,63,59,missed class frequently -10,56.8,56.8 +520,88,83,83,,84.5,84.5 +521,85,93,84,,87.0,87.0 +522,87,79,82,great final presentation +10,92.6,92.6 +523,92,87,60,great participation +10,87.7,87.7 +524,81,97,100,,93.4,93.4 +525,78,85,84,,82.5,92.5 +526,94,83,88,great final presentation +10,98.3,98.3 +527,0,97,88,"cheated on exam, gets 0pts",64.3,64.3 +528,96,64,93,great final presentation +10,95.2,85.2 +529,69,87,51,,67.2,67.2 +530,81,67,100,great participation +10,94.4,94.4 +531,81,87,60,missed class frequently -10,64.4,64.4 +532,66,83,77,,75.5,75.5 +533,76,72,100,great final presentation +10,94.4,94.4 +534,92,73,85,great final presentation +10,93.5,93.5 +535,80,85,93,great participation +10,96.7,96.7 +536,86,81,88,great final presentation +10,95.3,95.3 +537,56,75,71,,67.7,67.7 +538,72,0,76,"cheated on exam, gets 0pts",52.0,52.0 +539,62,64,63,,63.0,63.0 +540,75,0,65,"cheated on exam, gets 0pts",48.5,48.5 +541,89,65,74,missed homework frequently -10,65.8,65.8 +542,91,0,68,"cheated on exam, gets 0pts",54.5,54.5 +543,72,81,80,,77.9,77.9 +544,87,72,50,great final presentation +10,77.7,77.7 +545,73,96,100,great participation +10,100.0,100.0 +546,78,94,83,,84.8,84.8 +547,94,82,83,,86.0,86.0 +548,95,83,100,,93.4,93.4 +549,76,83,86,,82.1,82.1 +550,93,56,74,,74.3,74.3 +551,91,75,100,great participation +10,99.8,99.8 +552,82,94,85,,86.8,86.8 +553,83,79,92,missed homework frequently -10,75.4,75.4 +554,92,44,66,,67.2,67.2 +555,78,0,86,"cheated on exam, gets 0pts",57.8,57.8 +556,80,96,80,,84.8,84.8 +557,87,48,91,,76.9,76.9 +558,78,89,68,,77.3,77.3 +559,100,100,99,,99.6,99.6 +560,43,0,85,"cheated on exam, gets 0pts",46.9,36.9 +561,0,89,90,"cheated on exam, gets 0pts",62.7,62.7 +562,88,74,96,great final presentation +10,97.0,97.0 +563,81,98,96,,92.1,92.1 +564,84,92,86,,87.2,87.2 +565,83,86,85,missed homework frequently -10,74.7,74.7 +566,67,98,65,missed homework frequently -10,65.5,65.5 +567,0,95,94,"cheated on exam, gets 0pts",66.1,66.1 +568,84,99,47,great final presentation +10,83.7,83.7 +569,91,98,75,missed class frequently -10,76.7,76.7 +570,85,91,83,great participation +10,96.0,96.0 +571,92,50,87,,77.4,77.4 +572,99,84,82,missed class frequently -10,77.7,77.7 +573,87,74,86,missed homework frequently -10,72.7,62.7 +574,71,64,62,great participation +10,75.3,75.3 +575,90,96,71,missed class frequently -10,74.2,84.2 +576,61,54,100,,74.5,74.5 +577,74,48,74,,66.2,66.2 +578,98,68,58,,73.0,73.0 +579,92,87,49,,73.3,73.3 +580,70,75,99,,83.1,83.1 +581,80,0,99,"cheated on exam, gets 0pts",63.6,63.6 +582,66,83,96,,83.1,83.1 +583,69,49,75,,65.4,65.4 +584,93,95,67,,83.2,83.2 +585,87,85,77,,82.4,82.4 +586,82,68,48,,64.2,64.2 +587,75,90,93,,86.7,76.7 +588,67,92,64,,73.3,73.3 +589,98,97,93,,95.7,95.7 +590,73,93,86,,84.2,74.2 +591,58,0,71,"cheated on exam, gets 0pts",45.8,45.8 +592,97,94,76,,87.7,87.7 +593,92,99,87,missed homework frequently -10,82.1,82.1 +594,73,87,92,,84.8,84.8 +595,79,60,84,,75.3,75.3 +596,62,54,71,,63.2,63.2 +597,98,97,68,missed homework frequently -10,75.7,75.7 +598,41,80,93,,73.5,73.5 +599,91,90,81,great participation +10,96.7,96.7 +600,96,83,73,great final presentation +10,92.9,92.9 +601,98,88,95,,93.8,93.8 +602,83,80,86,,83.3,83.3 +603,86,90,80,great final presentation +10,94.8,94.8 +604,90,67,77,missed class frequently -10,67.9,67.9 +605,59,68,65,,64.1,64.1 +606,76,85,74,,77.9,77.9 +607,71,89,96,great final presentation +10,96.4,96.4 +608,82,68,80,,77.0,77.0 +609,57,74,86,,73.7,73.7 +610,91,97,96,,94.8,94.8 +611,89,75,64,great final presentation +10,84.8,84.8 +612,69,87,70,missed homework frequently -10,64.8,64.8 +613,90,66,96,great final presentation +10,95.2,95.2 +614,92,0,71,"cheated on exam, gets 0pts",56.0,56.0 +615,71,89,90,,84.0,84.0 +616,53,0,76,"cheated on exam, gets 0pts",46.3,46.3 +617,90,79,89,,86.3,86.3 +618,92,95,92,,92.9,92.9 +619,81,100,74,,83.9,83.9 +620,92,71,93,great participation +10,96.1,96.1 +621,0,87,94,"cheated on exam, gets 0pts",63.7,63.7 +622,54,76,96,,77.4,67.4 +623,86,67,80,,77.9,77.9 +624,94,79,58,great final presentation +10,85.1,95.1 +625,57,89,55,,65.8,65.8 +626,81,81,91,,85.0,85.0 +627,71,94,89,,85.1,85.1 +628,95,83,83,,86.6,86.6 +629,99,87,71,,84.2,84.2 +630,81,86,95,great participation +10,98.1,98.1 +631,94,78,89,,87.2,87.2 +632,99,73,84,missed homework frequently -10,75.2,75.2 +633,56,90,71,missed class frequently -10,62.2,62.2 +634,79,83,92,,85.4,85.4 +635,94,77,82,great participation +10,94.1,94.1 +636,100,62,61,missed class frequently -10,63.0,63.0 +637,88,92,83,,87.2,87.2 +638,89,86,90,great final presentation +10,98.5,98.5 +639,81,71,54,missed homework frequently -10,57.2,67.2 +640,93,53,77,,74.6,74.6 +641,92,0,61,"cheated on exam, gets 0pts",52.0,52.0 +642,89,77,68,,77.0,77.0 +643,96,98,92,great final presentation +10,100.0,90.0 +644,79,98,84,,86.7,86.7 +645,93,47,79,great participation +10,83.6,83.6 +646,92,93,73,missed homework frequently -10,74.7,74.7 +647,67,69,84,missed class frequently -10,64.4,64.4 +648,94,79,79,great participation +10,93.5,93.5 +649,95,73,57,great final presentation +10,83.2,83.2 +650,91,91,78,great final presentation +10,95.8,95.8 +651,81,69,95,,83.0,73.0 +652,80,76,96,missed class frequently -10,75.2,75.2 +653,76,82,91,great final presentation +10,93.8,93.8 +654,78,95,54,missed homework frequently -10,63.5,63.5 +655,86,96,100,,94.6,104.6 +656,97,98,63,missed class frequently -10,73.7,73.7 +657,98,75,89,great final presentation +10,97.5,97.5 +658,79,73,72,,74.4,74.4 +659,38,86,75,great final presentation +10,77.2,77.2 +660,83,74,97,,85.9,95.9 +661,78,95,87,,86.7,76.7 +662,0,79,65,"cheated on exam, gets 0pts",49.7,49.7 +663,89,66,90,,82.5,82.5 +664,81,96,96,great participation +10,100.0,100.0 +665,68,65,89,,75.5,75.5 +666,86,85,89,,86.9,86.9 +667,99,99,87,,94.2,94.2 +668,60,66,64,great final presentation +10,73.4,73.4 +669,68,95,90,,84.9,84.9 +670,79,81,69,,75.6,75.6 +671,95,69,83,missed homework frequently -10,72.4,72.4 +672,68,0,38,"cheated on exam, gets 0pts",35.6,45.6 +673,93,82,85,missed homework frequently -10,76.5,76.5 +674,80,85,86,missed homework frequently -10,73.9,73.9 +675,0,87,99,"cheated on exam, gets 0pts",65.7,65.7 +676,96,79,92,great participation +10,99.3,99.3 +677,95,82,76,,83.5,93.5 +678,89,81,64,missed class frequently -10,66.6,66.6 +679,70,50,75,missed class frequently -10,56.0,56.0 +680,91,97,53,great participation +10,87.6,87.6 +681,65,94,92,,84.5,84.5 +682,64,91,97,,85.3,85.3 +683,94,90,90,great participation +10,100.0,100.0 +684,85,82,55,great participation +10,82.1,82.1 +685,88,91,80,,85.7,85.7 +686,99,95,99,great participation +10,100.0,100.0 +687,66,0,78,"cheated on exam, gets 0pts",51.0,51.0 +688,49,77,89,great participation +10,83.4,83.4 +689,88,69,89,,82.7,82.7 +690,77,54,70,,67.3,67.3 +691,74,80,90,,82.2,82.2 +692,86,97,95,,92.9,92.9 +693,97,88,74,great participation +10,95.1,95.1 +694,84,55,53,missed class frequently -10,52.9,52.9 +695,0,96,87,"cheated on exam, gets 0pts",63.6,63.6 +696,89,74,85,,82.9,72.9 +697,55,71,98,missed homework frequently -10,67.0,67.0 +698,78,76,72,,75.0,75.0 +699,99,77,81,great final presentation +10,95.2,95.2 +700,78,63,88,,77.5,77.5 +701,96,76,85,,85.6,85.6 +702,88,88,83,missed class frequently -10,76.0,76.0 +703,89,85,87,great final presentation +10,97.0,97.0 +704,89,78,94,,87.7,87.7 +705,93,81,77,great participation +10,93.0,93.0 +706,71,96,65,missed class frequently -10,66.1,66.1 +707,70,96,32,missed homework frequently -10,52.6,52.6 +708,95,87,82,missed class frequently -10,77.4,77.4 +709,81,56,58,,64.3,64.3 +710,91,69,90,,84.0,94.0 +711,97,84,87,great participation +10,99.1,89.1 +712,61,0,97,"cheated on exam, gets 0pts",57.1,57.1 +713,70,99,90,,86.7,86.7 +714,72,91,91,,85.3,85.3 +715,73,77,73,,74.2,74.2 +716,58,90,100,great participation +10,94.4,94.4 +717,77,51,70,,66.4,66.4 +718,78,58,86,great final presentation +10,85.2,85.2 +719,95,94,89,,92.3,92.3 +720,65,0,95,"cheated on exam, gets 0pts",57.5,67.5 +721,80,0,98,"cheated on exam, gets 0pts",63.2,63.2 +722,65,0,92,"cheated on exam, gets 0pts",56.3,56.3 +723,89,91,57,,76.8,76.8 +724,65,72,86,great participation +10,85.5,85.5 +725,74,81,74,,76.1,76.1 +726,73,68,61,missed homework frequently -10,56.7,56.7 +727,94,91,93,great participation +10,100.0,100.0 +728,66,82,82,missed homework frequently -10,67.2,67.2 +729,92,81,54,,73.5,73.5 +730,78,75,96,,84.3,84.3 +731,81,79,86,,82.4,72.4 +732,78,84,71,,77.0,77.0 +733,84,81,88,,84.7,84.7 +734,97,0,90,"cheated on exam, gets 0pts",65.1,65.1 +735,0,61,84,"cheated on exam, gets 0pts",51.9,51.9 +736,85,94,84,,87.3,87.3 +737,100,82,72,great participation +10,93.4,93.4 +738,64,70,86,,74.6,74.6 +739,68,74,40,missed homework frequently -10,48.6,48.6 +740,90,82,60,missed class frequently -10,65.6,65.6 +741,87,97,99,,94.8,94.8 +742,0,75,78,"cheated on exam, gets 0pts",53.7,53.7 +743,76,74,97,,83.8,83.8 +744,90,88,84,missed homework frequently -10,77.0,77.0 +745,92,72,94,,86.8,86.8 +746,87,83,87,missed class frequently -10,75.8,75.8 +747,87,82,57,,73.5,73.5 +748,70,92,96,missed homework frequently -10,77.0,77.0 +749,94,77,87,,86.1,86.1 +750,84,65,95,missed class frequently -10,72.7,72.7 +751,92,79,98,great final presentation +10,100.0,100.0 +752,53,89,78,,73.8,73.8 +753,0,83,76,"cheated on exam, gets 0pts",55.3,55.3 +754,82,69,75,great final presentation +10,85.3,85.3 +755,88,90,81,missed homework frequently -10,75.8,85.8 +756,52,75,62,great final presentation +10,72.9,72.9 +757,78,89,58,,73.3,73.3 +758,41,88,98,missed class frequently -10,67.9,67.9 +759,93,68,86,missed homework frequently -10,72.7,72.7 +760,92,75,93,missed homework frequently -10,77.3,67.3 +761,53,0,94,"cheated on exam, gets 0pts",53.5,53.5 +762,90,95,68,,82.7,82.7 +763,43,76,91,missed homework frequently -10,62.1,62.1 +764,96,73,89,missed homework frequently -10,76.3,76.3 +765,79,76,98,,85.7,85.7 +766,82,87,82,,83.5,73.5 +767,82,80,98,great final presentation +10,97.8,97.8 +768,93,96,90,,92.7,92.7 +769,88,96,79,great final presentation +10,96.8,86.8 +770,58,66,74,,66.8,66.8 +771,88,81,85,,84.7,84.7 +772,58,80,89,,77.0,77.0 +773,97,76,90,,87.9,87.9 +774,90,74,95,great participation +10,97.2,107.2 +775,79,86,99,great final presentation +10,99.1,99.1 +776,93,36,62,,63.5,63.5 +777,34,91,92,missed homework frequently -10,64.3,64.3 +778,83,62,55,,65.5,65.5 +779,81,75,77,,77.6,77.6 +780,80,77,98,missed class frequently -10,76.3,66.3 +781,99,97,70,,86.8,96.8 +782,83,99,80,,86.6,86.6 +783,80,72,97,,84.4,84.4 +784,0,68,87,"cheated on exam, gets 0pts",55.2,55.2 +785,71,95,45,,67.8,67.8 +786,92,89,82,great final presentation +10,97.1,97.1 +787,89,62,93,,82.5,82.5 +788,67,72,90,missed class frequently -10,67.7,67.7 +789,64,89,91,great final presentation +10,92.3,92.3 +790,0,79,68,"cheated on exam, gets 0pts",50.9,50.9 +791,80,91,60,,75.3,75.3 +792,96,0,62,"cheated on exam, gets 0pts",53.6,53.6 +793,70,92,93,missed homework frequently -10,75.8,75.8 +794,48,50,65,,55.4,55.4 +795,0,89,91,"cheated on exam, gets 0pts",63.1,63.1 +796,91,89,81,,86.4,86.4 +797,99,84,94,,92.5,92.5 +798,94,97,91,,93.7,93.7 +799,84,93,62,missed class frequently -10,67.9,67.9 +800,82,64,80,great final presentation +10,85.8,85.8 +801,78,60,88,great final presentation +10,86.6,86.6 +802,69,55,72,missed homework frequently -10,56.0,56.0 +803,71,92,94,,86.5,86.5 +804,59,84,83,missed class frequently -10,66.1,66.1 +805,74,96,92,missed class frequently -10,77.8,77.8 +806,80,95,58,,75.7,75.7 +807,96,64,92,great final presentation +10,94.8,84.8 +808,0,88,95,"cheated on exam, gets 0pts",64.4,64.4 +809,97,65,85,missed class frequently -10,72.6,62.600000000000000 +810,64,85,97,,83.5,83.5 +811,85,97,86,great participation +10,99.0,109.0 +812,85,96,48,,73.5,73.5 +813,87,58,34,missed homework frequently -10,47.1,47.1 +814,85,82,85,great participation +10,94.1,94.1 +815,93,74,91,,86.5,86.5 +816,58,75,91,missed class frequently -10,66.3,66.3 +817,98,73,83,,84.5,84.5 +818,92,84,92,great participation +10,99.6,99.6 +819,93,88,84,great participation +10,97.9,107.9 +820,88,80,93,,87.6,77.6 +821,72,94,88,,85.0,85.0 +822,58,90,97,,83.2,83.2 +823,70,97,42,,66.9,66.9 +824,73,86,64,,73.3,73.3 +825,76,88,94,great final presentation +10,96.8,96.8 +826,71,96,83,great final presentation +10,93.3,93.3 +827,74,58,92,great final presentation +10,86.4,86.4 +828,78,95,78,,83.1,83.1 +829,49,95,77,,74.0,74.0 +830,85,93,58,,76.6,76.6 +831,91,90,74,,83.9,83.9 +832,98,97,87,,93.3,93.3 +833,74,98,86,,86.0,86.0 +834,94,0,72,"cheated on exam, gets 0pts",57.0,57.0 +835,83,85,92,great final presentation +10,97.2,97.2 +836,85,87,90,,87.6,97.6 +837,65,0,57,"cheated on exam, gets 0pts",42.3,42.3 +838,72,0,80,"cheated on exam, gets 0pts",53.6,53.6 +839,90,76,81,,82.2,82.2 +840,0,65,88,"cheated on exam, gets 0pts",54.7,54.7 +841,89,97,96,missed homework frequently -10,84.2,84.2 +842,84,94,100,great final presentation +10,100.0,100.0 +843,95,80,86,,86.9,86.9 +844,69,90,86,missed homework frequently -10,72.1,72.1 +845,95,90,69,,83.1,83.1 +846,93,98,75,,87.3,87.3 +847,72,85,91,missed homework frequently -10,73.5,73.5 +848,85,74,87,missed homework frequently -10,72.5,72.5 +849,90,82,86,,86.0,86.0 +850,69,86,75,,76.5,76.5 +851,99,75,78,,83.4,83.4 +852,96,95,89,,92.9,102.9 +853,99,93,90,,93.6,93.6 +854,0,92,60,"cheated on exam, gets 0pts",51.6,51.6 +855,85,91,84,,86.4,86.4 +856,99,62,90,,84.3,84.3 +857,62,92,95,,84.2,84.2 +858,60,37,62,,53.9,53.9 +859,99,86,74,,85.1,85.1 +860,48,47,84,missed homework frequently -10,52.1,52.1 +861,70,84,76,,76.6,76.6 +862,88,91,53,,74.9,74.9 +863,100,83,74,,84.5,94.5 +864,74,61,87,,75.3,75.3 +865,98,71,93,,87.9,87.9 +866,51,75,87,,72.6,82.6 +867,98,85,82,great final presentation +10,97.7,87.7 +868,97,0,42,"cheated on exam, gets 0pts",45.9,45.9 +869,83,91,63,,77.4,77.4 +870,82,61,87,great participation +10,87.7,87.7 +871,92,84,62,,77.6,77.6 +872,86,89,82,,85.3,85.3 +873,73,74,76,missed class frequently -10,64.5,64.5 +874,87,0,96,"cheated on exam, gets 0pts",64.5,64.5 +875,52,86,87,,76.2,76.2 +876,71,94,95,great final presentation +10,97.5,97.5 +877,82,90,85,,85.6,85.6 +878,96,96,88,,92.8,92.8 +879,66,95,87,great final presentation +10,93.1,93.1 +880,68,80,74,,74.0,84.0 +881,53,89,88,great final presentation +10,87.8,87.8 +882,80,96,81,,85.2,85.2 +883,65,69,69,,67.8,77.8 +884,70,96,81,great final presentation +10,92.2,92.2 +885,86,85,84,missed class frequently -10,74.9,74.9 +886,64,85,97,missed class frequently -10,73.5,73.5 +887,87,0,70,"cheated on exam, gets 0pts",54.1,44.1 +888,94,90,99,missed class frequently -10,84.8,74.8 +889,66,74,80,missed class frequently -10,64.0,64.0 +890,62,98,93,great participation +10,95.2,95.2 +891,0,63,88,"cheated on exam, gets 0pts",54.1,54.1 +892,82,99,82,,87.1,87.1 +893,85,90,80,missed homework frequently -10,74.5,74.5 +894,78,73,98,,84.5,84.5 +895,91,68,88,,82.9,82.9 +896,65,84,58,great participation +10,77.9,87.9 +897,84,58,88,missed class frequently -10,67.8,67.8 +898,70,71,88,great final presentation +10,87.5,77.5 +899,71,78,80,great final presentation +10,86.7,86.7 +900,85,68,76,great participation +10,86.3,76.3 +901,94,78,96,great participation +10,100.0,100.0 +902,100,100,87,missed homework frequently -10,84.8,84.8 +903,96,73,94,great participation +10,98.3,98.3 +904,67,88,91,,82.9,82.9 +905,79,84,64,great final presentation +10,84.5,84.5 +906,86,87,77,,82.7,82.7 +907,83,94,78,missed homework frequently -10,74.3,64.3 +908,97,90,72,,84.9,84.9 +909,75,70,75,,73.5,73.5 +910,83,71,70,great participation +10,84.2,84.2 +911,87,76,72,,77.7,77.7 +912,73,58,57,great participation +10,72.1,72.1 +913,65,82,83,missed homework frequently -10,67.3,67.3 +914,69,72,89,,77.9,77.9 +915,100,91,83,great participation +10,100.0,100.0 +916,78,71,94,,82.3,82.3 +917,61,78,64,,67.3,67.3 +918,100,93,70,,85.9,85.9 +919,85,88,81,,84.3,84.3 +920,92,67,65,missed class frequently -10,63.7,63.7 +921,97,86,68,missed homework frequently -10,72.1,62.100000000000000 +922,89,95,73,,84.4,84.4 +923,87,80,65,great final presentation +10,86.1,86.1 +924,92,0,94,"cheated on exam, gets 0pts",65.2,65.2 +925,81,0,95,"cheated on exam, gets 0pts",62.3,62.3 +926,82,69,92,,82.1,82.1 +927,74,73,77,great final presentation +10,84.9,84.9 +928,75,67,78,great final presentation +10,83.8,83.8 +929,80,59,86,,76.1,76.1 +930,79,92,90,missed class frequently -10,77.3,77.3 +931,67,63,83,great participation +10,82.2,82.2 +932,88,88,79,,84.4,84.4 +933,76,87,60,missed homework frequently -10,62.900000000000000,62.900000000000000 +934,0,79,65,"cheated on exam, gets 0pts",49.7,49.7 +935,65,93,88,great final presentation +10,92.6,92.6 +936,73,71,83,,76.4,76.4 +937,73,64,88,,76.3,76.3 +938,94,88,79,great participation +10,96.2,106.2 +939,93,71,89,,84.8,84.8 +940,67,0,76,"cheated on exam, gets 0pts",50.5,50.5 +941,79,73,78,,76.8,76.8 +942,84,76,65,missed class frequently -10,64.0,64.0 +943,47,77,88,,72.4,72.4 +944,74,65,85,,75.7,75.7 +945,84,90,100,,92.2,92.2 +946,84,87,77,,82.1,82.1 +947,90,0,88,"cheated on exam, gets 0pts",62.2,72.2 +948,84,85,61,,75.1,75.1 +949,93,82,74,,82.1,72.1 +950,57,85,86,,77.0,77.0 +951,94,0,89,"cheated on exam, gets 0pts",63.8,63.8 +952,73,80,95,,83.9,83.9 +953,87,80,91,,86.5,76.5 +954,100,80,78,missed class frequently -10,75.2,75.2 +955,56,81,90,,77.1,77.1 +956,67,65,65,,65.6,65.6 +957,56,97,92,great final presentation +10,92.7,92.7 +958,79,0,75,"cheated on exam, gets 0pts",53.7,53.7 +959,66,95,95,,86.3,96.3 +960,0,79,96,"cheated on exam, gets 0pts",62.1,62.1 +961,88,80,89,,86.0,86.0 +962,87,74,95,missed class frequently -10,76.3,76.3 +963,71,92,83,,82.1,82.1 +964,68,82,97,,83.8,83.8 +965,74,72,97,missed class frequently -10,72.6,72.6 +966,90,92,88,great participation +10,99.8,109.8 +967,79,80,91,,84.1,84.1 +968,42,87,63,great participation +10,73.9,73.9 +969,71,0,82,"cheated on exam, gets 0pts",54.1,54.1 +970,78,48,96,,76.2,76.2 +971,74,85,88,great participation +10,92.9,82.9 +972,85,94,75,missed class frequently -10,73.7,63.7 +973,88,79,98,great final presentation +10,99.3,99.3 +974,37,83,69,missed homework frequently -10,53.6,53.6 +975,59,37,75,missed homework frequently -10,48.8,38.8 +976,0,97,60,"cheated on exam, gets 0pts",53.1,53.1 +977,74,80,91,,82.6,82.6 +978,88,66,74,,75.8,75.8 \ No newline at end of file From 6c16a1a920eed6a3ea9673b72cd34fd931ff27a6 Mon Sep 17 00:00:00 2001 From: krmayankb Date: Wed, 28 Dec 2022 17:43:08 -0800 Subject: [PATCH 060/258] unused imports removed --- cleanlab/internal/regression_utils.py | 2 +- cleanlab/regression/rank.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/cleanlab/internal/regression_utils.py b/cleanlab/internal/regression_utils.py index 4e396f2d55..468edd30f5 100644 --- a/cleanlab/internal/regression_utils.py +++ b/cleanlab/internal/regression_utils.py @@ -4,7 +4,7 @@ import numpy as np from numpy.typing import ArrayLike -from typing import Tuple, Optional +from typing import Tuple def assert_valid_inputs( diff --git a/cleanlab/regression/rank.py b/cleanlab/regression/rank.py index cd6c474c93..b959e6e423 100644 --- a/cleanlab/regression/rank.py +++ b/cleanlab/regression/rank.py @@ -2,7 +2,7 @@ from cleanlab.outlier import OutOfDistribution from sklearn.neighbors import NearestNeighbors from cleanlab.internal.regression_utils import assert_valid_inputs -from typing import Dict, Callable, Optional +from typing import Dict, Callable from numpy.typing import ArrayLike """ Generates label quality scores for every sample in regression dataset """ From 54ae993ffa106a3d8eb092dce20e17571e60ca2b Mon Sep 17 00:00:00 2001 From: krmayankb Date: Thu, 29 Dec 2022 19:07:54 -0800 Subject: [PATCH 061/258] tutorial added --- docs/source/tutorials/index.rst | 1 + docs/source/tutorials/regression.ipynb | 667 +++++++++++++++ docs/source/tutorials/student_grades.csv | 980 ----------------------- 3 files changed, 668 insertions(+), 980 deletions(-) create mode 100644 docs/source/tutorials/regression.ipynb delete mode 100644 docs/source/tutorials/student_grades.csv diff --git a/docs/source/tutorials/index.rst b/docs/source/tutorials/index.rst index e0d63a7e06..d87c7df96c 100644 --- a/docs/source/tutorials/index.rst +++ b/docs/source/tutorials/index.rst @@ -14,5 +14,6 @@ Tutorials multiannotator multilabel_classification token_classification + regression pred_probs_cross_val faq diff --git a/docs/source/tutorials/regression.ipynb b/docs/source/tutorials/regression.ipynb new file mode 100644 index 0000000000..ace4d8aec7 --- /dev/null +++ b/docs/source/tutorials/regression.ipynb @@ -0,0 +1,667 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Label Quality Scores for Regression with Noisy Labels " + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This quickstart tutorial shows how to use cleanlab for finding label quality scores in regression datasets. Using the approach mentioned here, you can find label quality scores in any regression dataset irrespective of modality i.e. tabular, text, image, etc. \n", + "\n", + "**This example will take you through the following:**\n", + "- Generate label quality scores for each example in the dataset. \n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Quickstart \n", + "\n", + "Cleanlab uses two inputs to generate scores for labels in the dataset:\n", + "- `labels`: NumPy array of given labels in the dataset. labels[i] should contain label for `i`-th example. \n", + "- `predictions`: NumPy array of predictions generated through your favorite regressor. predictions[i] should contain predicted value for `i`-th example. \n", + "\n", + "If you already have predictions from your regressor, you can generate label quality scores for each example using the code below: \n", + "\n", + "
\n", + "\n", + "```python \n", + "\n", + "from cleanlab.regression.rank import get_label_quality_scores\n", + "label_quality_scores = get_label_quality_scores(labels, predictions)\n", + "\n", + "```\n", + "
\n", + "" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1. Install dependencies and import them \n", + "You can use `pip` to install all the packages required for this tutorial as follows:\n", + "\n", + "`!pip install cleanlab xgboost`" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Requirement already satisfied: cleanlab in /Users/krmayank/Desktop/Work/cleanlab/fork/cleanlab/ENV/lib/python3.10/site-packages (2.1.1)\n", + "Requirement already satisfied: xgboost in /Users/krmayank/Desktop/Work/cleanlab/fork/cleanlab/ENV/lib/python3.10/site-packages (1.7.2)\n", + "Requirement already satisfied: scikit-learn>=0.18 in /Users/krmayank/Desktop/Work/cleanlab/fork/cleanlab/ENV/lib/python3.10/site-packages (from cleanlab) (1.1.3)\n", + "Requirement already satisfied: pandas>=1.0.0 in /Users/krmayank/Desktop/Work/cleanlab/fork/cleanlab/ENV/lib/python3.10/site-packages (from cleanlab) (1.5.1)\n", + "Requirement already satisfied: numpy>=1.11.3 in /Users/krmayank/Desktop/Work/cleanlab/fork/cleanlab/ENV/lib/python3.10/site-packages (from cleanlab) (1.23.4)\n", + "Requirement already satisfied: termcolor>=1.1.0 in /Users/krmayank/Desktop/Work/cleanlab/fork/cleanlab/ENV/lib/python3.10/site-packages (from cleanlab) (2.1.0)\n", + "Requirement already satisfied: tqdm>=4.53.0 in /Users/krmayank/Desktop/Work/cleanlab/fork/cleanlab/ENV/lib/python3.10/site-packages (from cleanlab) (4.64.1)\n", + "Requirement already satisfied: scipy in /Users/krmayank/Desktop/Work/cleanlab/fork/cleanlab/ENV/lib/python3.10/site-packages (from xgboost) (1.9.3)\n", + "Requirement already satisfied: pytz>=2020.1 in /Users/krmayank/Desktop/Work/cleanlab/fork/cleanlab/ENV/lib/python3.10/site-packages (from pandas>=1.0.0->cleanlab) (2022.6)\n", + "Requirement already satisfied: python-dateutil>=2.8.1 in /Users/krmayank/Desktop/Work/cleanlab/fork/cleanlab/ENV/lib/python3.10/site-packages (from pandas>=1.0.0->cleanlab) (2.8.2)\n", + "Requirement already satisfied: threadpoolctl>=2.0.0 in /Users/krmayank/Desktop/Work/cleanlab/fork/cleanlab/ENV/lib/python3.10/site-packages (from scikit-learn>=0.18->cleanlab) (3.1.0)\n", + "Requirement already satisfied: joblib>=1.0.0 in /Users/krmayank/Desktop/Work/cleanlab/fork/cleanlab/ENV/lib/python3.10/site-packages (from scikit-learn>=0.18->cleanlab) (1.2.0)\n", + "Requirement already satisfied: six>=1.5 in /Users/krmayank/Desktop/Work/cleanlab/fork/cleanlab/ENV/lib/python3.10/site-packages (from python-dateutil>=2.8.1->pandas>=1.0.0->cleanlab) (1.16.0)\n" + ] + } + ], + "source": [ + "!pip install cleanlab xgboost" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "nbsphinx": "hidden" + }, + "outputs": [], + "source": [ + "# Package installation (hidden on docs website).\n", + "# Package versions we used: xgboost==1.7.2\n", + "\n", + "dependencies = [\"cleanlab\", \"xgboost\"]\n", + "\n", + "if \"google.colab\" in str(get_ipython()): # Check if it's running in Google Colab\n", + " %pip install cleanlab # for colab\n", + " cmd = \" \".join([dep for dep in dependencies if dep != \"cleanlab\"])\n", + " %pip install $cmd\n", + "else:\n", + " missing_dependencies = []\n", + " for dependency in dependencies:\n", + " try:\n", + " __import__(dependency)\n", + " except ImportError:\n", + " missing_dependencies.append(dependency)\n", + "\n", + " if len(missing_dependencies) > 0:\n", + " print(\"Missing required dependencies:\")\n", + " print(*missing_dependencies, sep=\", \")\n", + " print(\"\\nPlease install them before running the rest of this notebook.\")" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "from cleanlab.regression.rank import get_label_quality_scores\n", + "\n", + "np.set_printoptions(suppress=True)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In this part, we have added a support function to plot the dataset for a quick demonstration. You can use it to highlight the examples based on label_quality_scores. You can skip this part and move to the next section. " + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "
See the code for visualization **(click to expand)** \n", + "\n", + "```python \n", + "# Note: this pulldown is for docs.cleanlab.ai, if running on local Jupyter or colab, please ignore it. \n", + "\n", + "def plot_data(\n", + " data_x, data_y, circles, title, alpha=0.6, color=\"#1f77b4\", colorbar=False, xlabel=\"\", ylabel=\"\"\n", + "):\n", + " plt.figure(figsize=(14, 5))\n", + " data_x = data_x.to_numpy()\n", + " data_y = data_y.to_numpy()\n", + " plt.scatter(data_x, data_y, c=color, s=30)\n", + " for i in circles:\n", + " plt.plot(\n", + " data_x[i],\n", + " data_y[i],\n", + " \"o\",\n", + " markerfacecolor=\"none\",\n", + " markeredgecolor=\"red\",\n", + " markersize=10,\n", + " markeredgewidth=2.5,\n", + " alpha=alpha,\n", + " )\n", + " plt.title(title, fontsize=20)\n", + " plt.xlabel(xlabel)\n", + " plt.ylabel(ylabel)\n", + "\n", + " if colorbar:\n", + " plt.colorbar(orientation=\"vertical\")\n", + "\n", + "```\n", + "
" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "def plot_data(\n", + " data_x, data_y, circles, title, alpha=0.6, color=\"#1f77b4\", colorbar=False, xlabel=\"\", ylabel=\"\"\n", + "):\n", + " plt.figure(figsize=(14, 5))\n", + " data_x = data_x.to_numpy()\n", + " data_y = data_y.to_numpy()\n", + " plt.scatter(data_x, data_y, c=color, s=30)\n", + " for i in circles:\n", + " plt.plot(\n", + " data_x[i],\n", + " data_y[i],\n", + " \"o\",\n", + " markerfacecolor=\"none\",\n", + " markeredgecolor=\"red\",\n", + " markersize=10,\n", + " markeredgewidth=2.5,\n", + " alpha=alpha,\n", + " )\n", + " plt.title(title, fontsize=20)\n", + " plt.xlabel(xlabel)\n", + " plt.ylabel(ylabel)\n", + "\n", + " if colorbar:\n", + " plt.colorbar(orientation=\"vertical\")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 2. Import dataset and Generate predictions" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "File 'student_grades.csv' already there; not retrieving.\n", + "\n" + ] + }, + { + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
exam_1exam_2exam_3notestrue_gradegrade
0537793NaN76.276.2
1816480great participation +1085.585.5
2748897NaN87.487.4
3619478NaN77.777.7
4489091NaN77.877.8
\n", + "
" + ], + "text/plain": [ + " exam_1 exam_2 exam_3 notes true_grade grade\n", + "0 53 77 93 NaN 76.2 76.2\n", + "1 81 64 80 great participation +10 85.5 85.5\n", + "2 74 88 97 NaN 87.4 87.4\n", + "3 61 94 78 NaN 77.7 77.7\n", + "4 48 90 91 NaN 77.8 77.8" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "!wget -nc https://cleanlab-public.s3.amazonaws.com/Datasets/student_grades.csv\n", + "data = pd.read_csv(\"./student_grades.csv\", index_col=0)\n", + "data.head()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In the data frame displayed above, `grade` represents the noisy grades and `true_grade` represents the ground truth. Please note that ground truth is usually not available in a real dataset. We have added it here for comparison and to demonstrate our method. Also, note that column `notes` have categorical information. " + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Generate true errors\n", + "true_errors_index = np.where(data[\"grade\"] != data[\"true_grade\"])[0]\n", + "plot_data(\n", + " data_x=data[\"exam_3\"],\n", + " data_y=data[\"grade\"],\n", + " circles=true_errors_index,\n", + " title=\"Messy Regression dataset\",\n", + " xlabel=\"exam_3 feature\",\n", + " ylabel=\"grade (Y value)\",\n", + ")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In the above plot, `grade (Y value)` is plotted against one of the features in the dataset (`exam_3`). We have circled the examples that were considered as `true_error` in **Red** . " + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We will use sklearn API `XGBRegressor` from `xgboost` as the regressor for this tutorial. `xgboost` provides easy to use interface to process categorical variables. In order to make inputs compatible with `xgboost`, we need to divide data in `X` and labels `y`. This is demonstrated in the code below: " + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "# xgboost automatically factors categorical variable, you just need to mark the columns as category\n", + "data.notes = data.notes.astype(\"category\")\n", + "\n", + "# xgboost takes data and label seperately, so you will need to divide data accordingly.\n", + "X = data.drop([\"grade\", \"true_grade\"], axis=1)\n", + "y = data[\"grade\"]" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's start with initializing the model with relevant parameters. As mentioned earlier we are using `xgboost` for this tutorial. To handle categorical variables, we specifically need to set `enable_categorical` flag to `True`. Note that, support for the categorical variable is in the experimental stage and doesn't support the auto-selection of `tree_method`. Therefore, you will need to specify `tree_method` from supported types. More details can be found [here](https://xgboost.readthedocs.io/en/stable/tutorials/categorical.html)." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# using default xgboost cv " + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "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", + "
train-rmse-meantrain-rmse-stdtest-rmse-meantest-rmse-std
014.2264951.36156314.1786821.087675
111.8619650.85277512.1019180.589881
210.6461010.62194310.7044870.317186
\n", + "
" + ], + "text/plain": [ + " train-rmse-mean train-rmse-std test-rmse-mean test-rmse-std\n", + "0 14.226495 1.361563 14.178682 1.087675\n", + "1 11.861965 0.852775 12.101918 0.589881\n", + "2 10.646101 0.621943 10.704487 0.317186" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import xgboost \n", + "from xgboost import DMatrix, XGBRegressor\n", + "from xgboost import XGBRegressor\n", + "from sklearn.model_selection import cross_val_predict\n", + "\n", + "SEED = 1\n", + "num_boost_round = 1000\n", + "num_crossval_folds = 5\n", + "\n", + "training_data = DMatrix(X, label=y, enable_categorical=True)\n", + "params = {\"booster\": \"gblinear\", \"objective\": \"reg:squarederror\"}\n", + "\n", + "cross_validation_results = xgboost.cv(params, \n", + " training_data, \n", + " num_boost_round=num_boost_round,\n", + " nfold=num_crossval_folds, \n", + " seed=SEED,\n", + " early_stopping_rounds=5) \n", + "\n", + "display(cross_validation_results.head(3))" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "best_iteration = cross_validation_results['test-rmse-mean'].argmin()\n", + "\n", + "model = XGBRegressor(\n", + " tree_method= \"hist\",\n", + " n_estimators = best_iteration, \n", + " enable_categorical = True, \n", + " random_state = SEED)\n", + "\n", + "# get predictions\n", + "predictions = cross_val_predict(\n", + " estimator=model, X=X, y=y, cv=num_crossval_folds, method = \"predict\"\n", + ")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3. Using cleanlab to generate label quality scores\n", + "\n", + "Once you have the predictions from the cross-validation. You can generate label quality scores using cleanlab by running just one line of code. " + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "# get label quality score for each example in the dataset using cleanlab\n", + "label_quality_scores = get_label_quality_scores(labels=y, predictions=predictions)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_data(\n", + " data_x=data[\"exam_3\"],\n", + " data_y=data[\"grade\"],\n", + " circles=true_errors_index,\n", + " color=label_quality_scores,\n", + " title=\"Messy Regression dataset with label quality scores\",\n", + " colorbar=True,\n", + " xlabel=\"exam_3 feature\",\n", + " ylabel=\"grade (Y value)\",\n", + ")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In the above plot, we have colored each examples with their label quality scores generated using cleanlab. Examples are same as earlier plot displayed in the notebook. `grade (Y value)` is plotted against one of the features in the dataset (`exam_3`)\n", + "\n", + "**Red circle** represents the errors in `grade` with respect to the ground truth `true_grade`. You can observe that our method assign low scores to examples that were considered as `true_error`" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "nbsphinx": "hidden" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "OUTRE: 0.9762667538411246\n", + "RESIDUAL: 0.9781736951073335\n" + ] + }, + { + "ename": "ValueError", + "evalue": "Label quality scores did not outperform alternative scores", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn [13], line 20\u001b[0m\n\u001b[1;32m 15\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mValueError\u001b[39;00m(\u001b[39m\"\u001b[39m\u001b[39mLabel quality scores did not perform well enough\u001b[39m\u001b[39m\"\u001b[39m)\n\u001b[1;32m 17\u001b[0m \u001b[39mif\u001b[39;00m roc_auc_score(true_errors, \u001b[39m1\u001b[39m \u001b[39m-\u001b[39m label_quality_scores) \u001b[39m<\u001b[39m\u001b[39m=\u001b[39m roc_auc_score(\n\u001b[1;32m 18\u001b[0m true_errors, \u001b[39m1\u001b[39m \u001b[39m-\u001b[39m label_quality_scores_residual\n\u001b[1;32m 19\u001b[0m ):\n\u001b[0;32m---> 20\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mValueError\u001b[39;00m(\u001b[39m\"\u001b[39m\u001b[39mLabel quality scores did not outperform alternative scores\u001b[39m\u001b[39m\"\u001b[39m)\n", + "\u001b[0;31mValueError\u001b[0m: Label quality scores did not outperform alternative scores" + ] + } + ], + "source": [ + "# Note: This cell is only for docs.cleanlab.ai, if running on local Jupyter or Colab, please ignore it.\n", + "from sklearn.metrics import roc_auc_score\n", + "\n", + "true_errors = (data[\"grade\"] != data[\"true_grade\"]).astype(int)\n", + "\n", + "# label_quality_scores = get_label_quality_scores(labels= y, predictions=predictions)\n", + "from cleanlab.regression.rank import get_outre_score_for_each_label\n", + "label_quality_scores = get_outre_score_for_each_label(labels=np.array(y), predictions=predictions, frac_neighbors=0.5)\n", + "label_quality_scores_residual = get_label_quality_scores(labels = y, predictions=predictions, method=\"residual\")\n", + "\n", + "if roc_auc_score(true_errors, 1 - label_quality_scores) < 0.5:\n", + " raise ValueError(\"Label quality scores did not perform well enough\")\n", + "\n", + "if roc_auc_score(true_errors, 1 - label_quality_scores) <= roc_auc_score(\n", + " true_errors, 1 - label_quality_scores_residual\n", + "):\n", + " raise ValueError(\"Label quality scores did not outperform alternative scores\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.10.8 ('ENV': 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.10.8" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "1ed33b5e6ac3d9870092cd802185bba6fb7a8302b6022e7097221f18c33cb7b2" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/docs/source/tutorials/student_grades.csv b/docs/source/tutorials/student_grades.csv deleted file mode 100644 index 347454bb87..0000000000 --- a/docs/source/tutorials/student_grades.csv +++ /dev/null @@ -1,980 +0,0 @@ -,exam_1,exam_2,exam_3,notes,true_grade,grade -0,53,77,93,,76.2,76.2 -1,81,64,80,great participation +10,85.5,85.5 -2,74,88,97,,87.4,87.4 -3,61,94,78,,77.7,77.7 -4,48,90,91,,77.8,77.8 -5,89,95,72,,84.0,84.0 -6,0,83,97,"cheated on exam, gets 0pts",63.7,63.7 -7,71,82,97,,84.7,84.7 -8,0,56,96,"cheated on exam, gets 0pts",55.2,55.2 -9,75,80,98,missed class frequently -10,75.7,75.7 -10,81,65,82,,76.6,76.6 -11,95,86,53,missed homework frequently -10,65.5,65.5 -12,89,72,98,missed homework frequently -10,77.5,77.5 -13,80,59,65,,67.7,77.7 -14,67,82,98,,83.9,83.9 -15,87,78,95,,87.5,87.5 -16,89,69,98,great participation +10,96.6,96.6 -17,53,72,46,missed class frequently -10,45.9,45.9 -18,46,84,89,missed homework frequently -10,64.6,64.6 -19,70,63,95,great participation +10,87.9,87.9 -20,63,93,94,,84.4,84.4 -21,90,75,90,missed homework frequently -10,75.5,75.5 -22,72,81,95,missed class frequently -10,73.9,73.9 -23,90,83,51,,72.3,72.3 -24,99,53,76,,76.0,76.0 -25,85,49,83,,73.4,73.4 -26,89,71,94,great final presentation +10,95.6,95.6 -27,86,80,89,,85.4,85.4 -28,75,94,79,,82.3,82.3 -29,61,95,94,,84.4,84.4 -30,74,64,91,,77.8,77.8 -31,98,92,96,,95.4,95.4 -32,95,83,78,,84.6,84.6 -33,92,63,91,missed homework frequently -10,72.9,72.9 -34,91,63,48,great participation +10,75.4,75.4 -35,69,94,95,great participation +10,96.9,96.9 -36,81,90,90,missed homework frequently -10,77.3,77.3 -37,98,69,90,,86.1,86.1 -38,82,94,99,missed class frequently -10,82.4,82.4 -39,73,57,96,,77.4,77.4 -40,98,73,86,great final presentation +10,95.7,95.7 -41,0,81,99,"cheated on exam, gets 0pts",63.9,63.9 -42,0,89,100,"cheated on exam, gets 0pts",66.7,66.7 -43,62,83,81,,75.9,75.9 -44,78,84,92,great final presentation +10,95.4,95.4 -45,79,84,92,,85.7,85.7 -46,65,69,92,missed homework frequently -10,67.0,67.0 -47,98,82,47,great final presentation +10,82.8,82.8 -48,92,0,89,"cheated on exam, gets 0pts",63.2,63.2 -49,84,46,95,,77.0,77.0 -50,95,85,98,,93.2,93.2 -51,86,88,90,great final presentation +10,98.2,98.2 -52,65,58,91,,73.3,73.3 -53,79,83,88,,83.8,83.8 -54,0,95,87,"cheated on exam, gets 0pts",63.3,63.3 -55,90,57,97,,82.9,82.9 -56,72,69,81,missed homework frequently -10,64.7,64.7 -57,70,85,96,,84.9,84.9 -58,89,59,79,missed homework frequently -10,66.0,56.0 -59,75,83,69,,75.0,75.0 -60,89,70,90,missed homework frequently -10,73.7,73.7 -61,81,85,95,,87.8,87.8 -62,76,70,73,great participation +10,83.0,83.0 -63,92,62,66,great participation +10,82.6,82.6 -64,94,98,99,,97.2,97.2 -65,96,99,96,great final presentation +10,100.0,100.0 -66,65,85,80,great participation +10,87.0,87.0 -67,90,79,85,great participation +10,94.7,94.7 -68,0,87,77,"cheated on exam, gets 0pts",56.9,56.9 -69,91,75,95,great participation +10,97.8,97.8 -70,88,77,92,,86.3,86.3 -71,86,64,96,,83.4,83.4 -72,88,67,74,,76.1,76.1 -73,76,59,65,,66.5,66.5 -74,96,68,59,great participation +10,82.8,82.8 -75,84,98,51,,75.0,75.0 -76,97,85,75,,84.6,84.6 -77,97,98,80,great final presentation +10,100.0,100.0 -78,89,74,71,,77.3,77.3 -79,72,90,93,,85.8,85.8 -80,49,0,78,"cheated on exam, gets 0pts",45.9,45.9 -81,88,93,78,great participation +10,95.5,95.5 -82,88,80,82,great participation +10,93.2,103.2 -83,75,91,68,great final presentation +10,87.0,87.0 -84,68,99,91,,86.5,86.5 -85,92,87,71,,82.1,72.1 -86,83,97,75,great final presentation +10,94.0,94.0 -87,87,100,94,,93.7,93.7 -88,86,95,77,,85.1,85.1 -89,79,0,76,"cheated on exam, gets 0pts",54.1,54.1 -90,35,100,61,great participation +10,74.9,74.9 -91,99,83,44,great final presentation +10,82.2,82.2 -92,96,77,79,missed class frequently -10,73.5,83.5 -93,78,94,81,,84.0,84.0 -94,58,76,94,great participation +10,87.8,87.8 -95,70,0,63,"cheated on exam, gets 0pts",46.2,46.2 -96,75,46,48,great participation +10,65.5,65.5 -97,77,84,95,,86.3,86.3 -98,81,56,54,,62.7,62.7 -99,76,96,78,great final presentation +10,92.8,102.8 -100,99,53,73,missed homework frequently -10,64.8,64.8 -101,93,91,84,great final presentation +10,98.8,98.8 -102,73,87,86,missed class frequently -10,72.4,72.4 -103,85,99,71,,83.6,83.6 -104,82,79,64,,73.9,73.9 -105,100,100,81,missed homework frequently -10,82.4,82.4 -106,99,87,99,great final presentation +10,100.0,100.0 -107,0,84,93,"cheated on exam, gets 0pts",62.4,62.4 -108,90,81,79,,82.9,82.9 -109,78,0,76,"cheated on exam, gets 0pts",53.8,53.8 -110,92,73,89,,85.1,85.1 -111,74,77,79,missed homework frequently -10,66.9,66.9 -112,98,93,92,,94.1,94.1 -113,87,82,56,,73.1,73.1 -114,96,56,70,,73.6,73.6 -115,85,88,27,,62.7,62.7 -116,81,89,78,missed homework frequently -10,72.2,62.2 -117,77,81,88,great participation +10,92.6,92.6 -118,78,53,96,missed homework frequently -10,67.7,67.7 -119,71,57,96,great participation +10,86.8,86.8 -120,58,97,89,great participation +10,92.1,92.1 -121,53,99,69,missed class frequently -10,63.2,73.2 -122,96,82,86,great participation +10,97.8,97.8 -123,71,90,92,great final presentation +10,95.1,95.1 -124,0,81,97,"cheated on exam, gets 0pts",63.1,63.1 -125,74,94,81,missed homework frequently -10,72.8,72.8 -126,73,73,76,missed class frequently -10,64.2,64.2 -127,0,78,80,"cheated on exam, gets 0pts",55.4,55.4 -128,86,92,86,great participation +10,97.8,97.8 -129,97,94,87,great final presentation +10,100.0,100.0 -130,92,81,97,great final presentation +10,100.0,100.0 -131,93,0,60,"cheated on exam, gets 0pts",51.9,51.9 -132,82,0,79,"cheated on exam, gets 0pts",56.2,56.2 -133,99,62,89,,83.9,83.9 -134,75,0,55,"cheated on exam, gets 0pts",44.5,44.5 -135,77,70,84,,77.7,77.7 -136,84,66,49,great final presentation +10,74.6,74.6 -137,76,81,96,,85.5,85.5 -138,68,63,96,missed class frequently -10,67.7,67.7 -139,71,54,99,missed homework frequently -10,67.1,67.1 -140,84,92,75,missed homework frequently -10,72.8,72.8 -141,90,84,97,great participation +10,100.0,110.0 -142,61,100,94,,85.9,85.9 -143,73,56,91,missed class frequently -10,65.1,65.1 -144,83,88,57,missed homework frequently -10,64.1,74.1 -145,69,77,57,great participation +10,76.6,76.6 -146,79,77,95,great participation +10,94.8,94.8 -147,0,97,90,"cheated on exam, gets 0pts",65.1,65.1 -148,58,68,75,,67.8,67.8 -149,63,82,53,,64.7,64.7 -150,76,78,70,,74.2,74.2 -151,0,82,77,"cheated on exam, gets 0pts",55.4,55.4 -152,91,79,93,great final presentation +10,98.2,98.2 -153,71,65,81,great participation +10,83.2,83.2 -154,71,0,75,"cheated on exam, gets 0pts",51.3,51.3 -155,97,57,67,great participation +10,83.0,83.0 -156,98,77,86,,86.9,86.9 -157,56,80,79,,72.4,72.4 -158,99,90,90,,92.7,92.7 -159,80,83,87,,83.7,83.7 -160,79,75,74,,75.8,75.8 -161,95,81,76,,83.2,83.2 -162,72,87,90,missed class frequently -10,73.7,73.7 -163,72,0,86,"cheated on exam, gets 0pts",56.0,66.0 -164,91,0,94,"cheated on exam, gets 0pts",64.9,64.9 -165,73,84,68,great participation +10,84.3,74.3 -166,0,96,90,"cheated on exam, gets 0pts",64.8,64.8 -167,98,89,71,missed class frequently -10,74.5,74.5 -168,93,65,96,missed class frequently -10,75.8,75.8 -169,79,91,89,missed homework frequently -10,76.6,76.6 -170,89,93,79,,86.2,86.2 -171,96,90,77,,86.6,86.6 -172,0,65,87,"cheated on exam, gets 0pts",54.3,54.3 -173,92,86,78,,84.6,84.6 -174,56,52,78,,63.6,63.6 -175,74,0,85,"cheated on exam, gets 0pts",56.2,66.2 -176,73,80,95,,83.9,83.9 -177,69,93,84,,82.2,82.2 -178,91,99,90,,93.0,93.0 -179,73,92,91,great final presentation +10,95.9,95.9 -180,94,41,91,great participation +10,86.9,86.9 -181,91,96,92,,92.9,92.9 -182,69,94,58,missed homework frequently -10,62.1,62.1 -183,94,79,89,,87.5,87.5 -184,0,92,98,"cheated on exam, gets 0pts",66.8,66.8 -185,89,92,79,,85.9,85.9 -186,92,86,81,,85.8,85.8 -187,82,85,89,,85.7,85.7 -188,82,77,92,missed class frequently -10,74.5,74.5 -189,99,65,87,,84.0,84.0 -190,73,95,67,,77.2,77.2 -191,98,94,90,great participation +10,100.0,100.0 -192,95,78,60,great participation +10,85.9,85.9 -193,90,67,77,missed class frequently -10,67.9,67.9 -194,96,0,90,"cheated on exam, gets 0pts",64.8,64.8 -195,86,80,89,,85.4,85.4 -196,51,78,84,,72.3,72.3 -197,99,75,88,,87.4,87.4 -198,93,58,70,great final presentation +10,83.3,83.3 -199,95,0,72,"cheated on exam, gets 0pts",57.3,57.3 -200,88,71,93,,84.9,84.9 -201,91,92,70,,82.9,82.9 -202,98,92,69,,84.6,74.6 -203,90,0,100,"cheated on exam, gets 0pts",67.0,57.0 -204,89,70,74,,77.3,77.3 -205,97,82,80,,85.7,85.7 -206,78,81,74,missed homework frequently -10,67.3,67.3 -207,77,87,83,,82.4,82.4 -208,86,99,97,,94.3,84.3 -209,92,92,85,great final presentation +10,99.2,99.2 -210,86,80,66,,76.2,76.2 -211,59,70,86,,73.1,73.1 -212,93,75,91,,86.8,86.8 -213,76,54,65,,65.0,65.0 -214,72,78,69,missed homework frequently -10,62.6,62.6 -215,58,90,80,,76.4,76.4 -216,77,84,86,,82.7,82.7 -217,92,66,65,missed homework frequently -10,63.400000000000000,63.400000000000000 -218,88,83,86,great final presentation +10,95.7,95.7 -219,65,0,88,"cheated on exam, gets 0pts",54.7,64.7 -220,89,72,60,great final presentation +10,82.3,82.3 -221,84,79,97,great final presentation +10,97.7,97.7 -222,96,64,65,,74.0,74.0 -223,96,75,92,great final presentation +10,98.1,98.1 -224,62,92,76,,76.6,76.6 -225,94,62,66,,73.2,73.2 -226,85,74,92,,84.5,84.5 -227,73,90,68,missed homework frequently -10,66.1,66.1 -228,81,76,97,great participation +10,95.9,95.9 -229,96,87,80,missed class frequently -10,76.9,76.9 -230,76,65,59,great final presentation +10,75.9,85.9 -231,83,85,90,great participation +10,96.4,96.4 -232,85,100,79,missed class frequently -10,77.1,77.1 -233,75,77,73,missed homework frequently -10,64.8,64.8 -234,84,94,47,missed homework frequently -10,62.2,62.2 -235,84,96,73,great participation +10,93.2,93.2 -236,65,85,50,,65.0,65.0 -237,90,54,80,,75.2,75.2 -238,68,99,99,great final presentation +10,99.7,99.7 -239,95,88,69,,82.5,82.5 -240,0,97,85,"cheated on exam, gets 0pts",63.1,63.1 -241,89,93,70,missed homework frequently -10,72.6,72.6 -242,68,83,76,,75.7,75.7 -243,79,81,89,great final presentation +10,93.6,93.6 -244,73,95,93,,87.6,87.6 -245,87,93,91,great participation +10,100.0,100.0 -246,86,71,68,,74.3,74.3 -247,95,96,64,,82.9,82.9 -248,99,95,67,,85.0,85.0 -249,75,78,97,,84.7,84.7 -250,85,72,70,,75.1,75.1 -251,89,74,85,missed class frequently -10,72.9,72.9 -252,74,94,84,great participation +10,94.0,94.0 -253,95,75,97,great final presentation +10,99.8,99.8 -254,83,93,77,,83.6,73.6 -255,78,58,86,great final presentation +10,85.2,85.2 -256,88,56,80,,75.2,75.2 -257,94,94,72,great participation +10,95.2,95.2 -258,84,87,96,great final presentation +10,99.7,99.7 -259,99,76,95,great participation +10,100.0,100.0 -260,96,94,89,,92.6,92.6 -261,67,80,51,,64.5,64.5 -262,91,92,74,,84.5,84.5 -263,77,96,78,,83.1,83.1 -264,99,86,95,missed class frequently -10,83.5,73.5 -265,72,82,100,great participation +10,96.2,96.2 -266,89,99,73,great final presentation +10,95.6,95.6 -267,67,76,33,,56.1,56.1 -268,46,70,77,,65.6,65.6 -269,46,92,66,,67.8,57.8 -270,87,78,82,missed homework frequently -10,72.3,72.3 -271,80,98,84,great participation +10,97.0,97.0 -272,91,92,95,missed homework frequently -10,82.9,82.9 -273,80,60,80,,74.0,74.0 -274,88,75,59,missed class frequently -10,62.5,62.5 -275,93,73,97,great final presentation +10,98.6,98.6 -276,86,67,76,missed homework frequently -10,66.3,66.3 -277,59,94,80,missed homework frequently -10,67.9,67.9 -278,61,77,88,,76.6,86.6 -279,88,56,82,great participation +10,86.0,86.0 -280,86,89,85,great final presentation +10,96.5,96.5 -281,72,90,98,,87.8,87.8 -282,68,93,73,,77.5,77.5 -283,94,93,91,missed homework frequently -10,82.5,82.5 -284,91,98,97,great participation +10,100.0,100.0 -285,91,0,89,"cheated on exam, gets 0pts",62.9,62.9 -286,58,54,37,,48.4,48.4 -287,93,88,79,missed homework frequently -10,75.9,75.9 -288,0,72,88,"cheated on exam, gets 0pts",56.8,56.8 -289,61,76,87,,75.9,65.9 -290,84,97,99,,93.9,93.9 -291,86,98,95,,93.2,103.2 -292,80,76,66,,73.2,73.2 -293,73,86,40,great final presentation +10,73.7,73.7 -294,0,50,85,"cheated on exam, gets 0pts",49.0,49.0 -295,73,64,87,missed homework frequently -10,65.9,75.9 -296,95,76,41,,67.7,77.7 -297,0,69,90,"cheated on exam, gets 0pts",56.7,56.7 -298,86,45,86,great final presentation +10,83.7,83.7 -299,64,93,70,,75.1,75.1 -300,87,57,76,,73.6,63.600000000000000 -301,61,65,100,missed homework frequently -10,67.8,67.8 -302,87,56,85,,76.9,76.9 -303,83,77,72,missed homework frequently -10,66.8,66.8 -304,78,89,81,,82.5,82.5 -305,95,94,89,,92.3,92.3 -306,84,96,91,great final presentation +10,100.0,90.0 -307,67,93,93,,85.2,95.2 -308,77,79,94,,84.4,84.4 -309,86,74,61,,72.4,72.4 -310,0,71,80,"cheated on exam, gets 0pts",53.3,53.3 -311,79,62,82,,75.1,75.1 -312,66,72,83,missed homework frequently -10,64.6,64.6 -313,79,89,86,great final presentation +10,94.8,94.8 -314,100,98,96,missed homework frequently -10,87.8,87.8 -315,73,82,69,missed class frequently -10,64.1,64.1 -316,76,84,67,,74.8,74.8 -317,0,84,72,"cheated on exam, gets 0pts",54.0,54.0 -318,0,92,56,"cheated on exam, gets 0pts",50.0,50.0 -319,99,83,88,great participation +10,99.8,99.8 -320,91,61,100,,85.6,85.6 -321,83,52,88,missed homework frequently -10,65.7,65.7 -322,83,93,54,,74.4,74.4 -323,0,93,88,"cheated on exam, gets 0pts",63.1,63.1 -324,95,82,54,,74.7,74.7 -325,86,67,98,,85.1,85.1 -326,91,89,83,missed class frequently -10,77.2,77.2 -327,100,73,84,missed homework frequently -10,75.5,75.5 -328,52,95,72,great participation +10,82.9,82.9 -329,64,73,79,great final presentation +10,82.7,82.7 -330,98,51,74,,74.3,74.3 -331,86,91,86,missed class frequently -10,77.5,77.5 -332,97,97,92,missed homework frequently -10,85.0,85.0 -333,88,89,80,missed class frequently -10,75.1,75.1 -334,54,80,81,,72.6,72.6 -335,90,70,68,,75.2,65.2 -336,78,63,75,great final presentation +10,82.3,82.3 -337,93,90,82,,87.7,87.7 -338,66,73,89,,77.3,77.3 -339,82,88,78,great final presentation +10,92.2,92.2 -340,83,87,88,missed homework frequently -10,76.2,86.2 -341,53,100,78,great final presentation +10,87.1,77.1 -342,93,70,97,,87.7,87.7 -343,93,73,82,,82.6,92.6 -344,93,79,97,great participation +10,100.0,100.0 -345,99,86,54,,77.1,77.1 -346,85,80,60,,73.5,73.5 -347,64,86,78,,76.2,76.2 -348,89,97,100,missed class frequently -10,85.8,85.8 -349,95,88,77,,85.7,85.7 -350,96,62,92,great participation +10,94.2,94.2 -351,84,0,80,"cheated on exam, gets 0pts",57.2,57.2 -352,88,71,94,great participation +10,95.3,95.3 -353,92,93,81,,87.9,87.9 -354,93,94,94,,93.7,93.7 -355,86,87,86,missed class frequently -10,76.3,76.3 -356,80,85,84,missed homework frequently -10,73.1,73.1 -357,0,73,89,"cheated on exam, gets 0pts",57.5,57.5 -358,89,78,88,great participation +10,95.3,95.3 -359,66,90,50,,66.8,66.8 -360,81,0,75,"cheated on exam, gets 0pts",54.3,54.3 -361,87,93,76,missed class frequently -10,74.4,74.4 -362,71,76,56,,66.5,66.5 -363,94,70,85,great participation +10,93.2,93.2 -364,90,60,78,,76.2,76.2 -365,66,60,86,,72.2,72.2 -366,73,96,92,,87.5,87.5 -367,0,49,93,"cheated on exam, gets 0pts",51.9,51.9 -368,97,81,100,great participation +10,100.0,100.0 -369,0,54,74,"cheated on exam, gets 0pts",45.8,45.8 -370,86,75,62,,73.1,83.1 -371,89,90,93,great final presentation +10,100.0,100.0 -372,65,94,94,,85.3,85.3 -373,91,99,79,great participation +10,98.6,98.6 -374,69,55,95,,75.2,75.2 -375,77,71,78,,75.6,75.6 -376,99,59,70,missed class frequently -10,65.4,65.4 -377,88,93,92,great final presentation +10,100.0,100.0 -378,81,92,77,,82.7,82.7 -379,84,74,91,great participation +10,93.8,93.8 -380,85,81,87,,84.6,84.6 -381,88,67,92,,83.3,83.3 -382,97,0,94,"cheated on exam, gets 0pts",66.7,66.7 -383,99,67,89,great final presentation +10,95.4,95.4 -384,95,77,87,,86.4,86.4 -385,81,95,77,,83.6,83.6 -386,72,80,69,,73.2,73.2 -387,95,59,90,great participation +10,92.2,92.2 -388,89,95,87,great participation +10,100.0,100.0 -389,81,56,90,great final presentation +10,87.1,87.1 -390,50,67,55,,57.1,57.1 -391,87,0,91,"cheated on exam, gets 0pts",62.5,62.5 -392,79,0,59,"cheated on exam, gets 0pts",47.3,57.3 -393,85,62,75,,74.1,74.1 -394,64,75,90,,77.7,67.7 -395,69,87,94,great participation +10,94.4,94.4 -396,87,77,96,,87.6,87.6 -397,80,92,84,,85.2,85.2 -398,52,80,50,missed class frequently -10,49.6,49.6 -399,83,70,71,,74.3,74.3 -400,77,95,85,,85.6,75.6 -401,72,80,93,,82.8,82.8 -402,89,67,95,great final presentation +10,94.8,84.8 -403,90,87,99,,92.7,92.7 -404,85,79,87,,84.0,84.0 -405,69,95,62,great participation +10,84.0,74.0 -406,69,92,99,missed homework frequently -10,77.9,77.9 -407,97,61,76,missed homework frequently -10,67.8,67.8 -408,0,76,75,"cheated on exam, gets 0pts",52.8,52.8 -409,91,74,88,great participation +10,94.7,94.7 -410,83,92,80,missed class frequently -10,74.5,74.5 -411,82,0,58,"cheated on exam, gets 0pts",47.8,47.8 -412,92,96,90,,92.4,92.4 -413,59,82,61,,66.7,66.7 -414,65,91,72,,75.6,75.6 -415,65,81,75,,73.8,73.8 -416,97,0,92,"cheated on exam, gets 0pts",65.9,65.9 -417,71,86,89,missed class frequently -10,72.7,82.7 -418,94,0,95,"cheated on exam, gets 0pts",66.2,66.2 -419,65,95,68,,75.2,75.2 -420,84,83,60,,74.1,74.1 -421,67,87,95,missed homework frequently -10,74.2,74.2 -422,88,69,100,,87.1,87.1 -423,65,98,93,,86.1,86.1 -424,78,57,85,,74.5,74.5 -425,92,97,44,,74.3,74.3 -426,53,49,88,,65.8,65.8 -427,83,88,88,,86.5,86.5 -428,83,79,93,great participation +10,95.8,95.8 -429,96,91,90,great final presentation +10,100.0,100.0 -430,76,91,100,great participation +10,100.0,100.0 -431,85,92,84,missed homework frequently -10,76.7,76.7 -432,92,90,77,great participation +10,95.4,95.4 -433,83,78,74,,77.9,77.9 -434,97,98,92,,95.3,95.3 -435,88,78,91,great final presentation +10,96.2,96.2 -436,95,41,56,,63.2,53.2 -437,97,86,54,missed homework frequently -10,66.5,66.5 -438,68,73,81,missed class frequently -10,64.7,64.7 -439,94,92,75,great participation +10,95.8,95.8 -440,96,84,74,,83.6,73.6 -441,86,85,89,missed homework frequently -10,76.9,76.9 -442,87,81,86,,84.8,84.8 -443,77,0,87,"cheated on exam, gets 0pts",57.9,57.9 -444,84,83,85,missed class frequently -10,74.1,74.1 -445,0,69,93,"cheated on exam, gets 0pts",57.9,57.9 -446,94,95,90,missed class frequently -10,82.7,82.7 -447,57,78,83,,73.7,73.7 -448,92,74,88,great final presentation +10,95.0,95.0 -449,72,91,92,,85.7,85.7 -450,0,77,81,"cheated on exam, gets 0pts",55.5,45.5 -451,87,83,78,,82.2,82.2 -452,69,85,79,,77.8,77.8 -453,73,74,96,,82.5,82.5 -454,51,65,97,,73.6,73.6 -455,90,99,90,,92.7,92.7 -456,85,0,96,"cheated on exam, gets 0pts",63.9,63.9 -457,71,81,80,,77.6,77.6 -458,88,80,91,missed class frequently -10,76.8,76.8 -459,80,89,88,,85.9,85.9 -460,74,86,93,great participation +10,95.2,95.2 -461,0,72,67,"cheated on exam, gets 0pts",48.4,48.4 -462,89,98,80,great participation +10,98.1,98.1 -463,92,92,76,,85.6,95.6 -464,62,95,52,missed homework frequently -10,57.900000000000000,57.900000000000000 -465,77,78,95,missed homework frequently -10,74.5,74.5 -466,93,91,52,,76.0,76.0 -467,84,97,89,great participation +10,99.9,89.9 -468,94,62,50,missed homework frequently -10,56.8,56.8 -469,56,76,60,,63.6,63.6 -470,80,95,61,,76.9,76.9 -471,90,95,75,great final presentation +10,95.5,95.5 -472,91,92,96,missed class frequently -10,83.3,83.3 -473,66,91,70,missed class frequently -10,65.1,65.1 -474,58,92,93,,82.2,82.2 -475,72,93,98,great participation +10,98.7,98.7 -476,80,96,83,missed homework frequently -10,76.0,76.0 -477,100,69,41,,67.1,67.1 -478,91,98,77,,87.5,87.5 -479,71,77,73,great final presentation +10,83.6,83.6 -480,90,73,91,,85.3,85.3 -481,66,95,86,,82.7,72.7 -482,67,88,89,,82.1,72.1 -483,50,67,94,great final presentation +10,82.7,82.7 -484,84,99,71,,83.3,83.3 -485,80,65,55,,65.5,65.5 -486,67,83,77,,75.8,75.8 -487,94,78,78,,82.8,82.8 -488,72,63,91,great final presentation +10,86.9,86.9 -489,90,94,79,missed homework frequently -10,76.8,76.8 -490,83,90,83,,85.1,85.1 -491,74,79,92,missed homework frequently -10,72.7,72.7 -492,93,75,93,,87.6,87.6 -493,72,88,96,,86.4,76.4 -494,90,100,89,great participation +10,100.0,100.0 -495,72,92,85,great participation +10,93.2,93.2 -496,60,92,55,,67.6,67.6 -497,83,79,67,,75.4,75.4 -498,93,96,94,great final presentation +10,100.0,100.0 -499,63,68,84,,72.9,72.9 -500,77,88,82,missed homework frequently -10,72.3,72.3 -501,94,82,97,great final presentation +10,100.0,100.0 -502,69,86,97,missed homework frequently -10,75.3,75.3 -503,90,77,99,great participation +10,99.7,99.7 -504,0,99,92,"cheated on exam, gets 0pts",66.5,66.5 -505,93,82,88,,87.7,87.7 -506,86,86,85,missed class frequently -10,75.6,75.6 -507,76,92,64,great participation +10,86.0,86.0 -508,94,97,93,great participation +10,100.0,100.0 -509,89,71,94,,85.6,85.6 -510,89,57,47,,62.6,62.6 -511,96,69,92,,86.3,86.3 -512,91,74,88,,84.7,84.7 -513,85,100,78,,86.7,86.7 -514,85,0,59,"cheated on exam, gets 0pts",49.1,49.1 -515,81,94,82,,85.3,85.3 -516,87,64,94,,82.9,82.9 -517,68,56,98,great final presentation +10,86.4,86.4 -518,56,79,85,,74.5,74.5 -519,81,63,59,missed class frequently -10,56.8,56.8 -520,88,83,83,,84.5,84.5 -521,85,93,84,,87.0,87.0 -522,87,79,82,great final presentation +10,92.6,92.6 -523,92,87,60,great participation +10,87.7,87.7 -524,81,97,100,,93.4,93.4 -525,78,85,84,,82.5,92.5 -526,94,83,88,great final presentation +10,98.3,98.3 -527,0,97,88,"cheated on exam, gets 0pts",64.3,64.3 -528,96,64,93,great final presentation +10,95.2,85.2 -529,69,87,51,,67.2,67.2 -530,81,67,100,great participation +10,94.4,94.4 -531,81,87,60,missed class frequently -10,64.4,64.4 -532,66,83,77,,75.5,75.5 -533,76,72,100,great final presentation +10,94.4,94.4 -534,92,73,85,great final presentation +10,93.5,93.5 -535,80,85,93,great participation +10,96.7,96.7 -536,86,81,88,great final presentation +10,95.3,95.3 -537,56,75,71,,67.7,67.7 -538,72,0,76,"cheated on exam, gets 0pts",52.0,52.0 -539,62,64,63,,63.0,63.0 -540,75,0,65,"cheated on exam, gets 0pts",48.5,48.5 -541,89,65,74,missed homework frequently -10,65.8,65.8 -542,91,0,68,"cheated on exam, gets 0pts",54.5,54.5 -543,72,81,80,,77.9,77.9 -544,87,72,50,great final presentation +10,77.7,77.7 -545,73,96,100,great participation +10,100.0,100.0 -546,78,94,83,,84.8,84.8 -547,94,82,83,,86.0,86.0 -548,95,83,100,,93.4,93.4 -549,76,83,86,,82.1,82.1 -550,93,56,74,,74.3,74.3 -551,91,75,100,great participation +10,99.8,99.8 -552,82,94,85,,86.8,86.8 -553,83,79,92,missed homework frequently -10,75.4,75.4 -554,92,44,66,,67.2,67.2 -555,78,0,86,"cheated on exam, gets 0pts",57.8,57.8 -556,80,96,80,,84.8,84.8 -557,87,48,91,,76.9,76.9 -558,78,89,68,,77.3,77.3 -559,100,100,99,,99.6,99.6 -560,43,0,85,"cheated on exam, gets 0pts",46.9,36.9 -561,0,89,90,"cheated on exam, gets 0pts",62.7,62.7 -562,88,74,96,great final presentation +10,97.0,97.0 -563,81,98,96,,92.1,92.1 -564,84,92,86,,87.2,87.2 -565,83,86,85,missed homework frequently -10,74.7,74.7 -566,67,98,65,missed homework frequently -10,65.5,65.5 -567,0,95,94,"cheated on exam, gets 0pts",66.1,66.1 -568,84,99,47,great final presentation +10,83.7,83.7 -569,91,98,75,missed class frequently -10,76.7,76.7 -570,85,91,83,great participation +10,96.0,96.0 -571,92,50,87,,77.4,77.4 -572,99,84,82,missed class frequently -10,77.7,77.7 -573,87,74,86,missed homework frequently -10,72.7,62.7 -574,71,64,62,great participation +10,75.3,75.3 -575,90,96,71,missed class frequently -10,74.2,84.2 -576,61,54,100,,74.5,74.5 -577,74,48,74,,66.2,66.2 -578,98,68,58,,73.0,73.0 -579,92,87,49,,73.3,73.3 -580,70,75,99,,83.1,83.1 -581,80,0,99,"cheated on exam, gets 0pts",63.6,63.6 -582,66,83,96,,83.1,83.1 -583,69,49,75,,65.4,65.4 -584,93,95,67,,83.2,83.2 -585,87,85,77,,82.4,82.4 -586,82,68,48,,64.2,64.2 -587,75,90,93,,86.7,76.7 -588,67,92,64,,73.3,73.3 -589,98,97,93,,95.7,95.7 -590,73,93,86,,84.2,74.2 -591,58,0,71,"cheated on exam, gets 0pts",45.8,45.8 -592,97,94,76,,87.7,87.7 -593,92,99,87,missed homework frequently -10,82.1,82.1 -594,73,87,92,,84.8,84.8 -595,79,60,84,,75.3,75.3 -596,62,54,71,,63.2,63.2 -597,98,97,68,missed homework frequently -10,75.7,75.7 -598,41,80,93,,73.5,73.5 -599,91,90,81,great participation +10,96.7,96.7 -600,96,83,73,great final presentation +10,92.9,92.9 -601,98,88,95,,93.8,93.8 -602,83,80,86,,83.3,83.3 -603,86,90,80,great final presentation +10,94.8,94.8 -604,90,67,77,missed class frequently -10,67.9,67.9 -605,59,68,65,,64.1,64.1 -606,76,85,74,,77.9,77.9 -607,71,89,96,great final presentation +10,96.4,96.4 -608,82,68,80,,77.0,77.0 -609,57,74,86,,73.7,73.7 -610,91,97,96,,94.8,94.8 -611,89,75,64,great final presentation +10,84.8,84.8 -612,69,87,70,missed homework frequently -10,64.8,64.8 -613,90,66,96,great final presentation +10,95.2,95.2 -614,92,0,71,"cheated on exam, gets 0pts",56.0,56.0 -615,71,89,90,,84.0,84.0 -616,53,0,76,"cheated on exam, gets 0pts",46.3,46.3 -617,90,79,89,,86.3,86.3 -618,92,95,92,,92.9,92.9 -619,81,100,74,,83.9,83.9 -620,92,71,93,great participation +10,96.1,96.1 -621,0,87,94,"cheated on exam, gets 0pts",63.7,63.7 -622,54,76,96,,77.4,67.4 -623,86,67,80,,77.9,77.9 -624,94,79,58,great final presentation +10,85.1,95.1 -625,57,89,55,,65.8,65.8 -626,81,81,91,,85.0,85.0 -627,71,94,89,,85.1,85.1 -628,95,83,83,,86.6,86.6 -629,99,87,71,,84.2,84.2 -630,81,86,95,great participation +10,98.1,98.1 -631,94,78,89,,87.2,87.2 -632,99,73,84,missed homework frequently -10,75.2,75.2 -633,56,90,71,missed class frequently -10,62.2,62.2 -634,79,83,92,,85.4,85.4 -635,94,77,82,great participation +10,94.1,94.1 -636,100,62,61,missed class frequently -10,63.0,63.0 -637,88,92,83,,87.2,87.2 -638,89,86,90,great final presentation +10,98.5,98.5 -639,81,71,54,missed homework frequently -10,57.2,67.2 -640,93,53,77,,74.6,74.6 -641,92,0,61,"cheated on exam, gets 0pts",52.0,52.0 -642,89,77,68,,77.0,77.0 -643,96,98,92,great final presentation +10,100.0,90.0 -644,79,98,84,,86.7,86.7 -645,93,47,79,great participation +10,83.6,83.6 -646,92,93,73,missed homework frequently -10,74.7,74.7 -647,67,69,84,missed class frequently -10,64.4,64.4 -648,94,79,79,great participation +10,93.5,93.5 -649,95,73,57,great final presentation +10,83.2,83.2 -650,91,91,78,great final presentation +10,95.8,95.8 -651,81,69,95,,83.0,73.0 -652,80,76,96,missed class frequently -10,75.2,75.2 -653,76,82,91,great final presentation +10,93.8,93.8 -654,78,95,54,missed homework frequently -10,63.5,63.5 -655,86,96,100,,94.6,104.6 -656,97,98,63,missed class frequently -10,73.7,73.7 -657,98,75,89,great final presentation +10,97.5,97.5 -658,79,73,72,,74.4,74.4 -659,38,86,75,great final presentation +10,77.2,77.2 -660,83,74,97,,85.9,95.9 -661,78,95,87,,86.7,76.7 -662,0,79,65,"cheated on exam, gets 0pts",49.7,49.7 -663,89,66,90,,82.5,82.5 -664,81,96,96,great participation +10,100.0,100.0 -665,68,65,89,,75.5,75.5 -666,86,85,89,,86.9,86.9 -667,99,99,87,,94.2,94.2 -668,60,66,64,great final presentation +10,73.4,73.4 -669,68,95,90,,84.9,84.9 -670,79,81,69,,75.6,75.6 -671,95,69,83,missed homework frequently -10,72.4,72.4 -672,68,0,38,"cheated on exam, gets 0pts",35.6,45.6 -673,93,82,85,missed homework frequently -10,76.5,76.5 -674,80,85,86,missed homework frequently -10,73.9,73.9 -675,0,87,99,"cheated on exam, gets 0pts",65.7,65.7 -676,96,79,92,great participation +10,99.3,99.3 -677,95,82,76,,83.5,93.5 -678,89,81,64,missed class frequently -10,66.6,66.6 -679,70,50,75,missed class frequently -10,56.0,56.0 -680,91,97,53,great participation +10,87.6,87.6 -681,65,94,92,,84.5,84.5 -682,64,91,97,,85.3,85.3 -683,94,90,90,great participation +10,100.0,100.0 -684,85,82,55,great participation +10,82.1,82.1 -685,88,91,80,,85.7,85.7 -686,99,95,99,great participation +10,100.0,100.0 -687,66,0,78,"cheated on exam, gets 0pts",51.0,51.0 -688,49,77,89,great participation +10,83.4,83.4 -689,88,69,89,,82.7,82.7 -690,77,54,70,,67.3,67.3 -691,74,80,90,,82.2,82.2 -692,86,97,95,,92.9,92.9 -693,97,88,74,great participation +10,95.1,95.1 -694,84,55,53,missed class frequently -10,52.9,52.9 -695,0,96,87,"cheated on exam, gets 0pts",63.6,63.6 -696,89,74,85,,82.9,72.9 -697,55,71,98,missed homework frequently -10,67.0,67.0 -698,78,76,72,,75.0,75.0 -699,99,77,81,great final presentation +10,95.2,95.2 -700,78,63,88,,77.5,77.5 -701,96,76,85,,85.6,85.6 -702,88,88,83,missed class frequently -10,76.0,76.0 -703,89,85,87,great final presentation +10,97.0,97.0 -704,89,78,94,,87.7,87.7 -705,93,81,77,great participation +10,93.0,93.0 -706,71,96,65,missed class frequently -10,66.1,66.1 -707,70,96,32,missed homework frequently -10,52.6,52.6 -708,95,87,82,missed class frequently -10,77.4,77.4 -709,81,56,58,,64.3,64.3 -710,91,69,90,,84.0,94.0 -711,97,84,87,great participation +10,99.1,89.1 -712,61,0,97,"cheated on exam, gets 0pts",57.1,57.1 -713,70,99,90,,86.7,86.7 -714,72,91,91,,85.3,85.3 -715,73,77,73,,74.2,74.2 -716,58,90,100,great participation +10,94.4,94.4 -717,77,51,70,,66.4,66.4 -718,78,58,86,great final presentation +10,85.2,85.2 -719,95,94,89,,92.3,92.3 -720,65,0,95,"cheated on exam, gets 0pts",57.5,67.5 -721,80,0,98,"cheated on exam, gets 0pts",63.2,63.2 -722,65,0,92,"cheated on exam, gets 0pts",56.3,56.3 -723,89,91,57,,76.8,76.8 -724,65,72,86,great participation +10,85.5,85.5 -725,74,81,74,,76.1,76.1 -726,73,68,61,missed homework frequently -10,56.7,56.7 -727,94,91,93,great participation +10,100.0,100.0 -728,66,82,82,missed homework frequently -10,67.2,67.2 -729,92,81,54,,73.5,73.5 -730,78,75,96,,84.3,84.3 -731,81,79,86,,82.4,72.4 -732,78,84,71,,77.0,77.0 -733,84,81,88,,84.7,84.7 -734,97,0,90,"cheated on exam, gets 0pts",65.1,65.1 -735,0,61,84,"cheated on exam, gets 0pts",51.9,51.9 -736,85,94,84,,87.3,87.3 -737,100,82,72,great participation +10,93.4,93.4 -738,64,70,86,,74.6,74.6 -739,68,74,40,missed homework frequently -10,48.6,48.6 -740,90,82,60,missed class frequently -10,65.6,65.6 -741,87,97,99,,94.8,94.8 -742,0,75,78,"cheated on exam, gets 0pts",53.7,53.7 -743,76,74,97,,83.8,83.8 -744,90,88,84,missed homework frequently -10,77.0,77.0 -745,92,72,94,,86.8,86.8 -746,87,83,87,missed class frequently -10,75.8,75.8 -747,87,82,57,,73.5,73.5 -748,70,92,96,missed homework frequently -10,77.0,77.0 -749,94,77,87,,86.1,86.1 -750,84,65,95,missed class frequently -10,72.7,72.7 -751,92,79,98,great final presentation +10,100.0,100.0 -752,53,89,78,,73.8,73.8 -753,0,83,76,"cheated on exam, gets 0pts",55.3,55.3 -754,82,69,75,great final presentation +10,85.3,85.3 -755,88,90,81,missed homework frequently -10,75.8,85.8 -756,52,75,62,great final presentation +10,72.9,72.9 -757,78,89,58,,73.3,73.3 -758,41,88,98,missed class frequently -10,67.9,67.9 -759,93,68,86,missed homework frequently -10,72.7,72.7 -760,92,75,93,missed homework frequently -10,77.3,67.3 -761,53,0,94,"cheated on exam, gets 0pts",53.5,53.5 -762,90,95,68,,82.7,82.7 -763,43,76,91,missed homework frequently -10,62.1,62.1 -764,96,73,89,missed homework frequently -10,76.3,76.3 -765,79,76,98,,85.7,85.7 -766,82,87,82,,83.5,73.5 -767,82,80,98,great final presentation +10,97.8,97.8 -768,93,96,90,,92.7,92.7 -769,88,96,79,great final presentation +10,96.8,86.8 -770,58,66,74,,66.8,66.8 -771,88,81,85,,84.7,84.7 -772,58,80,89,,77.0,77.0 -773,97,76,90,,87.9,87.9 -774,90,74,95,great participation +10,97.2,107.2 -775,79,86,99,great final presentation +10,99.1,99.1 -776,93,36,62,,63.5,63.5 -777,34,91,92,missed homework frequently -10,64.3,64.3 -778,83,62,55,,65.5,65.5 -779,81,75,77,,77.6,77.6 -780,80,77,98,missed class frequently -10,76.3,66.3 -781,99,97,70,,86.8,96.8 -782,83,99,80,,86.6,86.6 -783,80,72,97,,84.4,84.4 -784,0,68,87,"cheated on exam, gets 0pts",55.2,55.2 -785,71,95,45,,67.8,67.8 -786,92,89,82,great final presentation +10,97.1,97.1 -787,89,62,93,,82.5,82.5 -788,67,72,90,missed class frequently -10,67.7,67.7 -789,64,89,91,great final presentation +10,92.3,92.3 -790,0,79,68,"cheated on exam, gets 0pts",50.9,50.9 -791,80,91,60,,75.3,75.3 -792,96,0,62,"cheated on exam, gets 0pts",53.6,53.6 -793,70,92,93,missed homework frequently -10,75.8,75.8 -794,48,50,65,,55.4,55.4 -795,0,89,91,"cheated on exam, gets 0pts",63.1,63.1 -796,91,89,81,,86.4,86.4 -797,99,84,94,,92.5,92.5 -798,94,97,91,,93.7,93.7 -799,84,93,62,missed class frequently -10,67.9,67.9 -800,82,64,80,great final presentation +10,85.8,85.8 -801,78,60,88,great final presentation +10,86.6,86.6 -802,69,55,72,missed homework frequently -10,56.0,56.0 -803,71,92,94,,86.5,86.5 -804,59,84,83,missed class frequently -10,66.1,66.1 -805,74,96,92,missed class frequently -10,77.8,77.8 -806,80,95,58,,75.7,75.7 -807,96,64,92,great final presentation +10,94.8,84.8 -808,0,88,95,"cheated on exam, gets 0pts",64.4,64.4 -809,97,65,85,missed class frequently -10,72.6,62.600000000000000 -810,64,85,97,,83.5,83.5 -811,85,97,86,great participation +10,99.0,109.0 -812,85,96,48,,73.5,73.5 -813,87,58,34,missed homework frequently -10,47.1,47.1 -814,85,82,85,great participation +10,94.1,94.1 -815,93,74,91,,86.5,86.5 -816,58,75,91,missed class frequently -10,66.3,66.3 -817,98,73,83,,84.5,84.5 -818,92,84,92,great participation +10,99.6,99.6 -819,93,88,84,great participation +10,97.9,107.9 -820,88,80,93,,87.6,77.6 -821,72,94,88,,85.0,85.0 -822,58,90,97,,83.2,83.2 -823,70,97,42,,66.9,66.9 -824,73,86,64,,73.3,73.3 -825,76,88,94,great final presentation +10,96.8,96.8 -826,71,96,83,great final presentation +10,93.3,93.3 -827,74,58,92,great final presentation +10,86.4,86.4 -828,78,95,78,,83.1,83.1 -829,49,95,77,,74.0,74.0 -830,85,93,58,,76.6,76.6 -831,91,90,74,,83.9,83.9 -832,98,97,87,,93.3,93.3 -833,74,98,86,,86.0,86.0 -834,94,0,72,"cheated on exam, gets 0pts",57.0,57.0 -835,83,85,92,great final presentation +10,97.2,97.2 -836,85,87,90,,87.6,97.6 -837,65,0,57,"cheated on exam, gets 0pts",42.3,42.3 -838,72,0,80,"cheated on exam, gets 0pts",53.6,53.6 -839,90,76,81,,82.2,82.2 -840,0,65,88,"cheated on exam, gets 0pts",54.7,54.7 -841,89,97,96,missed homework frequently -10,84.2,84.2 -842,84,94,100,great final presentation +10,100.0,100.0 -843,95,80,86,,86.9,86.9 -844,69,90,86,missed homework frequently -10,72.1,72.1 -845,95,90,69,,83.1,83.1 -846,93,98,75,,87.3,87.3 -847,72,85,91,missed homework frequently -10,73.5,73.5 -848,85,74,87,missed homework frequently -10,72.5,72.5 -849,90,82,86,,86.0,86.0 -850,69,86,75,,76.5,76.5 -851,99,75,78,,83.4,83.4 -852,96,95,89,,92.9,102.9 -853,99,93,90,,93.6,93.6 -854,0,92,60,"cheated on exam, gets 0pts",51.6,51.6 -855,85,91,84,,86.4,86.4 -856,99,62,90,,84.3,84.3 -857,62,92,95,,84.2,84.2 -858,60,37,62,,53.9,53.9 -859,99,86,74,,85.1,85.1 -860,48,47,84,missed homework frequently -10,52.1,52.1 -861,70,84,76,,76.6,76.6 -862,88,91,53,,74.9,74.9 -863,100,83,74,,84.5,94.5 -864,74,61,87,,75.3,75.3 -865,98,71,93,,87.9,87.9 -866,51,75,87,,72.6,82.6 -867,98,85,82,great final presentation +10,97.7,87.7 -868,97,0,42,"cheated on exam, gets 0pts",45.9,45.9 -869,83,91,63,,77.4,77.4 -870,82,61,87,great participation +10,87.7,87.7 -871,92,84,62,,77.6,77.6 -872,86,89,82,,85.3,85.3 -873,73,74,76,missed class frequently -10,64.5,64.5 -874,87,0,96,"cheated on exam, gets 0pts",64.5,64.5 -875,52,86,87,,76.2,76.2 -876,71,94,95,great final presentation +10,97.5,97.5 -877,82,90,85,,85.6,85.6 -878,96,96,88,,92.8,92.8 -879,66,95,87,great final presentation +10,93.1,93.1 -880,68,80,74,,74.0,84.0 -881,53,89,88,great final presentation +10,87.8,87.8 -882,80,96,81,,85.2,85.2 -883,65,69,69,,67.8,77.8 -884,70,96,81,great final presentation +10,92.2,92.2 -885,86,85,84,missed class frequently -10,74.9,74.9 -886,64,85,97,missed class frequently -10,73.5,73.5 -887,87,0,70,"cheated on exam, gets 0pts",54.1,44.1 -888,94,90,99,missed class frequently -10,84.8,74.8 -889,66,74,80,missed class frequently -10,64.0,64.0 -890,62,98,93,great participation +10,95.2,95.2 -891,0,63,88,"cheated on exam, gets 0pts",54.1,54.1 -892,82,99,82,,87.1,87.1 -893,85,90,80,missed homework frequently -10,74.5,74.5 -894,78,73,98,,84.5,84.5 -895,91,68,88,,82.9,82.9 -896,65,84,58,great participation +10,77.9,87.9 -897,84,58,88,missed class frequently -10,67.8,67.8 -898,70,71,88,great final presentation +10,87.5,77.5 -899,71,78,80,great final presentation +10,86.7,86.7 -900,85,68,76,great participation +10,86.3,76.3 -901,94,78,96,great participation +10,100.0,100.0 -902,100,100,87,missed homework frequently -10,84.8,84.8 -903,96,73,94,great participation +10,98.3,98.3 -904,67,88,91,,82.9,82.9 -905,79,84,64,great final presentation +10,84.5,84.5 -906,86,87,77,,82.7,82.7 -907,83,94,78,missed homework frequently -10,74.3,64.3 -908,97,90,72,,84.9,84.9 -909,75,70,75,,73.5,73.5 -910,83,71,70,great participation +10,84.2,84.2 -911,87,76,72,,77.7,77.7 -912,73,58,57,great participation +10,72.1,72.1 -913,65,82,83,missed homework frequently -10,67.3,67.3 -914,69,72,89,,77.9,77.9 -915,100,91,83,great participation +10,100.0,100.0 -916,78,71,94,,82.3,82.3 -917,61,78,64,,67.3,67.3 -918,100,93,70,,85.9,85.9 -919,85,88,81,,84.3,84.3 -920,92,67,65,missed class frequently -10,63.7,63.7 -921,97,86,68,missed homework frequently -10,72.1,62.100000000000000 -922,89,95,73,,84.4,84.4 -923,87,80,65,great final presentation +10,86.1,86.1 -924,92,0,94,"cheated on exam, gets 0pts",65.2,65.2 -925,81,0,95,"cheated on exam, gets 0pts",62.3,62.3 -926,82,69,92,,82.1,82.1 -927,74,73,77,great final presentation +10,84.9,84.9 -928,75,67,78,great final presentation +10,83.8,83.8 -929,80,59,86,,76.1,76.1 -930,79,92,90,missed class frequently -10,77.3,77.3 -931,67,63,83,great participation +10,82.2,82.2 -932,88,88,79,,84.4,84.4 -933,76,87,60,missed homework frequently -10,62.900000000000000,62.900000000000000 -934,0,79,65,"cheated on exam, gets 0pts",49.7,49.7 -935,65,93,88,great final presentation +10,92.6,92.6 -936,73,71,83,,76.4,76.4 -937,73,64,88,,76.3,76.3 -938,94,88,79,great participation +10,96.2,106.2 -939,93,71,89,,84.8,84.8 -940,67,0,76,"cheated on exam, gets 0pts",50.5,50.5 -941,79,73,78,,76.8,76.8 -942,84,76,65,missed class frequently -10,64.0,64.0 -943,47,77,88,,72.4,72.4 -944,74,65,85,,75.7,75.7 -945,84,90,100,,92.2,92.2 -946,84,87,77,,82.1,82.1 -947,90,0,88,"cheated on exam, gets 0pts",62.2,72.2 -948,84,85,61,,75.1,75.1 -949,93,82,74,,82.1,72.1 -950,57,85,86,,77.0,77.0 -951,94,0,89,"cheated on exam, gets 0pts",63.8,63.8 -952,73,80,95,,83.9,83.9 -953,87,80,91,,86.5,76.5 -954,100,80,78,missed class frequently -10,75.2,75.2 -955,56,81,90,,77.1,77.1 -956,67,65,65,,65.6,65.6 -957,56,97,92,great final presentation +10,92.7,92.7 -958,79,0,75,"cheated on exam, gets 0pts",53.7,53.7 -959,66,95,95,,86.3,96.3 -960,0,79,96,"cheated on exam, gets 0pts",62.1,62.1 -961,88,80,89,,86.0,86.0 -962,87,74,95,missed class frequently -10,76.3,76.3 -963,71,92,83,,82.1,82.1 -964,68,82,97,,83.8,83.8 -965,74,72,97,missed class frequently -10,72.6,72.6 -966,90,92,88,great participation +10,99.8,109.8 -967,79,80,91,,84.1,84.1 -968,42,87,63,great participation +10,73.9,73.9 -969,71,0,82,"cheated on exam, gets 0pts",54.1,54.1 -970,78,48,96,,76.2,76.2 -971,74,85,88,great participation +10,92.9,82.9 -972,85,94,75,missed class frequently -10,73.7,63.7 -973,88,79,98,great final presentation +10,99.3,99.3 -974,37,83,69,missed homework frequently -10,53.6,53.6 -975,59,37,75,missed homework frequently -10,48.8,38.8 -976,0,97,60,"cheated on exam, gets 0pts",53.1,53.1 -977,74,80,91,,82.6,82.6 -978,88,66,74,,75.8,75.8 \ No newline at end of file From a25b2366d6213554522101ee1311419bac00d06e Mon Sep 17 00:00:00 2001 From: krmayankb Date: Thu, 29 Dec 2022 19:24:15 -0800 Subject: [PATCH 062/258] default, frac_neighbors 0.1 -> 0.5 --- cleanlab/regression/rank.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cleanlab/regression/rank.py b/cleanlab/regression/rank.py index b959e6e423..6a5f6a3a0e 100644 --- a/cleanlab/regression/rank.py +++ b/cleanlab/regression/rank.py @@ -112,7 +112,7 @@ def get_outre_score_for_each_label( predictions: np.ndarray, *, residual_scale: float = 10, - frac_neighbors: float = 0.1, + frac_neighbors: float = 0.5, neighbor_metric: str = "euclidean", ) -> np.ndarray: """Returns OUTRE based label-quality scores. From 6bf61c6c25ef2f8687dbe2583b221795a902f6c2 Mon Sep 17 00:00:00 2001 From: krmayankb Date: Thu, 29 Dec 2022 19:34:54 -0800 Subject: [PATCH 063/258] updated tutorial notebook --- docs/source/tutorials/regression.ipynb | 194 +++---------------------- 1 file changed, 24 insertions(+), 170 deletions(-) diff --git a/docs/source/tutorials/regression.ipynb b/docs/source/tutorials/regression.ipynb index ace4d8aec7..03f0e27925 100644 --- a/docs/source/tutorials/regression.ipynb +++ b/docs/source/tutorials/regression.ipynb @@ -58,35 +58,6 @@ { "cell_type": "code", "execution_count": 1, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Requirement already satisfied: cleanlab in /Users/krmayank/Desktop/Work/cleanlab/fork/cleanlab/ENV/lib/python3.10/site-packages (2.1.1)\n", - "Requirement already satisfied: xgboost in /Users/krmayank/Desktop/Work/cleanlab/fork/cleanlab/ENV/lib/python3.10/site-packages (1.7.2)\n", - "Requirement already satisfied: scikit-learn>=0.18 in /Users/krmayank/Desktop/Work/cleanlab/fork/cleanlab/ENV/lib/python3.10/site-packages (from cleanlab) (1.1.3)\n", - "Requirement already satisfied: pandas>=1.0.0 in /Users/krmayank/Desktop/Work/cleanlab/fork/cleanlab/ENV/lib/python3.10/site-packages (from cleanlab) (1.5.1)\n", - "Requirement already satisfied: numpy>=1.11.3 in /Users/krmayank/Desktop/Work/cleanlab/fork/cleanlab/ENV/lib/python3.10/site-packages (from cleanlab) (1.23.4)\n", - "Requirement already satisfied: termcolor>=1.1.0 in /Users/krmayank/Desktop/Work/cleanlab/fork/cleanlab/ENV/lib/python3.10/site-packages (from cleanlab) (2.1.0)\n", - "Requirement already satisfied: tqdm>=4.53.0 in /Users/krmayank/Desktop/Work/cleanlab/fork/cleanlab/ENV/lib/python3.10/site-packages (from cleanlab) (4.64.1)\n", - "Requirement already satisfied: scipy in /Users/krmayank/Desktop/Work/cleanlab/fork/cleanlab/ENV/lib/python3.10/site-packages (from xgboost) (1.9.3)\n", - "Requirement already satisfied: pytz>=2020.1 in /Users/krmayank/Desktop/Work/cleanlab/fork/cleanlab/ENV/lib/python3.10/site-packages (from pandas>=1.0.0->cleanlab) (2022.6)\n", - "Requirement already satisfied: python-dateutil>=2.8.1 in /Users/krmayank/Desktop/Work/cleanlab/fork/cleanlab/ENV/lib/python3.10/site-packages (from pandas>=1.0.0->cleanlab) (2.8.2)\n", - "Requirement already satisfied: threadpoolctl>=2.0.0 in /Users/krmayank/Desktop/Work/cleanlab/fork/cleanlab/ENV/lib/python3.10/site-packages (from scikit-learn>=0.18->cleanlab) (3.1.0)\n", - "Requirement already satisfied: joblib>=1.0.0 in /Users/krmayank/Desktop/Work/cleanlab/fork/cleanlab/ENV/lib/python3.10/site-packages (from scikit-learn>=0.18->cleanlab) (1.2.0)\n", - "Requirement already satisfied: six>=1.5 in /Users/krmayank/Desktop/Work/cleanlab/fork/cleanlab/ENV/lib/python3.10/site-packages (from python-dateutil>=2.8.1->pandas>=1.0.0->cleanlab) (1.16.0)\n" - ] - } - ], - "source": [ - "!pip install cleanlab xgboost" - ] - }, - { - "cell_type": "code", - "execution_count": 2, "metadata": { "nbsphinx": "hidden" }, @@ -117,13 +88,15 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "import pandas as pd\n", "import matplotlib.pyplot as plt\n", + "from xgboost import XGBRegressor\n", + "from sklearn.model_selection import cross_val_predict\n", "from cleanlab.regression.rank import get_label_quality_scores\n", "\n", "np.set_printoptions(suppress=True)" @@ -178,7 +151,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -216,19 +189,21 @@ "# 2. Import dataset and Generate predictions" ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# fetch the data\n", + "!wget -nc https://cleanlab-public.s3.amazonaws.com/Datasets/student_grades.csv" + ] + }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "File 'student_grades.csv' already there; not retrieving.\n", - "\n" - ] - }, { "data": { "text/html": [ @@ -323,7 +298,7 @@ } ], "source": [ - "!wget -nc https://cleanlab-public.s3.amazonaws.com/Datasets/student_grades.csv\n", + "# Load data\n", "data = pd.read_csv(\"./student_grades.csv\", index_col=0)\n", "data.head()" ] @@ -403,121 +378,22 @@ "Let's start with initializing the model with relevant parameters. As mentioned earlier we are using `xgboost` for this tutorial. To handle categorical variables, we specifically need to set `enable_categorical` flag to `True`. Note that, support for the categorical variable is in the experimental stage and doesn't support the auto-selection of `tree_method`. Therefore, you will need to specify `tree_method` from supported types. More details can be found [here](https://xgboost.readthedocs.io/en/stable/tutorials/categorical.html)." ] }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# using default xgboost cv " - ] - }, { "cell_type": "code", "execution_count": 8, "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", - "
train-rmse-meantrain-rmse-stdtest-rmse-meantest-rmse-std
014.2264951.36156314.1786821.087675
111.8619650.85277512.1019180.589881
210.6461010.62194310.7044870.317186
\n", - "
" - ], - "text/plain": [ - " train-rmse-mean train-rmse-std test-rmse-mean test-rmse-std\n", - "0 14.226495 1.361563 14.178682 1.087675\n", - "1 11.861965 0.852775 12.101918 0.589881\n", - "2 10.646101 0.621943 10.704487 0.317186" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ - "import xgboost \n", - "from xgboost import DMatrix, XGBRegressor\n", - "from xgboost import XGBRegressor\n", - "from sklearn.model_selection import cross_val_predict\n", - "\n", "SEED = 1\n", - "num_boost_round = 1000\n", "num_crossval_folds = 5\n", "\n", - "training_data = DMatrix(X, label=y, enable_categorical=True)\n", - "params = {\"booster\": \"gblinear\", \"objective\": \"reg:squarederror\"}\n", - "\n", - "cross_validation_results = xgboost.cv(params, \n", - " training_data, \n", - " num_boost_round=num_boost_round,\n", - " nfold=num_crossval_folds, \n", - " seed=SEED,\n", - " early_stopping_rounds=5) \n", - "\n", - "display(cross_validation_results.head(3))" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [], - "source": [ - "best_iteration = cross_validation_results['test-rmse-mean'].argmin()\n", - "\n", "model = XGBRegressor(\n", " tree_method= \"hist\",\n", - " n_estimators = best_iteration, \n", + " n_estimators = 100, \n", " enable_categorical = True, \n", " random_state = SEED)\n", "\n", - "# get predictions\n", + "# get predictions using cross-validation\n", "predictions = cross_val_predict(\n", " estimator=model, X=X, y=y, cv=num_crossval_folds, method = \"predict\"\n", ")" @@ -535,7 +411,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -545,12 +421,12 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 10, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -584,40 +460,18 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 11, "metadata": { "nbsphinx": "hidden" }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "OUTRE: 0.9762667538411246\n", - "RESIDUAL: 0.9781736951073335\n" - ] - }, - { - "ename": "ValueError", - "evalue": "Label quality scores did not outperform alternative scores", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn [13], line 20\u001b[0m\n\u001b[1;32m 15\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mValueError\u001b[39;00m(\u001b[39m\"\u001b[39m\u001b[39mLabel quality scores did not perform well enough\u001b[39m\u001b[39m\"\u001b[39m)\n\u001b[1;32m 17\u001b[0m \u001b[39mif\u001b[39;00m roc_auc_score(true_errors, \u001b[39m1\u001b[39m \u001b[39m-\u001b[39m label_quality_scores) \u001b[39m<\u001b[39m\u001b[39m=\u001b[39m roc_auc_score(\n\u001b[1;32m 18\u001b[0m true_errors, \u001b[39m1\u001b[39m \u001b[39m-\u001b[39m label_quality_scores_residual\n\u001b[1;32m 19\u001b[0m ):\n\u001b[0;32m---> 20\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mValueError\u001b[39;00m(\u001b[39m\"\u001b[39m\u001b[39mLabel quality scores did not outperform alternative scores\u001b[39m\u001b[39m\"\u001b[39m)\n", - "\u001b[0;31mValueError\u001b[0m: Label quality scores did not outperform alternative scores" - ] - } - ], + "outputs": [], "source": [ "# Note: This cell is only for docs.cleanlab.ai, if running on local Jupyter or Colab, please ignore it.\n", "from sklearn.metrics import roc_auc_score\n", "\n", "true_errors = (data[\"grade\"] != data[\"true_grade\"]).astype(int)\n", "\n", - "# label_quality_scores = get_label_quality_scores(labels= y, predictions=predictions)\n", - "from cleanlab.regression.rank import get_outre_score_for_each_label\n", - "label_quality_scores = get_outre_score_for_each_label(labels=np.array(y), predictions=predictions, frac_neighbors=0.5)\n", + "label_quality_scores = get_label_quality_scores(labels=y, predictions=predictions)\n", "label_quality_scores_residual = get_label_quality_scores(labels = y, predictions=predictions, method=\"residual\")\n", "\n", "if roc_auc_score(true_errors, 1 - label_quality_scores) < 0.5:\n", From 15bfa43c2a34f4ad1333e3f3f13e44db1883fcf1 Mon Sep 17 00:00:00 2001 From: krmayankb Date: Thu, 29 Dec 2022 22:00:38 -0800 Subject: [PATCH 064/258] review suggestion updated --- docs/source/tutorials/regression.ipynb | 223 +++++++++++++++++++++---- 1 file changed, 189 insertions(+), 34 deletions(-) diff --git a/docs/source/tutorials/regression.ipynb b/docs/source/tutorials/regression.ipynb index 03f0e27925..7903e9ce8d 100644 --- a/docs/source/tutorials/regression.ipynb +++ b/docs/source/tutorials/regression.ipynb @@ -95,11 +95,24 @@ "import numpy as np\n", "import pandas as pd\n", "import matplotlib.pyplot as plt\n", - "from xgboost import XGBRegressor\n", + "from xgboost import XGBRegressor" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "nbsphinx": "hidden" + }, + "outputs": [], + "source": [ + "# This cell is hidden on docs.cleanlab.ai\n", + "from sklearn.metrics import r2_score\n", "from sklearn.model_selection import cross_val_predict\n", "from cleanlab.regression.rank import get_label_quality_scores\n", "\n", - "np.set_printoptions(suppress=True)" + "np.set_printoptions(suppress=True)\n", + "SEED = np.random.RandomState(10203)" ] }, { @@ -151,7 +164,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -191,9 +204,18 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "File 'student_grades.csv' already there; not retrieving.\n", + "\n" + ] + } + ], "source": [ "# fetch the data\n", "!wget -nc https://cleanlab-public.s3.amazonaws.com/Datasets/student_grades.csv" @@ -201,7 +223,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -292,7 +314,7 @@ "4 48 90 91 NaN 77.8 77.8" ] }, - "execution_count": 5, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } @@ -313,12 +335,12 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -329,12 +351,13 @@ ], "source": [ "# Generate true errors\n", - "true_errors_index = np.where(data[\"grade\"] != data[\"true_grade\"])[0]\n", + "true_errors = (data[\"grade\"] != data[\"true_grade\"]).astype(int)\n", + "true_errors_index = np.where(true_errors == 1)[0]\n", "plot_data(\n", " data_x=data[\"exam_3\"],\n", " data_y=data[\"grade\"],\n", " circles=true_errors_index,\n", - " title=\"Messy Regression dataset\",\n", + " title=\"Noisy regression dataset\",\n", " xlabel=\"exam_3 feature\",\n", " ylabel=\"grade (Y value)\",\n", ")" @@ -345,7 +368,123 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "In the above plot, `grade (Y value)` is plotted against one of the features in the dataset (`exam_3`). We have circled the examples that were considered as `true_error` in **Red** . " + "In the above plot, `grade (Y value)` is plotted against one of the features in the dataset (`exam_3`). We have circled the examples that were considered as `true_error` in **Red**. \n", + "\n", + "Let's check some of the errors in next cell. " + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'Errors in dataset:'" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
exam_1exam_2exam_3notestrue_gradegrade
13805965NaN67.777.7
58895979missed homework frequently -1066.056.0
82888082great participation +1093.2103.2
85928771NaN82.172.1
92967779missed class frequently -1073.583.5
\n", + "
" + ], + "text/plain": [ + " exam_1 exam_2 exam_3 notes true_grade grade\n", + "13 80 59 65 NaN 67.7 77.7\n", + "58 89 59 79 missed homework frequently -10 66.0 56.0\n", + "82 88 80 82 great participation +10 93.2 103.2\n", + "85 92 87 71 NaN 82.1 72.1\n", + "92 96 77 79 missed class frequently -10 73.5 83.5" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Some of the error in the dataset\n", + "display(\"Errors in dataset:\", data.loc[true_errors_index].head())\n", + "\n", + "# Dropping ground truth i.e. true_grade \n", + "data = data.drop(columns=[\"true_grade\"])" ] }, { @@ -358,7 +497,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -366,7 +505,7 @@ "data.notes = data.notes.astype(\"category\")\n", "\n", "# xgboost takes data and label seperately, so you will need to divide data accordingly.\n", - "X = data.drop([\"grade\", \"true_grade\"], axis=1)\n", + "X = data.drop(columns=[\"grade\"])\n", "y = data[\"grade\"]" ] }, @@ -380,11 +519,10 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ - "SEED = 1\n", "num_crossval_folds = 5\n", "\n", "model = XGBRegressor(\n", @@ -399,6 +537,32 @@ ")" ] }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "An additional benefit of cross-validation is that it facilitates more reliable evaluation of our model than a single training/validation split." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "R-squared on predictions from cross-validation: 0.902\n" + ] + } + ], + "source": [ + "roc = r2_score(y, predictions)\n", + "print(f\"R-squared on predictions from cross-validation: {roc:.3f}\")" + ] + }, { "attachments": {}, "cell_type": "markdown", @@ -411,7 +575,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ @@ -421,12 +585,12 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 13, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -441,7 +605,7 @@ " data_y=data[\"grade\"],\n", " circles=true_errors_index,\n", " color=label_quality_scores,\n", - " title=\"Messy Regression dataset with label quality scores\",\n", + " title=\"Noisy regression dataset colored by label quality scores\",\n", " colorbar=True,\n", " xlabel=\"exam_3 feature\",\n", " ylabel=\"grade (Y value)\",\n", @@ -460,7 +624,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 14, "metadata": { "nbsphinx": "hidden" }, @@ -469,26 +633,17 @@ "# Note: This cell is only for docs.cleanlab.ai, if running on local Jupyter or Colab, please ignore it.\n", "from sklearn.metrics import roc_auc_score\n", "\n", - "true_errors = (data[\"grade\"] != data[\"true_grade\"]).astype(int)\n", - "\n", "label_quality_scores = get_label_quality_scores(labels=y, predictions=predictions)\n", "label_quality_scores_residual = get_label_quality_scores(labels = y, predictions=predictions, method=\"residual\")\n", "\n", - "if roc_auc_score(true_errors, 1 - label_quality_scores) < 0.5:\n", + "auc = roc_auc_score(true_errors, 1 - label_quality_scores)\n", + "\n", + "if auc <= 0.5:\n", " raise ValueError(\"Label quality scores did not perform well enough\")\n", "\n", - "if roc_auc_score(true_errors, 1 - label_quality_scores) <= roc_auc_score(\n", - " true_errors, 1 - label_quality_scores_residual\n", - "):\n", + "if auc <= roc_auc_score(true_errors, 1 - label_quality_scores_residual):\n", " raise ValueError(\"Label quality scores did not outperform alternative scores\")" ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { From feb5797a66e7c5fe6128c63ff20d2ecf98474333 Mon Sep 17 00:00:00 2001 From: krmayankb Date: Thu, 29 Dec 2022 22:48:02 -0800 Subject: [PATCH 065/258] suggestion in test corrected --- tests/test_regression.py | 8 +------- 1 file changed, 1 insertion(+), 7 deletions(-) diff --git a/tests/test_regression.py b/tests/test_regression.py index 355752dee3..12c70e5aed 100644 --- a/tests/test_regression.py +++ b/tests/test_regression.py @@ -1,13 +1,7 @@ -import numpy as np - -# import pandas as pd import pytest -from typing import Union, Sequence - +import numpy as np from cleanlab.regression import rank -ArrayLike = Union[np.ndarray, Sequence] - # To be used for all the tests labels = np.array([1, 2, 3, 4]) predictions = np.array([1, 3, 4, 5]) From 3a49cfd0c2de9dbefc893cb4ce6fadad75d5115b Mon Sep 17 00:00:00 2001 From: Mayank Kumar Date: Thu, 29 Dec 2022 22:50:45 -0800 Subject: [PATCH 066/258] copyright updated file regression_utils.py Co-authored-by: Jonas Mueller <1390638+jwmueller@users.noreply.github.com> --- cleanlab/internal/regression_utils.py | 19 ++++++++++++++++++- 1 file changed, 18 insertions(+), 1 deletion(-) diff --git a/cleanlab/internal/regression_utils.py b/cleanlab/internal/regression_utils.py index 468edd30f5..3f878615a4 100644 --- a/cleanlab/internal/regression_utils.py +++ b/cleanlab/internal/regression_utils.py @@ -1,5 +1,22 @@ +# Copyright (C) 2017-2022 Cleanlab Inc. +# This file is part of cleanlab. +# +# cleanlab is free software: you can redistribute it and/or modify +# it under the terms of the GNU Affero General Public License as published +# by the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# cleanlab is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU Affero General Public License for more details. +# +# You should have received a copy of the GNU Affero General Public License +# along with cleanlab. If not, see . + + """ -Helper function internally used in cleanlab.regression +Helper functions internally used in cleanlab.regression. """ import numpy as np From cdfa82d05a447de283d77b52adba3f71c7c9dc6e Mon Sep 17 00:00:00 2001 From: Mayank Kumar Date: Thu, 29 Dec 2022 22:54:27 -0800 Subject: [PATCH 067/258] Error message suggestions updated file regression_utils.py Co-authored-by: Jonas Mueller <1390638+jwmueller@users.noreply.github.com> --- cleanlab/internal/regression_utils.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/cleanlab/internal/regression_utils.py b/cleanlab/internal/regression_utils.py index 3f878615a4..d2c353fe57 100644 --- a/cleanlab/internal/regression_utils.py +++ b/cleanlab/internal/regression_utils.py @@ -59,7 +59,7 @@ def assert_valid_inputs( scoring_methods = ["residual", "outre"] if method not in scoring_methods: raise ValueError( - f"Passed method is not among allowed methods. Expected either of {scoring_methods}, got {method}." + f"Specified method '{method}' must be one of: {scoring_methods}." ) # return 1-D numpy array @@ -82,7 +82,7 @@ def check_dimension_and_datatype(check_input: np.ndarray, text: str) -> np.ndarr # Check if input is empty if not check_input.size: - raise ValueError(f"{text} is Empty, check input.") + raise ValueError(f"{text} cannot be empty array.") # Remove axis with length one check_input = np.squeeze(check_input) @@ -95,7 +95,7 @@ def check_dimension_and_datatype(check_input: np.ndarray, text: str) -> np.ndarr # Check if datatype is numeric if not np.issubdtype(check_input.dtype, np.number): - raise ValueError(f"Expected {text} to be Numeric, got {check_input.dtype}.") + raise ValueError(f"Expected {text} to contain numeric values, got values of type {check_input.dtype}.") return check_input @@ -104,4 +104,4 @@ def check_missing_values(check_input: np.ndarray, text: str): """Raise error if there are any missing values in Numpy array.""" if np.isnan(check_input).any(): - raise ValueError(f"{text} has missing values, check input.") + raise ValueError(f"{text} cannot contain missing values.") From 7a25675febac4d29c141140e148f2221eca2a723 Mon Sep 17 00:00:00 2001 From: Mayank Kumar Date: Thu, 29 Dec 2022 23:09:11 -0800 Subject: [PATCH 068/258] Copyright update Update cleanlab/regression/rank.py Co-authored-by: Jonas Mueller <1390638+jwmueller@users.noreply.github.com> --- cleanlab/regression/rank.py | 24 +++++++++++++++++++++++- 1 file changed, 23 insertions(+), 1 deletion(-) diff --git a/cleanlab/regression/rank.py b/cleanlab/regression/rank.py index 6a5f6a3a0e..a3a49c4872 100644 --- a/cleanlab/regression/rank.py +++ b/cleanlab/regression/rank.py @@ -5,7 +5,29 @@ from typing import Dict, Callable from numpy.typing import ArrayLike -""" Generates label quality scores for every sample in regression dataset """ +# Copyright (C) 2017-2022 Cleanlab Inc. +# This file is part of cleanlab. +# +# cleanlab is free software: you can redistribute it and/or modify +# it under the terms of the GNU Affero General Public License as published +# by the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# cleanlab is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU Affero General Public License for more details. +# +# You should have received a copy of the GNU Affero General Public License +# along with cleanlab. If not, see . + + +""" +Methods to score the quality of each label in a regression dataset. These can be used to rank the examples whose Y-value most likely has an error. + +Note: Label quality scores are most accurate when they are computed based on out-of-sample `predictions` from your regression model. +To obtain out-of-sample predictions for every datapoint in your dataset, you can use :ref:`cross-validation `. This is encouraged to get better results. +""" EPS = 1e-30 From f4571b9a14b97c5c589bcd9371faf14adc004cd6 Mon Sep 17 00:00:00 2001 From: krmayankb Date: Thu, 29 Dec 2022 23:22:59 -0800 Subject: [PATCH 069/258] Suggestions from code review 1. dependency restructuring 2. comments added --- cleanlab/regression/rank.py | 16 +++++++++------- 1 file changed, 9 insertions(+), 7 deletions(-) diff --git a/cleanlab/regression/rank.py b/cleanlab/regression/rank.py index a3a49c4872..ea14f536a2 100644 --- a/cleanlab/regression/rank.py +++ b/cleanlab/regression/rank.py @@ -1,10 +1,3 @@ -import numpy as np -from cleanlab.outlier import OutOfDistribution -from sklearn.neighbors import NearestNeighbors -from cleanlab.internal.regression_utils import assert_valid_inputs -from typing import Dict, Callable -from numpy.typing import ArrayLike - # Copyright (C) 2017-2022 Cleanlab Inc. # This file is part of cleanlab. # @@ -29,6 +22,15 @@ To obtain out-of-sample predictions for every datapoint in your dataset, you can use :ref:`cross-validation `. This is encouraged to get better results. """ +from typing import Dict, Callable +import numpy as np +from numpy.typing import ArrayLike +from sklearn.neighbors import NearestNeighbors + +from cleanlab.outlier import OutOfDistribution +from cleanlab.internal.regression_utils import assert_valid_inputs + +# Small value used to prevent division by zero EPS = 1e-30 From 22728d8be16e35acfba0bdc5bbf57ddca666c40a Mon Sep 17 00:00:00 2001 From: krmayankb Date: Thu, 29 Dec 2022 23:27:12 -0800 Subject: [PATCH 070/258] black formatting --- cleanlab/internal/regression_utils.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/cleanlab/internal/regression_utils.py b/cleanlab/internal/regression_utils.py index d2c353fe57..dbf1c22384 100644 --- a/cleanlab/internal/regression_utils.py +++ b/cleanlab/internal/regression_utils.py @@ -58,9 +58,7 @@ def assert_valid_inputs( # Check if method is among allowed scoring method scoring_methods = ["residual", "outre"] if method not in scoring_methods: - raise ValueError( - f"Specified method '{method}' must be one of: {scoring_methods}." - ) + raise ValueError(f"Specified method '{method}' must be one of: {scoring_methods}.") # return 1-D numpy array return valid_labels, valid_predictions @@ -95,7 +93,9 @@ def check_dimension_and_datatype(check_input: np.ndarray, text: str) -> np.ndarr # Check if datatype is numeric if not np.issubdtype(check_input.dtype, np.number): - raise ValueError(f"Expected {text} to contain numeric values, got values of type {check_input.dtype}.") + raise ValueError( + f"Expected {text} to contain numeric values, got values of type {check_input.dtype}." + ) return check_input From 79a509f0d0bcdab86d84c77243d2abc61f38966a Mon Sep 17 00:00:00 2001 From: krmayankb Date: Thu, 29 Dec 2022 23:54:41 -0800 Subject: [PATCH 071/258] import cell correction --- docs/source/tutorials/regression.ipynb | 11 +++++------ 1 file changed, 5 insertions(+), 6 deletions(-) diff --git a/docs/source/tutorials/regression.ipynb b/docs/source/tutorials/regression.ipynb index 7903e9ce8d..a37413bead 100644 --- a/docs/source/tutorials/regression.ipynb +++ b/docs/source/tutorials/regression.ipynb @@ -88,14 +88,17 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "import pandas as pd\n", "import matplotlib.pyplot as plt\n", - "from xgboost import XGBRegressor" + "from xgboost import XGBRegressor\n", + "from sklearn.metrics import r2_score\n", + "from sklearn.model_selection import cross_val_predict\n", + "from cleanlab.regression.rank import get_label_quality_scores" ] }, { @@ -107,10 +110,6 @@ "outputs": [], "source": [ "# This cell is hidden on docs.cleanlab.ai\n", - "from sklearn.metrics import r2_score\n", - "from sklearn.model_selection import cross_val_predict\n", - "from cleanlab.regression.rank import get_label_quality_scores\n", - "\n", "np.set_printoptions(suppress=True)\n", "SEED = np.random.RandomState(10203)" ] From 96d4ae0250f4ad65dc4448dcdd168ea28bd5d4bc Mon Sep 17 00:00:00 2001 From: krmayankb Date: Fri, 30 Dec 2022 09:28:12 -0800 Subject: [PATCH 072/258] estimator update to 10 --- docs/source/tutorials/regression.ipynb | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/source/tutorials/regression.ipynb b/docs/source/tutorials/regression.ipynb index a37413bead..a110f589da 100644 --- a/docs/source/tutorials/regression.ipynb +++ b/docs/source/tutorials/regression.ipynb @@ -526,7 +526,7 @@ "\n", "model = XGBRegressor(\n", " tree_method= \"hist\",\n", - " n_estimators = 100, \n", + " n_estimators = 10, \n", " enable_categorical = True, \n", " random_state = SEED)\n", "\n", @@ -661,7 +661,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.8" + "version": "3.10.8 (main, Oct 13 2022, 09:48:40) [Clang 14.0.0 (clang-1400.0.29.102)]" }, "orig_nbformat": 4, "vscode": { From 1fe5b379de545c0c251a687aae0217e23b13a40b Mon Sep 17 00:00:00 2001 From: krmayankb Date: Fri, 30 Dec 2022 09:51:29 -0800 Subject: [PATCH 073/258] example in docstring updated --- cleanlab/regression/rank.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cleanlab/regression/rank.py b/cleanlab/regression/rank.py index ea14f536a2..d6eb2b468b 100644 --- a/cleanlab/regression/rank.py +++ b/cleanlab/regression/rank.py @@ -74,7 +74,7 @@ def get_label_quality_scores( >>> predictions = np.array([2,2,5,4.1]) >>> label_quality_scores = get_label_quality_scores(labels, predictions) >>> label_quality_scores - array([0.36787944, 1. , 0.13533528, 0.90483742]) + array([0.00323821, 0.33692597, 0.00191686, 0.33692597]) """ # Check if inputs are valid From 56bc77169a88041173f73dd5c15acff6a45a8417 Mon Sep 17 00:00:00 2001 From: krmayankb Date: Fri, 30 Dec 2022 10:27:16 -0800 Subject: [PATCH 074/258] chracterization test added --- tests/test_regression.py | 50 ++++++++++++++++++++++++++-------------- 1 file changed, 33 insertions(+), 17 deletions(-) diff --git a/tests/test_regression.py b/tests/test_regression.py index 12c70e5aed..61741c09be 100644 --- a/tests/test_regression.py +++ b/tests/test_regression.py @@ -4,7 +4,12 @@ # To be used for all the tests labels = np.array([1, 2, 3, 4]) -predictions = np.array([1, 3, 4, 5]) +predictions = np.array([2, 2, 5, 4.1]) + +# Used for characterization tests +expected_score_outre = np.array([0.00323821, 0.33692597, 0.00191686, 0.33692597]) +expected_score_residual = np.array([0.36787944, 1.0, 0.13533528, 0.90483742]) +expected_scores = {"outre": expected_score_outre, "residual": expected_score_residual} # Inputs that are not array like aConstant = 1 @@ -14,6 +19,11 @@ aBool = True +@pytest.fixture +def non_array_input(): + return [aConstant, aString, aDict, aSet, aBool] + + # test with deafault parameters def test_output_shape_type(): scores = rank.get_label_quality_scores(labels=labels, predictions=predictions) @@ -21,24 +31,18 @@ def test_output_shape_type(): assert isinstance(scores, np.ndarray) -@pytest.mark.parametrize( - "aInput", - [aConstant, aString, aDict, aSet, aBool], -) -def test_labels_are_arraylike(aInput): - with pytest.raises(ValueError) as error: - rank.get_label_quality_scores(labels=aInput, predictions=predictions) - assert error.type == ValueError +def test_labels_are_arraylike(non_array_input): + for new_input in non_array_input: + with pytest.raises(ValueError) as error: + rank.get_label_quality_scores(labels=new_input, predictions=predictions) + assert error.type == ValueError -@pytest.mark.parametrize( - "aInput", - [aConstant, aString, aDict, aSet, aBool], -) -def test_predictionns_are_arraylike(aInput): - with pytest.raises(ValueError) as error: - rank.get_label_quality_scores(labels=labels, predictions=aInput) - assert error.type == ValueError +def test_predictionns_are_arraylike(non_array_input): + for new_input in non_array_input: + with pytest.raises(ValueError) as error: + rank.get_label_quality_scores(labels=labels, predictions=new_input) + assert error.type == ValueError # test for input shapes @@ -83,3 +87,15 @@ def test_method_pass_get_label_quality_scores(method): scores = rank.get_label_quality_scores(labels=labels, predictions=predictions, method=method) assert labels.shape == scores.shape assert isinstance(scores, np.ndarray) + + +@pytest.mark.parametrize( + "method", + [ + "residual", + "outre", + ], +) +def test_expected_scores(method): + scores = rank.get_label_quality_scores(labels=labels, predictions=predictions, method=method) + assert np.allclose(scores, expected_scores[method], atol=1e-08) From 3d71ae1ddc923875a769de208a00454bc949e0d1 Mon Sep 17 00:00:00 2001 From: krmayankb Date: Fri, 30 Dec 2022 14:26:19 -0800 Subject: [PATCH 075/258] notebook output cleared --- docs/source/tutorials/regression.ipynb | 273 ++----------------------- 1 file changed, 20 insertions(+), 253 deletions(-) diff --git a/docs/source/tutorials/regression.ipynb b/docs/source/tutorials/regression.ipynb index a110f589da..67b619f056 100644 --- a/docs/source/tutorials/regression.ipynb +++ b/docs/source/tutorials/regression.ipynb @@ -57,7 +57,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": { "nbsphinx": "hidden" }, @@ -88,7 +88,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -103,7 +103,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": { "nbsphinx": "hidden" }, @@ -163,7 +163,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -203,18 +203,9 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "File 'student_grades.csv' already there; not retrieving.\n", - "\n" - ] - } - ], + "outputs": [], "source": [ "# fetch the data\n", "!wget -nc https://cleanlab-public.s3.amazonaws.com/Datasets/student_grades.csv" @@ -222,102 +213,9 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "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", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
exam_1exam_2exam_3notestrue_gradegrade
0537793NaN76.276.2
1816480great participation +1085.585.5
2748897NaN87.487.4
3619478NaN77.777.7
4489091NaN77.877.8
\n", - "
" - ], - "text/plain": [ - " exam_1 exam_2 exam_3 notes true_grade grade\n", - "0 53 77 93 NaN 76.2 76.2\n", - "1 81 64 80 great participation +10 85.5 85.5\n", - "2 74 88 97 NaN 87.4 87.4\n", - "3 61 94 78 NaN 77.7 77.7\n", - "4 48 90 91 NaN 77.8 77.8" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "# Load data\n", "data = pd.read_csv(\"./student_grades.csv\", index_col=0)\n", @@ -334,20 +232,9 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# Generate true errors\n", "true_errors = (data[\"grade\"] != data[\"true_grade\"]).astype(int)\n", @@ -374,110 +261,9 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "'Errors in dataset:'" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "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", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
exam_1exam_2exam_3notestrue_gradegrade
13805965NaN67.777.7
58895979missed homework frequently -1066.056.0
82888082great participation +1093.2103.2
85928771NaN82.172.1
92967779missed class frequently -1073.583.5
\n", - "
" - ], - "text/plain": [ - " exam_1 exam_2 exam_3 notes true_grade grade\n", - "13 80 59 65 NaN 67.7 77.7\n", - "58 89 59 79 missed homework frequently -10 66.0 56.0\n", - "82 88 80 82 great participation +10 93.2 103.2\n", - "85 92 87 71 NaN 82.1 72.1\n", - "92 96 77 79 missed class frequently -10 73.5 83.5" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# Some of the error in the dataset\n", "display(\"Errors in dataset:\", data.loc[true_errors_index].head())\n", @@ -496,7 +282,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -518,7 +304,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -546,17 +332,9 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "R-squared on predictions from cross-validation: 0.902\n" - ] - } - ], + "outputs": [], "source": [ "roc = r2_score(y, predictions)\n", "print(f\"R-squared on predictions from cross-validation: {roc:.3f}\")" @@ -574,7 +352,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -584,20 +362,9 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "plot_data(\n", " data_x=data[\"exam_3\"],\n", @@ -623,7 +390,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "metadata": { "nbsphinx": "hidden" }, From 9bca4151300c83adac674fa98d3dffb8c6029dd6 Mon Sep 17 00:00:00 2001 From: Anish Athalye Date: Sat, 31 Dec 2022 10:36:32 -0500 Subject: [PATCH 076/258] Fix broken link --- docs/source/tutorials/image.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/source/tutorials/image.ipynb b/docs/source/tutorials/image.ipynb index 7f00bae63c..3d065f5d01 100644 --- a/docs/source/tutorials/image.ipynb +++ b/docs/source/tutorials/image.ipynb @@ -240,7 +240,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "As some cleanlab features require scikit-learn compatibility, we adapt the above PyTorch neural net accordingly. [skorch](https://skorch.readthedocs.io) is a convenient package that helps with this. Alternatively, you can also easily wrap an arbitrary model to be scikit-learn compatible as demonstrated [here](https://github.com/cleanlab/cleanlab#use-cleanlab-with-any-model-tensorflow-pytorch-sklearn-xgboost-etc)." + "As some cleanlab features require scikit-learn compatibility, we adapt the above PyTorch neural net accordingly. [skorch](https://skorch.readthedocs.io) is a convenient package that helps with this. Alternatively, you can also easily wrap an arbitrary model to be scikit-learn compatible as demonstrated [here](https://github.com/cleanlab/cleanlab#use-cleanlab-with-any-model-for-most-ml-tasks)." ] }, { From 36b46c195fa20635bd526582fd1ec9124df0a1c2 Mon Sep 17 00:00:00 2001 From: Jonas Mueller <1390638+jwmueller@users.noreply.github.com> Date: Sun, 1 Jan 2023 14:24:53 -0800 Subject: [PATCH 077/258] mention applications beyond label error detection in readme (#580) --- README.md | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index 429c8f5393..80dc4a1f35 100644 --- a/README.md +++ b/README.md @@ -1,6 +1,6 @@ ![](https://raw.githubusercontent.com/cleanlab/assets/master/cleanlab/cleanlab_logo_open_source_transparent_optimized_size.png) -cleanlab automatically finds and fixes errors in any ML dataset. This data-centric AI package facilitates **machine learning with messy, real-world data** by providing **clean lab**els during training. +cleanlab automatically detects problems in a ML dataset. This data-centric AI package facilitates **machine learning with messy, real-world data** by providing **clean lab**els for robust training and flagging errors in your data. ```python @@ -23,6 +23,7 @@ cleanlab.dataset.health_summary(labels, confident_joint=cl.confident_joint) Get started with: [documentation](https://docs.cleanlab.ai/), [tutorials](https://docs.cleanlab.ai/stable/tutorials/image.html), [examples](https://github.com/cleanlab/examples), and [blogs](https://cleanlab.ai/blog/). - Learn to run cleanlab on your data in 5 minutes for classification with: [image](https://docs.cleanlab.ai/stable/tutorials/image.html), [text](https://docs.cleanlab.ai/stable/tutorials/text.html), [audio](https://docs.cleanlab.ai/stable/tutorials/audio.html), or [tabular](https://docs.cleanlab.ai/stable/tutorials/tabular.html) data. +- Use cleanlab to automatically: [find mislabeled data + train robust models](https://docs.cleanlab.ai/stable/tutorials/indepth_overview.html), [detect outliers](https://docs.cleanlab.ai/stable/tutorials/outliers.html), [estimate consensus + annotator-quality for multi-annotator datasets](https://docs.cleanlab.ai/stable/tutorials/multiannotator.html), [decide what data is best to (re)label next](https://github.com/cleanlab/examples/blob/master/active_learning_multiannotator/active_learning.ipynb). [![pypi](https://img.shields.io/pypi/v/cleanlab.svg)](https://pypi.org/pypi/cleanlab/) @@ -160,7 +161,8 @@ cleanlab is useful across a wide variety of Machine Learning tasks. Specific tas 2. [Multi-label classification](https://docs.cleanlab.ai/stable/tutorials/multilabel_classification.html) (e.g. image/document tagging) 3. [Token classification](https://docs.cleanlab.ai/stable/tutorials/token_classification.html) (e.g. entity recognition in text) 4. [Classification with data labeled by multiple annotators](https://docs.cleanlab.ai/stable/tutorials/multiannotator.html) -5. [Out of distribution detection](https://docs.cleanlab.ai/stable/tutorials/outliers.html) +5. [Active learning with multiple annotators](https://github.com/cleanlab/examples/blob/master/active_learning_multiannotator/active_learning.ipynb) (decide which data to label or re-label to improve model most) +6. [Out of distribution detection](https://docs.cleanlab.ai/stable/tutorials/outliers.html) For many other ML tasks, cleanlab can still help you improve your dataset if appropriately applied. From aa1542bd714cc10b45cf7a4e66e7cde9fb38db52 Mon Sep 17 00:00:00 2001 From: Sanjana Date: Mon, 2 Jan 2023 11:33:19 +0530 Subject: [PATCH 078/258] Drop python 3.6 support from dependencies in setup.py (#579) --- .gitignore | 3 ++- setup.py | 9 ++++----- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/.gitignore b/.gitignore index 16915dde28..82fd660bf0 100644 --- a/.gitignore +++ b/.gitignore @@ -119,5 +119,6 @@ venv.bak/ /docs/source/notebooks/spoken_digits /docs/source/notebooks/pretrained_models -# VS Code +# Editor files .vscode/ +.idea/ diff --git a/setup.py b/setup.py index 71b685da50..e4b03739c8 100644 --- a/setup.py +++ b/setup.py @@ -28,7 +28,6 @@ def run(self): # Get version number and store it in __version__ exec(open("cleanlab/version.py").read()) - setup( name="cleanlab", version=__version__, @@ -89,10 +88,10 @@ def run(self): # requirements files see: # https://packaging.python.org/en/latest/discussions/install-requires-vs-requirements/ install_requires=[ - "numpy>=1.11.3", - "scikit-learn>=0.18", + "numpy>=1.20.0", + "scikit-learn>=1.0", "tqdm>=4.53.0", - "pandas>=1.0.0", - "termcolor>=1.1.0", + "pandas>=1.1.5", + "termcolor>=2.0.0", ], ) From 1e078e0e02e2fd5060f266fa07995ae77cfafe14 Mon Sep 17 00:00:00 2001 From: Jonas Mueller <1390638+jwmueller@users.noreply.github.com> Date: Tue, 3 Jan 2023 20:10:10 -0800 Subject: [PATCH 079/258] specify better default values --- cleanlab/regression/rank.py | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/cleanlab/regression/rank.py b/cleanlab/regression/rank.py index d6eb2b468b..c9e9189032 100644 --- a/cleanlab/regression/rank.py +++ b/cleanlab/regression/rank.py @@ -135,7 +135,7 @@ def get_outre_score_for_each_label( labels: np.ndarray, predictions: np.ndarray, *, - residual_scale: float = 10, + residual_scale: float = 5, frac_neighbors: float = 0.5, neighbor_metric: str = "euclidean", ) -> np.ndarray: @@ -152,11 +152,11 @@ def get_outre_score_for_each_label( predictions: np.ndarray Predicted labels in the same format as expected by the :py:func:`get_label_quality_scores ` function. - residual_scale: float, default = 10 - Manipulates scale of the distribution of residual. + residual_scale: float, default = 5 + Multiplicative factor to adjust scale (standard deviation) of the residuals relative to the labels. - frac_neighbors: float, default = 0.1 - Fraction of examples that should be considered as n_neighbors to NearestNeighbors. + frac_neighbors: float, default = 0.5 + Fraction of examples in dataset that should be considered as `n_neighbors` in the ``NearestNeighbors`` object used internally to assess outliers. neighbor_metric: str, default = "euclidean" The parameter is passed to sklearn NearestNeighbors. # TODO add reference to sklearn.NearestNeighbor? From 0d9fee88a9a8cd786f25bdb7441110e0af1b970e Mon Sep 17 00:00:00 2001 From: "Curtis G. Northcutt" Date: Wed, 4 Jan 2023 17:31:16 -0800 Subject: [PATCH 080/258] add maximum line length (#583) and clarify where black settings are found in DEVELOPMENT guide Co-authored-by: Jonas Mueller <1390638+jwmueller@users.noreply.github.com> --- DEVELOPMENT.md | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/DEVELOPMENT.md b/DEVELOPMENT.md index 80063408ba..19a1d739f0 100644 --- a/DEVELOPMENT.md +++ b/DEVELOPMENT.md @@ -100,12 +100,14 @@ examples/run_all_notebooks.sh ## How to style new code contributions -cleanlab follows the [Black](https://black.readthedocs.io/) code style. This is +cleanlab follows the [Black](https://black.readthedocs.io/) code style (see [pyproject.toml](pyproject.toml)). This is enforced by CI, so please format your code by invoking `black` before submitting a pull request. Generally aim to follow the [PEP-8 coding style](https://peps.python.org/pep-0008/). Please do not use wildcard `import *` in any files, instead you should always import the specific functions that you need from a module. +All cleanlab code should have a maximum line length of 100 characters. + ### Pre-commit hook This repo uses the [pre-commit framework](https://pre-commit.com/) to easily From 044c5aa2e4a6e878a96b3e4e821af9e608e22388 Mon Sep 17 00:00:00 2001 From: Jonas Mueller <1390638+jwmueller@users.noreply.github.com> Date: Thu, 5 Jan 2023 12:50:36 -0800 Subject: [PATCH 081/258] ignore flake8 flagging unused submodule imports --- setup.cfg | 1 + 1 file changed, 1 insertion(+) diff --git a/setup.cfg b/setup.cfg index 04a05501c6..b436333936 100644 --- a/setup.cfg +++ b/setup.cfg @@ -5,3 +5,4 @@ per-file-ignores = cleanlab/__init__.py: F401 cleanlab/token_classification/__init__.py: F401 cleanlab/benchmarking/__init__.py: F401 + cleanlab/regression/__init__.py: F401 From 7caed937842cedba91e148a4974cc6cd74276396 Mon Sep 17 00:00:00 2001 From: Ulyana Date: Thu, 5 Jan 2023 21:42:34 -0800 Subject: [PATCH 082/258] Update github actions (#589) update: github actions to v3, codecov to v3, setup-python to v4, setup node v2 to v3, setup cache v2 to v3 --- .github/workflows/ci.yml | 2 +- .github/workflows/gh-pages.yaml | 6 +++--- .github/workflows/links.yml | 2 +- 3 files changed, 5 insertions(+), 5 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 0896e2a082..ec5e8bb98a 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -37,7 +37,7 @@ jobs: pip install tensorflow-cpu - name: Test with coverage run: pytest --verbose --cov=cleanlab/ --cov-config .coveragerc --cov-report=xml - - uses: codecov/codecov-action@v2 + - uses: codecov/codecov-action@v3 typecheck: name: Type check runs-on: ubuntu-latest diff --git a/.github/workflows/gh-pages.yaml b/.github/workflows/gh-pages.yaml index a1f2f84fa7..ae0ce12e53 100644 --- a/.github/workflows/gh-pages.yaml +++ b/.github/workflows/gh-pages.yaml @@ -28,12 +28,12 @@ jobs: sudo tar xzvf pandoc-2.19.2-linux-amd64.tar.gz --strip-components 1 -C /usr/local - name: Setup Python - uses: actions/setup-python@v2 + uses: actions/setup-python@v4 with: python-version: "3.10" - name: Setup Node - uses: actions/setup-node@v2 + uses: actions/setup-node@v3 with: node-version: "16" @@ -45,7 +45,7 @@ jobs: run: echo "::set-output name=dir::$(pip cache dir)" - name: Cache dependencies - uses: actions/cache@v2 + uses: actions/cache@v3 with: path: ${{ steps.pip-cache.outputs.dir }} key: ${{ runner.os }}-pip-${{ hashFiles('**/requirements.txt') }} diff --git a/.github/workflows/links.yml b/.github/workflows/links.yml index fba7abc18c..469100c88e 100644 --- a/.github/workflows/links.yml +++ b/.github/workflows/links.yml @@ -12,7 +12,7 @@ jobs: - run: >- sudo apt-get install -y pandoc - - uses: actions/checkout@v2 + - uses: actions/checkout@v3 - run: | find . -name '*.html' -delete - run: | From 248bb91378773aabb5bf59c26a3c375a8bc85fac Mon Sep 17 00:00:00 2001 From: Hui Wen <45724323+huiwengoh@users.noreply.github.com> Date: Sat, 7 Jan 2023 00:53:02 +0800 Subject: [PATCH 083/258] Revamp text tutorial to use cleanlab Keras wrapper (#584) Co-authored-by: Jonas Mueller <1390638+jwmueller@users.noreply.github.com> --- cleanlab/experimental/keras.py | 39 ++++- docs/source/tutorials/text.ipynb | 263 +++++++++++++------------------ tests/test_frameworks.py | 8 + 3 files changed, 150 insertions(+), 160 deletions(-) diff --git a/cleanlab/experimental/keras.py b/cleanlab/experimental/keras.py index d4d3e8cf03..96f2caf545 100644 --- a/cleanlab/experimental/keras.py +++ b/cleanlab/experimental/keras.py @@ -37,7 +37,9 @@ import tensorflow as tf import numpy as np +import pandas as pd from typing import Callable, Optional +from cleanlab.internal.validation import assert_valid_inputs class KerasWrapperModel: @@ -87,11 +89,26 @@ def get_params(self, deep=True): } def fit(self, X, y=None, **kwargs): - """Note that `X` dataset object must already contain the labels as is required for standard Keras fit. - You can optionally provide the labels again here as argument `y` to be compatible with sklearn, but they are ignored. + """Trains a Keras classifier. + + Parameters + ---------- + X : tf.Dataset or np.array or pd.DataFrame + If `X` is a tensorflow dataset object, it must already contain the labels as is required for standard Keras fit. + + y : np.array or pd.DataFrame, default = None + If `X` is a tensorflow dataset object, you can optionally provide the labels again here as argument `y` to be compatible with sklearn, + but they are ignored. + If `X` is a numpy array or pandas dataframe, the labels have to be passed in using this argument. """ + self.net = self.model(**self.model_kwargs) self.net.compile(**self.compile_kwargs) + + if isinstance(X, (np.ndarray, pd.DataFrame)): + assert_valid_inputs(X, y) + kwargs["y"] = y + self.net.fit(X, **kwargs) def predict_proba(self, X, *, apply_softmax=True, **kwargs): @@ -151,11 +168,25 @@ def get_params(self, deep=True): } def fit(self, X, y=None, **kwargs): - """Note that `X` dataset object must already contain the labels as is required for standard Keras fit. - You can optionally provide the labels again here as argument `y` to be compatible with sklearn, but they are ignored. + """Trains a Sequential Keras classifier. + + Parameters + ---------- + X : tf.Dataset or np.array or pd.DataFrame + If `X` is a tensorflow dataset object, it must already contain the labels as is required for standard Keras fit. + + y : np.array or pd.DataFrame, default = None + If `X` is a tensorflow dataset object, you can optionally provide the labels again here as argument `y` to be compatible with sklearn, + but they are ignored. + If `X` is a numpy array or pandas dataframe, the labels have to be passed in using this argument. """ self.net = tf.keras.models.Sequential(self.layers, self.name) self.net.compile(**self.compile_kwargs) + + if isinstance(X, (np.ndarray, pd.DataFrame)): + assert_valid_inputs(X, y) + kwargs["y"] = y + self.net.fit(X, **kwargs) def predict_proba(self, X, *, apply_softmax=True, **kwargs): diff --git a/docs/source/tutorials/text.ipynb b/docs/source/tutorials/text.ipynb index 3d39c1a936..8ec3ee27be 100644 --- a/docs/source/tutorials/text.ipynb +++ b/docs/source/tutorials/text.ipynb @@ -11,17 +11,15 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "In this 5-minute quickstart tutorial, we use cleanlab to find potential label errors in a text classification dataset of [IMDb movie reviews](https://ai.stanford.edu/~amaas/data/sentiment/). This dataset contains 50,000 text reviews, each labeled with a binary sentiment polarity label indicating whether the review is positive (1) or negative (0). cleanlab will shortlist _hundreds_ of examples that confuse our ML model the most; many of which are potential label errors, edge cases, or otherwise ambiguous examples.\n", + "In this 5-minute quickstart tutorial, we use cleanlab to find potential label errors in a text classification dataset of [IMDB movie reviews](https://ai.stanford.edu/~amaas/data/sentiment/). This dataset contains 50,000 text reviews, each labeled with a binary sentiment polarity label indicating whether the review is positive (1) or negative (0). cleanlab will shortlist _hundreds_ of examples that confuse our ML model the most; many of which are potential label errors, edge cases, or otherwise ambiguous examples.\n", "\n", "**Overview of what we'll do in this tutorial:**\n", "\n", - "- Build a simple TensorFlow & Keras neural net and wrap it with [SciKeras](https://www.adriangb.com/scikeras/) to make it scikit-learn compatible.\n", + "- Build a simple TensorFlow & Keras neural network and wrap it with cleanlab's `KerasWrapperSequential`. This wrapper class makes *any* Keras/Tensorflow model compatible with scikit-learn (and some advanced cleanlab functionality like `CleanLearning` is easier to run with scikit-learn-compatible models).\n", "\n", - "- Use this classifier to compute out-of-sample predicted probabilities, `pred_probs`, via cross validation.\n", + "- Use `CleanLearning` to automatically compute out-of-sample preddicted probabilites and identify potential label errors with the `find_label_issues` method.\n", "\n", - "- Identify potential label errors in the data with cleanlab's `find_label_issues` method.\n", - "\n", - "- Train a more robust version of the same neural net via cleanlab's `CleanLearning` wrapper.\n" + "- Train a more robust version of the same neural network after dropping the identified label errors using `CleanLearning`." ] }, { @@ -32,7 +30,9 @@ "Quickstart\n", "
\n", " \n", - "Already have an sklearn compatible `model`, text `data` and given `labels`? Run the code below to train your `model` and get label issues.\n", + "Already have an sklearn compatible `model`, `data` and given `labels`? Run the code below to train your `model` and get label issues using `CleanLearning`. \n", + " \n", + "You can subsequently use the same `CleanLearning` object to train a more robust model (only trained on the clean data) by calling the `.fit()` method and passing in the `label_issues` found earlier.\n", "\n", "\n", "
\n", @@ -42,10 +42,11 @@ "from cleanlab.classification import CleanLearning\n", "\n", "cl = CleanLearning(model)\n", - "_ = cl.fit(train_data, labels)\n", - "label_issues = cl.get_label_issues()\n", - "preds = cl.predict(test_data) # predictions from a version of your model \n", - " # trained on auto-cleaned data\n", + "label_issues = cl.find_label_issues(train_data, labels) # identify mislabeled examples \n", + " \n", + "cl.fit(train_data, labels, label_issues=label_issues)\n", + "preds = cl.predict(test_data) # predictions from a version of your model \n", + " # trained on auto-cleaned data\n", "\n", "\n", "```\n", @@ -88,7 +89,7 @@ "You can use `pip` to install all packages required for this tutorial as follows:\n", "\n", "```ipython3\n", - "!pip install sklearn tensorflow tensorflow-datasets scikeras\n", + "!pip install sklearn tensorflow tensorflow-datasets\n", "!pip install cleanlab\n", "# Make sure to install the version corresponding to this tutorial\n", "# E.g. if viewing master branch documentation:\n", @@ -106,9 +107,9 @@ "source": [ "# Package installation (hidden on docs.cleanlab.ai).\n", "# If running on Colab, may want to use GPU (select: Runtime > Change runtime type > Hardware accelerator > GPU)\n", - "# Package versions we used: tensorflow==2.9.1 scikeras==0.9.0 scikit-learn==1.1.3 tensorflow_datasets==4.5.2\n", + "# Package versions we used: tensorflow==2.9.1 scikit-learn==1.2.0 tensorflow_datasets==4.5.2\n", "\n", - "dependencies = [\"cleanlab\", \"sklearn\", \"tensorflow\", \"tensorflow_datasets\", \"scikeras\"]\n", + "dependencies = [\"cleanlab\", \"sklearn\", \"tensorflow\", \"tensorflow_datasets\"]\n", "\n", "# Supress outputs that may appear if tensorflow happens to be improperly installed: \n", "import os \n", @@ -148,7 +149,9 @@ "import tensorflow as tf \n", "from tensorflow.keras import layers \n", "import tensorflow_datasets as tfds \n", - "from scikeras.wrappers import KerasClassifier \n", + "\n", + "from cleanlab.classification import CleanLearning\n", + "from cleanlab.experimental.keras import KerasWrapperSequential\n", "\n", "SEED = 123456 # for reproducibility " ] @@ -194,11 +197,11 @@ "outputs": [], "source": [ "%%capture\n", + "raw_train_ds = tfds.load(name=\"imdb_reviews\", split=\"train\", batch_size=-1, as_supervised=True)\n", + "raw_test_ds = tfds.load(name=\"imdb_reviews\", split=\"test\", batch_size=-1, as_supervised=True)\n", "\n", - "raw_full_ds = tfds.load(\n", - " name=\"imdb_reviews\", split=(\"train+test\"), batch_size=-1, as_supervised=True\n", - ")\n", - "raw_full_texts, full_labels = tfds.as_numpy(raw_full_ds)" + "raw_train_texts, train_labels = tfds.as_numpy(raw_train_ds)\n", + "raw_test_texts, test_labels = tfds.as_numpy(raw_test_ds)" ] }, { @@ -207,15 +210,15 @@ "metadata": {}, "outputs": [], "source": [ - "num_classes = len(set(full_labels))\n", - "print(f\"Classes: {set(full_labels)}\")" + "num_classes = len(set(train_labels))\n", + "print(f\"Classes: {set(train_labels)}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Let's print the first example." + "Let's print the first example in the train set." ] }, { @@ -225,18 +228,18 @@ "outputs": [], "source": [ "i = 0\n", - "print(f\"Example Label: {full_labels[i]}\")\n", - "print(f\"Example Text: {raw_full_texts[i]}\")" + "print(f\"Example Label: {train_labels[i]}\")\n", + "print(f\"Example Text: {raw_train_texts[i]}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "The data are stored as two numpy arrays:\n", + "The data is stored as two numpy arrays for each the train and test set:\n", "\n", - "1. `raw_full_texts` for the movie reviews in text format,\n", - "2. `full_labels` for the labels.\n" + "1. `raw_train_texts` and `raw_test_texts` for the movie reviews in text format,\n", + "2. `train_labels` and `test_labels` for the labels.\n" ] }, { @@ -248,8 +251,8 @@ "\n", "You can easily replace the above with your own text dataset, and continue with the rest of the tutorial.\n", "\n", - "Your classes (and entries of `full_labels`) should be represented as integer indices 0, 1, ..., num_classes - 1.\n", - "For example, if your dataset has 7 examples from 3 classes, `full_labels` might be: `np.array([2,0,0,1,2,0,1])`\n", + "Your classes (and entries of `train_labels` / `test_labels`) should be represented as integer indices 0, 1, ..., num_classes - 1.\n", + "For example, if your dataset has 7 examples from 3 classes, `train_labels` might be: `np.array([2,0,0,1,2,0,1])`\n", "\n", "
\n" ] @@ -305,7 +308,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Adapting `vectorize_layer` to the text data creates a mapping of each token (i.e. word) to an integer index. Subsequently, we can vectorize our text data by using this mapping. Finally, we'll also convert our text data into a numpy array as required by cleanlab.\n" + "Adapting `vectorize_layer` to the text data creates a mapping of each token (i.e. word) to an integer index. Note that we only adapt the vectorization on the train set, as it is standard ML practice. \n", + "\n", + "Subsequently, we can vectorize our text data in the train and test sets by using this mapping. " ] }, { @@ -314,25 +319,27 @@ "metadata": {}, "outputs": [], "source": [ - "%%capture\n", + "vectorize_layer.reset_state()\n", + "vectorize_layer.adapt(raw_train_texts)\n", "\n", - "vectorize_layer.adapt(raw_full_texts)\n", - "full_texts = vectorize_layer(raw_full_texts)\n", - "full_texts = full_texts.numpy()" + "train_texts = vectorize_layer(raw_train_texts).numpy()\n", + "test_texts = vectorize_layer(raw_test_texts).numpy()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## 3. Define a classification model and compute out-of-sample predicted probabilities\n" + "## 3. Define a classification model and use cleanlab to find potential label errors\n", + "\n", + "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Here, we build a simple neural network for classification with TensorFlow and Keras.\n" + "Here, we build a simple neural network for classification with TensorFlow and Keras. We will also wrap it with cleanlab's `KerasWrapperSequential` to make it compatible with sklearn (and hence`CleanLearning`). Note: you can wrap *any* existing Keras model this way, by just replacing `keras.Sequential` with `KerasWrapperSequential` in your code. \n" ] }, { @@ -341,9 +348,11 @@ "metadata": {}, "outputs": [], "source": [ - "def get_net():\n", - " net = tf.keras.Sequential(\n", - " [\n", + "def get_nn_model():\n", + " # simply replace `keras.Sequential(` with cleanlab's class in this line to make any keras model sklearn-compatible \n", + " # the rest of your existing keras code does not need to change at all \n", + " model = KerasWrapperSequential( \n", + " [ \n", " tf.keras.Input(shape=(None,), dtype=\"int64\"),\n", " layers.Embedding(max_features + 1, 16),\n", " layers.Dropout(0.2),\n", @@ -351,22 +360,24 @@ " layers.Dropout(0.2),\n", " layers.Dense(num_classes),\n", " layers.Softmax()\n", - " ]\n", - " ) # outputs probability that text belongs to class 1\n", - "\n", - " net.compile(\n", - " optimizer=\"adam\",\n", - " loss=tf.keras.losses.SparseCategoricalCrossentropy(),\n", - " metrics=tf.keras.metrics.CategoricalAccuracy(),\n", + " ], # outputs probability that text belongs to class 1\n", + " compile_kwargs= {\n", + " \"optimizer\":\"adam\",\n", + " \"loss\":tf.keras.losses.SparseCategoricalCrossentropy(),\n", + " \"metrics\":tf.keras.metrics.CategoricalAccuracy(),\n", + " },\n", " )\n", - " return net" + " \n", + " return model" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "As some of cleanlab's feature requires scikit-learn compatibility, we will need to adapt the above TensorFlow & Keras neural net accordingly. [SciKeras](https://www.adriangb.com/scikeras/stable/) is a convenient package that makes this really easy.\n" + "We can define the `CleanLearning` object with the neural network model and use `find_label_issues` to identify potential label errors.\n", + "\n", + "`CleanLearning` provides a wrapper class that can easily be applied to any scikit-learn compatible model, which can be used to find potential label issues or train a more robust model if the original data contains noisy labels." ] }, { @@ -375,39 +386,38 @@ "metadata": {}, "outputs": [], "source": [ - "model = KerasClassifier(get_net(), epochs=10)" + "cv_n_folds = 3 # for efficiency; values like 5 or 10 will generally work better\n", + "num_epochs = 15 " ] }, { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": null, "metadata": {}, + "outputs": [], "source": [ - "To identify label issues, cleanlab requires a probabilistic prediction from your model for every datapoint that should be considered. However these predictions will be _overfit_ (and thus unreliable) for datapoints the model was previously trained on. cleanlab is intended to only be used with **out-of-sample** predicted probabilities, i.e. on datapoints held-out from the model during the training.\n", - "\n", - "K-fold cross-validation is a straightforward way to produce out-of-sample predicted probabilities for every datapoint in the dataset, by training K copies of our model on different data subsets and using each copy to predict on the subset of data it did not see during training. We can obtain cross-validated out-of-sample predicted probabilities from any classifier via a scikit-learn simple wrapper:\n" + "model = get_nn_model()\n", + "cl = CleanLearning(model, cv_n_folds=cv_n_folds)" ] }, { "cell_type": "code", "execution_count": null, - "metadata": {}, + "metadata": { + "scrolled": true + }, "outputs": [], "source": [ - "num_crossval_folds = 3 # for efficiency; values like 5 or 10 will generally work better\n", - "pred_probs = cross_val_predict(\n", - " model,\n", - " full_texts,\n", - " full_labels,\n", - " cv=num_crossval_folds,\n", - " method=\"predict_proba\",\n", - ")" + "label_issues = cl.find_label_issues(X=train_texts, labels=train_labels, clf_kwargs={\"epochs\": num_epochs})" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "An additional benefit of cross-validation is that it facilitates more reliable evaluation of our model than a single training/validation split." + "The `find_label_issues` method above will perform cross validation to compute out-of-sample predicted probabilites for each example, which is used to identify label issues.\n", + "\n", + "This method returns a dataframe containing a label quality score for each example. These numeric scores lie between 0 and 1, where lower scores indicate examples more likely to be mislabeled. The dataframe also contains a boolean column specifying whether or not each example is identified to have a label issue (indicating it is likely mislabeled)." ] }, { @@ -416,22 +426,24 @@ "metadata": {}, "outputs": [], "source": [ - "loss = log_loss(full_labels, pred_probs) # score to evaluate probabilistic predictions, lower values are better\n", - "print(f\"Cross-validated estimate of log loss: {loss:.3f}\")" + "label_issues.head()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## 4. Use cleanlab to find potential label errors\n" + "We can get the subset of examples flagged with label issues, and also sort by label quality score to find the indices of the 10 most likely mislabeled examples in our dataset." ] }, { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": null, "metadata": {}, + "outputs": [], "source": [ - "Based on the given labels and out-of-sample predicted probabilities, cleanlab can quickly help us identify label issues in our dataset. For a dataset with N examples from K classes, the labels should be a 1D array of length N and predicted probabilities should be a 2D (N x K) array. Here we request that the indices of the identified label issues should be sorted by cleanlab's self-confidence score, which measures the quality of each given label via the probability assigned it in our model's prediction.\n" + "identified_issues = label_issues[label_issues[\"is_label_issue\"] == True]\n", + "lowest_quality_labels = label_issues[\"label_quality\"].argsort()[:10].to_numpy()" ] }, { @@ -440,10 +452,9 @@ "metadata": {}, "outputs": [], "source": [ - "from cleanlab.filter import find_label_issues\n", - "\n", - "ranked_label_issues = find_label_issues(\n", - " labels=full_labels, pred_probs=pred_probs, return_indices_ranked_by=\"self_confidence\"\n", + "print(\n", + " f\"cleanlab found {len(identified_issues)} potential label errors in the dataset.\\n\"\n", + " f\"Here are indices of the top 10 most likely errors: \\n {lowest_quality_labels}\"\n", ")" ] }, @@ -454,18 +465,6 @@ "Let's review some of the most likely label errors:\n" ] }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "print(\n", - " f\"cleanlab found {len(ranked_label_issues)} potential label errors.\\n\"\n", - " f\"Here are indices of the top 10 most likely errors: \\n {ranked_label_issues[:10]}\"\n", - ")" - ] - }, { "cell_type": "markdown", "metadata": {}, @@ -481,7 +480,7 @@ "source": [ "def print_as_df(index):\n", " return pd.DataFrame(\n", - " {\"texts\": raw_full_texts[index], \"labels\": full_labels[index]},\n", + " {\"texts\": raw_train_texts[index], \"labels\": train_labels[index]},\n", " [index]\n", " )" ] @@ -514,7 +513,7 @@ "metadata": {}, "outputs": [], "source": [ - "print_as_df(44582)" + "print_as_df(22294)" ] }, { @@ -541,7 +540,7 @@ "metadata": {}, "outputs": [], "source": [ - "print_as_df(10404)" + "print_as_df(5204)" ] }, { @@ -570,7 +569,7 @@ "metadata": {}, "outputs": [], "source": [ - "print_as_df(30151)" + "print_as_df(15079)" ] }, { @@ -584,58 +583,33 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## 5. Train a more robust model from noisy labels\n" + "## 4. Train a more robust model from noisy labels\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Fixing the label issues manually may be time-consuming, but at least cleanlab can filter these noisy examples and train a model on the remaining clean data for you automatically.\n", - "To demonstrate this, we first reload the dataset, this time with separate train and test splits.\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "raw_train_ds = tfds.load(name=\"imdb_reviews\", split=\"train\", batch_size=-1, as_supervised=True)\n", - "raw_test_ds = tfds.load(name=\"imdb_reviews\", split=\"test\", batch_size=-1, as_supervised=True)\n", - "\n", - "raw_train_texts, train_labels = tfds.as_numpy(raw_train_ds)\n", - "raw_test_texts, test_labels = tfds.as_numpy(raw_test_ds)" + "Fixing the label issues manually may be time-consuming, but cleanlab can filter these noisy examples and train a model on the remaining clean data for you automatically.\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "We featurize the raw text using the same `vectorize_layer` as before, but first, reset its state and adapt it only on the train set (as is proper ML practice). We finally convert the vectorized text data in the train/test sets into numpy arrays.\n" + "To establish a baseline, let's first train and evaluate our original neural network model.\n" ] }, { "cell_type": "code", "execution_count": null, - "metadata": {}, + "metadata": { + "scrolled": true + }, "outputs": [], "source": [ - "vectorize_layer.reset_state()\n", - "vectorize_layer.adapt(raw_train_texts)\n", - "\n", - "train_texts = vectorize_layer(raw_train_texts)\n", - "test_texts = vectorize_layer(raw_test_texts)\n", - "\n", - "train_texts = train_texts.numpy()\n", - "test_texts = test_texts.numpy()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Let's now train and evaluate our original neural network model.\n" + "baseline_model = get_nn_model() # note we first re-instantiate the model\n", + "baseline_model.fit(X=train_texts, y=train_labels, epochs=num_epochs)" ] }, { @@ -644,10 +618,7 @@ "metadata": {}, "outputs": [], "source": [ - "model = KerasClassifier(get_net(), epochs=10)\n", - "model.fit(train_texts, train_labels)\n", - "\n", - "preds = model.predict(test_texts)\n", + "preds = baseline_model.predict(test_texts)\n", "acc_og = accuracy_score(test_labels, preds)\n", "print(f\"\\n Test accuracy of original neural net: {acc_og}\")" ] @@ -656,42 +627,22 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "cleanlab provides a wrapper class that can easily be applied to any scikit-learn compatible model. Once wrapped, the resulting model can still be used in the exact same manner, but it will now train more robustly if the data have noisy labels.\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from cleanlab.classification import CleanLearning\n", + "Now that we have a baseline, let's check if using `CleanLearning` improves our test accuracy.\n", "\n", - "model = KerasClassifier(get_net(), epochs=10) # Note we first re-instantiate the model\n", - "cl = CleanLearning(clf=model, seed=SEED) # cl has same methods/attributes as model" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "When we train the cleanlab-wrapped model, the following operations take place: The original model is trained in a cross-validated fashion to produce out-of-sample predicted probabilities. Then, these predicted probabilities are used to identify label issues, which are then removed from the dataset. Finally, the original model is trained once more on the remaining clean subset of the data.\n" + "`CleanLearning` provides a wrapper that can be applied to any scikit-learn compatible model. The resulting model object can be used in the same manner, but it will now train more robustly if the data has noisy labels.\n", + "\n", + "We can use the same `CleanLearning` object defined above, and pass the label issues we already computed into `.fit()` via the `label_issues` argument. This accelerates things; if we did not provide the label issues, then they would be recomputed via cross-validation. After that `CleanLearning` simply deletes the examples with label issues and retrains your model on the remaining data." ] }, { "cell_type": "code", "execution_count": null, - "metadata": {}, + "metadata": { + "scrolled": true + }, "outputs": [], "source": [ - "_ = cl.fit(train_texts, train_labels)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We can get predictions from the resulting cleanlab model and evaluate them, just like we did for our original neural network.\n" + "cl.fit(X=train_texts, labels=train_labels, label_issues=cl.get_label_issues(), clf_kwargs={\"epochs\": num_epochs})" ] }, { @@ -722,8 +673,8 @@ "source": [ "# Note: This cell is only for docs.cleanlab.ai, if running on local Jupyter or Colab, please ignore it.\n", "\n", - "highlighted_indices = [44582, 10404, 30151] # check these examples were found in find_label_issues\n", - "if not all(x in ranked_label_issues for x in highlighted_indices):\n", + "highlighted_indices = [5204, 22294, 15079] # check these examples were found in find_label_issues\n", + "if not all(x in identified_issues.index for x in highlighted_indices):\n", " raise Exception(\"Some highlighted examples are missing from ranked_label_issues.\")\n", "\n", "# Also check that cleanlab has improved prediction accuracy\n", @@ -753,7 +704,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.13" + "version": "3.10.8" } }, "nbformat": 4, diff --git a/tests/test_frameworks.py b/tests/test_frameworks.py index 9d9cdadbdb..09604cc88f 100644 --- a/tests/test_frameworks.py +++ b/tests/test_frameworks.py @@ -151,6 +151,10 @@ def test_tensorflow_sequential(batch_size, shuffle_config, data=DATA, hidden_uni assert issue_indices == data["error_indices"] assert err < 1e-3 + # Test wrapper works with numpy array + cl = CleanLearning(model) + cl.fit(data["X"], data["y"]) + @pytest.mark.skipif("not python_version_ok()", reason="need at least python 3.7") @pytest.mark.parametrize("batch_size,shuffle_config", [(1, 0), (32, 0), (32, 1), (32, 2)]) @@ -197,6 +201,10 @@ def make_model(num_features, num_classes): assert len(set(issue_indices) & set(data["error_indices"])) != 0 assert err < 1e-3 + # Test wrapper works with numpy array + cl = CleanLearning(model) + cl.fit(data["X"], data["y"]) + @pytest.mark.skipif("not python_version_ok()", reason="need at least python 3.7") @pytest.mark.parametrize("batch_size", [1, 32]) From fdfb0290016ed390c553695a03f5e539a4c38ff6 Mon Sep 17 00:00:00 2001 From: Jonas Mueller <1390638+jwmueller@users.noreply.github.com> Date: Fri, 6 Jan 2023 08:55:42 -0800 Subject: [PATCH 084/258] clarify thresholding in issues_from_scores (#582) --- cleanlab/token_classification/rank.py | 12 +++++++++--- docs/source/tutorials/token_classification.ipynb | 4 ++-- 2 files changed, 11 insertions(+), 5 deletions(-) diff --git a/cleanlab/token_classification/rank.py b/cleanlab/token_classification/rank.py index bd7a3f59d0..69fdb13931 100644 --- a/cleanlab/token_classification/rank.py +++ b/cleanlab/token_classification/rank.py @@ -154,9 +154,15 @@ def issues_from_scores( Converts scores output by :py:func:`token_classification.rank.get_label_quality_scores ` to a list of issues of similar format as output by :py:func:`token_classification.filter.find_label_issues `. - Only considers as issues those tokens with label quality score lower than `threshold`. - - Issues are sorted by label quality score, from most severe to least. + Issues are sorted by label quality score, from most to least severe. + + Only considers as issues those tokens with label quality score lower than `threshold`, + so this parameter determines the number of issues that are returned. + This method is intended for converting the most severely mislabeled examples to a format compatible with + ``summary`` methods like :py:func:`token_classification.summary.display_issues `. + This method does not estimate the number of label errors since the `threshold` is arbitrary, + for that instead use :py:func:`token_classification.filter.find_label_issues `, + which estimates the label errors via Confident Learning rather than score thresholding. Parameters ---------- diff --git a/docs/source/tutorials/token_classification.ipynb b/docs/source/tutorials/token_classification.ipynb index 9e261fd57e..938559540d 100644 --- a/docs/source/tutorials/token_classification.ipynb +++ b/docs/source/tutorials/token_classification.ipynb @@ -445,7 +445,7 @@ "id": "a35ef843", "metadata": {}, "source": [ - "### Find issue sentences with particular word \n", + "### Find sentences containing a particular mislabeled word \n", "\n", "You can also only focus on the subset of potentially problematic sentences where a particular token may have been mislabeled." ] @@ -470,7 +470,7 @@ "source": [ "### Sentence label quality score \n", "\n", - "For best reviewing label issues in a token classification dataset, you want to look at sentences one at a time. Here sentences more likely to contain a label error should be ranked earlier. Cleanlab can provide an overall label quality score for each sentence (ranging from 0 to 1) such that lower scores indicate sentences more likely to contain some mislabeled token. We can also obtain label quality scores for each individual token and decide which of these are label issues by thresholding them. This may be a superior approach if high precision (or high recall) is specifically preferred for your label error detection." + "For best reviewing label issues in a token classification dataset, you want to look at sentences one at a time. Here sentences more likely to contain a label error should be ranked earlier. Cleanlab can provide an overall label quality score for each sentence (ranging from 0 to 1) such that lower scores indicate sentences more likely to contain some mislabeled token. We can also obtain label quality scores for each individual token and manually decide which of these are label issues by thresholding them. For automatically estimating which tokens are mislabeled (and the number of label errors), you should use `find_label_issues()` instead. `get_label_quality_scores()` is useful if you only have time to review a few sentences and want to prioritize which, or if you're specifically aiming to detect label errors with high precision (or high recall) rather than overall estimation of the set of mislabeled tokens." ] }, { From d911acc7e89d47b283907d17ce2b3b274009725e Mon Sep 17 00:00:00 2001 From: Hui Wen <45724323+huiwengoh@users.noreply.github.com> Date: Sat, 7 Jan 2023 01:54:01 +0800 Subject: [PATCH 085/258] Remove temp scaling from single annotator case (#590) Co-authored-by: Jonas Mueller <1390638+jwmueller@users.noreply.github.com> --- cleanlab/multiannotator.py | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/cleanlab/multiannotator.py b/cleanlab/multiannotator.py index 214cd8b247..7b57e2e3cd 100644 --- a/cleanlab/multiannotator.py +++ b/cleanlab/multiannotator.py @@ -585,11 +585,10 @@ def get_active_learning_scores( num_classes = get_num_classes(pred_probs=pred_probs) - optimal_temp = find_best_temp_scaler(labels_multiannotator, pred_probs) - pred_probs = temp_scale_pred_probs(pred_probs, optimal_temp) - # if all examples are only labeled by a single annotator if labels_multiannotator.apply(lambda s: len(s.dropna()) == 1, axis=1).all(): + optimal_temp = 1.0 # do not temp scale for single annotator case, temperature is defined here for later use + assert_valid_inputs_multiannotator( labels_multiannotator, pred_probs, allow_single_label=True ) @@ -605,6 +604,9 @@ def get_active_learning_scores( avg_annotator_weight = np.mean(annotator_weight) else: + optimal_temp = find_best_temp_scaler(labels_multiannotator, pred_probs) + pred_probs = temp_scale_pred_probs(pred_probs, optimal_temp) + multiannotator_info = get_label_quality_multiannotator( labels_multiannotator, pred_probs, From fe9efda26933f5650cc256d4e11b686d9b66e73a Mon Sep 17 00:00:00 2001 From: Hui Wen <45724323+huiwengoh@users.noreply.github.com> Date: Sat, 7 Jan 2023 06:22:16 +0800 Subject: [PATCH 086/258] update docs dependencies (#593) --- docs/requirements.txt | 2 -- 1 file changed, 2 deletions(-) diff --git a/docs/requirements.txt b/docs/requirements.txt index 00db3f8b9e..1c944c18a7 100644 --- a/docs/requirements.txt +++ b/docs/requirements.txt @@ -15,8 +15,6 @@ matplotlib==3.5.1 skorch==0.11.0 tensorflow-datasets==4.5.2 tensorflow==2.9.1 -scikeras==0.9.0 -scikit-learn<1.2.0 speechbrain==0.5.12 tensorflow-io==0.26.0 huggingface_hub==0.7 From ebadffdebe4df80dc4c9a210c042c661f31bbc21 Mon Sep 17 00:00:00 2001 From: Ulyana Date: Fri, 6 Jan 2023 21:25:23 -0800 Subject: [PATCH 087/258] Use euclidean distance for identifying outliers for lower dimensional features (#581) Co-authored-by: Jonas Mueller <1390638+jwmueller@users.noreply.github.com> --- cleanlab/outlier.py | 12 ++++++++++-- tests/test_outlier.py | 26 ++++++++++++++++++++++---- 2 files changed, 32 insertions(+), 6 deletions(-) diff --git a/cleanlab/outlier.py b/cleanlab/outlier.py index b2190ada65..ad07691596 100644 --- a/cleanlab/outlier.py +++ b/cleanlab/outlier.py @@ -55,7 +55,8 @@ class OutOfDistribution: You can also pass in a subclass of ``sklearn.neighbors.NearestNeighbors`` which allows you to use faster approximate neighbor libraries as long as you wrap them behind the same sklearn API. If you specify ``knn`` here, there is no need to later call ``fit()`` before calling ``score()``. - If ``knn = None``, then by default: ``knn = sklearn.neighbors.NearestNeighbors(n_neighbors=k, metric="cosine").fit(features)`` + If ``knn = None``, then by default: ``knn = sklearn.neighbors.NearestNeighbors(n_neighbors=k, metric=dist_metric).fit(features)`` + where ``dist_metric == "cosine"`` if ``dim(features) > 3`` or ``dist_metric == "euclidean"`` otherwise. See: https://scikit-learn.org/stable/modules/neighbors.html * k : int, default=None Optional number of neighbors to use when calculating outlier score (average distance to neighbors). @@ -411,8 +412,15 @@ def _get_ood_features_scores( raise ValueError( f"Number of nearest neighbors k={k} cannot exceed the number of examples N={len(features)} passed into the estimator (knn)." ) - knn = NearestNeighbors(n_neighbors=k, metric="cosine").fit(features) + + if features.shape[1] > 3: # use euclidean distance for lower dimensional spaces + metric = "cosine" + else: + metric = "euclidean" + + knn = NearestNeighbors(n_neighbors=k, metric=metric).fit(features) features = None # features should be None in knn.kneighbors(features) to avoid counting duplicate data points + elif k is None: k = knn.n_neighbors diff --git a/tests/test_outlier.py b/tests/test_outlier.py index 545b008de5..6a07f16fdf 100644 --- a/tests/test_outlier.py +++ b/tests/test_outlier.py @@ -270,6 +270,26 @@ def test_class_public_func(): OOD_ood_already_fit.params["confident_thresholds"] == confident_thresholds ).all() # Assert not overwritten + # Testing fit uses correct metrics given feature dimensionality + X_small = np.random.rand(20, 3) + OOD_euclidean = OutOfDistribution() + OOD_euclidean.fit(features=X_small) + assert OOD_euclidean.params["knn"].metric == "euclidean" + X_small_with_ood = np.vstack([X_small, [999999.0] * 3]) + euclidean_score = OOD_euclidean.score(features=X_small_with_ood) + assert (np.max(euclidean_score) <= 1) and (np.min(euclidean_score) >= 0) + assert np.argmin(euclidean_score) == (euclidean_score.shape[0] - 1) + + # Re-run tests with high dimensional dataset + X_large = np.hstack([np.zeros((200, 400)), np.random.rand(200, 1)]) + OOD_cosine = OutOfDistribution() + OOD_cosine.fit(features=X_large) + assert OOD_cosine.params["knn"].metric == "cosine" + X_large_with_ood = np.vstack([X_large, [999999.0] * 401]) + cosine_score = OOD_cosine.score(features=X_large_with_ood) + assert (np.max(cosine_score) <= 1) and (np.min(cosine_score) >= 0) + assert np.argmin(cosine_score) == (cosine_score.shape[0] - 1) + #### TESTING SCORE ood_score = OOD_ood.score(pred_probs=pred_probs) outlier_score = OOD_outlier.score(features=features) @@ -329,14 +349,12 @@ def test_get_ood_features_scores(): X_test_with_ood = np.vstack([X_test, X_ood]) # Fit nearest neighbors on X_train - knn = NearestNeighbors(n_neighbors=5).fit(X_train) - + knn = NearestNeighbors(n_neighbors=5, metric="euclidean").fit(X_train) # Get KNN distance as outlier score k = 5 knn_distance_to_score, _ = outlier._get_ood_features_scores( features=X_test_with_ood, knn=knn, k=k ) - # Checking that X_ood has the smallest outlier score among all the datapoints assert np.argmin(knn_distance_to_score) == (knn_distance_to_score.shape[0] - 1) @@ -376,7 +394,7 @@ def test_default_k_and_model_get_ood_features_scores(): instantiated_k = 10 # Create NN class object with small instantiated k and fit on data - knn = NearestNeighbors(n_neighbors=instantiated_k, metric="cosine").fit(X_with_ood) + knn = NearestNeighbors(n_neighbors=instantiated_k, metric="euclidean").fit(X_with_ood) avg_knn_distances_default_model, _ = outlier._get_ood_features_scores( features=X_with_ood, From 7b589f6d63b8548cef79ffccce35e5d1ea6ccb1c Mon Sep 17 00:00:00 2001 From: Aditya Thyagarajan Date: Sat, 7 Jan 2023 10:55:57 +0530 Subject: [PATCH 088/258] updating copyright year to include 2023 (#594) --- README.md | 2 +- cleanlab/benchmarking/noise_generation.py | 2 +- cleanlab/classification.py | 2 +- cleanlab/count.py | 2 +- cleanlab/dataset.py | 2 +- cleanlab/experimental/cifar_cnn.py | 2 +- cleanlab/experimental/coteaching.py | 2 +- cleanlab/experimental/fasttext.py | 2 +- cleanlab/experimental/keras.py | 10 +++++----- cleanlab/experimental/mnist_pytorch.py | 2 +- cleanlab/filter.py | 2 +- cleanlab/internal/label_quality_utils.py | 2 +- cleanlab/internal/latent_algebra.py | 8 ++++---- cleanlab/internal/multiannotator_utils.py | 2 +- cleanlab/internal/multilabel_scorer.py | 2 +- cleanlab/internal/multilabel_utils.py | 2 +- cleanlab/internal/token_classification_utils.py | 2 +- cleanlab/internal/util.py | 2 +- cleanlab/internal/validation.py | 2 +- cleanlab/multiannotator.py | 2 +- cleanlab/multilabel_classification.py | 2 +- cleanlab/outlier.py | 2 +- cleanlab/rank.py | 2 +- cleanlab/token_classification/filter.py | 2 +- cleanlab/token_classification/rank.py | 2 +- cleanlab/token_classification/summary.py | 2 +- cleanlab/version.py | 2 +- tests/test_classification.py | 2 +- tests/test_dataset.py | 2 +- tests/test_filter_count.py | 2 +- tests/test_frameworks.py | 4 ++-- tests/test_latent_algebra.py | 2 +- tests/test_multilabel_classification.py | 2 +- tests/test_outlier.py | 2 +- tests/test_rank.py | 2 +- 35 files changed, 43 insertions(+), 43 deletions(-) diff --git a/README.md b/README.md index 80dc4a1f35..ad8387034e 100644 --- a/README.md +++ b/README.md @@ -556,7 +556,7 @@ Join our [\#help Slack channel](https://cleanlab.ai/slack) and message one of ou ## License -Copyright (c) 2017-2022 Cleanlab Inc. +Copyright (c) 2017-2023 Cleanlab Inc. cleanlab is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. diff --git a/cleanlab/benchmarking/noise_generation.py b/cleanlab/benchmarking/noise_generation.py index 47937c4453..4c71b57264 100644 --- a/cleanlab/benchmarking/noise_generation.py +++ b/cleanlab/benchmarking/noise_generation.py @@ -1,4 +1,4 @@ -# Copyright (C) 2017-2022 Cleanlab Inc. +# Copyright (C) 2017-2023 Cleanlab Inc. # This file is part of cleanlab. # # cleanlab is free software: you can redistribute it and/or modify diff --git a/cleanlab/classification.py b/cleanlab/classification.py index 3ce2362bcd..407afef0f6 100644 --- a/cleanlab/classification.py +++ b/cleanlab/classification.py @@ -1,4 +1,4 @@ -# Copyright (C) 2017-2022 Cleanlab Inc. +# Copyright (C) 2017-2023 Cleanlab Inc. # This file is part of cleanlab. # # cleanlab is free software: you can redistribute it and/or modify diff --git a/cleanlab/count.py b/cleanlab/count.py index 65db814bfb..ce24e559b4 100644 --- a/cleanlab/count.py +++ b/cleanlab/count.py @@ -1,4 +1,4 @@ -# Copyright (C) 2017-2022 Cleanlab Inc. +# Copyright (C) 2017-2023 Cleanlab Inc. # This file is part of cleanlab. # # cleanlab is free software: you can redistribute it and/or modify diff --git a/cleanlab/dataset.py b/cleanlab/dataset.py index 40e2905a3a..9020b34539 100644 --- a/cleanlab/dataset.py +++ b/cleanlab/dataset.py @@ -1,4 +1,4 @@ -# Copyright (C) 2017-2022 Cleanlab Inc. +# Copyright (C) 2017-2023 Cleanlab Inc. # This file is part of cleanlab. # # cleanlab is free software: you can redistribute it and/or modify diff --git a/cleanlab/experimental/cifar_cnn.py b/cleanlab/experimental/cifar_cnn.py index 15e82d1b8e..13c08d35d3 100644 --- a/cleanlab/experimental/cifar_cnn.py +++ b/cleanlab/experimental/cifar_cnn.py @@ -1,4 +1,4 @@ -# Copyright (C) 2017-2022 Cleanlab Inc. +# Copyright (C) 2017-2023 Cleanlab Inc. # This file is part of cleanlab. # # cleanlab is free software: you can redistribute it and/or modify diff --git a/cleanlab/experimental/coteaching.py b/cleanlab/experimental/coteaching.py index b6247ee57d..8d46f523f5 100644 --- a/cleanlab/experimental/coteaching.py +++ b/cleanlab/experimental/coteaching.py @@ -1,4 +1,4 @@ -# Copyright (C) 2017-2022 Cleanlab Inc. +# Copyright (C) 2017-2023 Cleanlab Inc. # This file is part of cleanlab. # # cleanlab is free software: you can redistribute it and/or modify diff --git a/cleanlab/experimental/fasttext.py b/cleanlab/experimental/fasttext.py index 6247e3cf97..ad1a7923a4 100644 --- a/cleanlab/experimental/fasttext.py +++ b/cleanlab/experimental/fasttext.py @@ -1,4 +1,4 @@ -# Copyright (C) 2017-2022 Cleanlab Inc. +# Copyright (C) 2017-2023 Cleanlab Inc. # This file is part of cleanlab. # # cleanlab is free software: you can redistribute it and/or modify diff --git a/cleanlab/experimental/keras.py b/cleanlab/experimental/keras.py index 96f2caf545..4e34567b47 100644 --- a/cleanlab/experimental/keras.py +++ b/cleanlab/experimental/keras.py @@ -1,4 +1,4 @@ -# Copyright (C) 2017-2022 Cleanlab Inc. +# Copyright (C) 2017-2023 Cleanlab Inc. # This file is part of cleanlab. # # cleanlab is free software: you can redistribute it and/or modify @@ -16,9 +16,9 @@ """ Wrapper class you can use to make any Keras model compatible with :py:class:`CleanLearning ` and sklearn. -Use :py:class:`KerasWrapperModel` to wrap existing functional API code for ``keras.Model`` objects, +Use :py:class:`KerasWrapperModel` to wrap existing functional API code for ``keras.Model`` objects, and :py:class:`KerasWrapperSequential` to wrap existing ``tf.keras.models.Sequential`` objects. -Most of the instance methods of this class work the same as the ones for the wrapped Keras model, +Most of the instance methods of this class work the same as the ones for the wrapped Keras model, see the `Keras documentation `_ for details. This is a good example of making any bespoke neural network compatible with cleanlab. @@ -30,8 +30,8 @@ * If this class lacks certain functionality, you can alternatively try `scikeras `_. * Unlike scikeras, our `KerasWrapper` classes can operate directly on ``tensorflow.data.Dataset`` objects (like regular Keras models). * To call ``fit()`` on a tensorflow ``Dataset`` object with a Keras model, the ``Dataset`` should already be batched. -* Check out our `example `_ using this class: `huggingface_keras_imdb `_ -* Our `unit tests `_ also provide basic usage examples. +* Check out our `example `_ using this class: `huggingface_keras_imdb `_ +* Our `unit tests `_ also provide basic usage examples. """ diff --git a/cleanlab/experimental/mnist_pytorch.py b/cleanlab/experimental/mnist_pytorch.py index bdc9b6ffba..3166b68f16 100644 --- a/cleanlab/experimental/mnist_pytorch.py +++ b/cleanlab/experimental/mnist_pytorch.py @@ -1,4 +1,4 @@ -# Copyright (C) 2017-2022 Cleanlab Inc. +# Copyright (C) 2017-2023 Cleanlab Inc. # This file is part of cleanlab. # # cleanlab is free software: you can redistribute it and/or modify diff --git a/cleanlab/filter.py b/cleanlab/filter.py index 7a65da6622..e507011416 100644 --- a/cleanlab/filter.py +++ b/cleanlab/filter.py @@ -1,4 +1,4 @@ -# Copyright (C) 2017-2022 Cleanlab Inc. +# Copyright (C) 2017-2023 Cleanlab Inc. # This file is part of cleanlab. # # cleanlab is free software: you can redistribute it and/or modify diff --git a/cleanlab/internal/label_quality_utils.py b/cleanlab/internal/label_quality_utils.py index 2fbead808d..7317d134c0 100644 --- a/cleanlab/internal/label_quality_utils.py +++ b/cleanlab/internal/label_quality_utils.py @@ -1,4 +1,4 @@ -# Copyright (C) 2017-2022 Cleanlab Inc. +# Copyright (C) 2017-2023 Cleanlab Inc. # This file is part of cleanlab. # # cleanlab is free software: you can redistribute it and/or modify diff --git a/cleanlab/internal/latent_algebra.py b/cleanlab/internal/latent_algebra.py index 20e1c62de2..af3b0ec177 100644 --- a/cleanlab/internal/latent_algebra.py +++ b/cleanlab/internal/latent_algebra.py @@ -1,4 +1,4 @@ -# Copyright (C) 2017-2022 Cleanlab Inc. +# Copyright (C) 2017-2023 Cleanlab Inc. # This file is part of cleanlab. # # cleanlab is free software: you can redistribute it and/or modify @@ -18,8 +18,8 @@ """ Contains mathematical functions relating the latent terms, ``P(given_label)``, ``P(given_label | true_label)``, ``P(true_label | given_label)``, ``P(true_label)``, etc. together. -For every function here, if the inputs are exact, the output is guaranteed to be exact. -Every function herein is the computational equivalent of a mathematical equation having a closed, exact form. +For every function here, if the inputs are exact, the output is guaranteed to be exact. +Every function herein is the computational equivalent of a mathematical equation having a closed, exact form. If the inputs are inexact, the error will of course propagate. Throughout `K` denotes the number of classes in the classification task. """ @@ -150,7 +150,7 @@ def compute_noise_matrix_from_inverse(ps, inverse_noise_matrix, *, py=None) -> n Returns ------- - noise_matrix : np.ndarray + noise_matrix : np.ndarray Array of shape ``(K, K)``, where `K` = number of classes, whose columns sum to 1. A conditional probability matrix of the form ``P(label=k_s|true_label=k_y)`` containing the fraction of examples in every class, labeled as every other class. diff --git a/cleanlab/internal/multiannotator_utils.py b/cleanlab/internal/multiannotator_utils.py index 42e34d7903..93cec654fc 100644 --- a/cleanlab/internal/multiannotator_utils.py +++ b/cleanlab/internal/multiannotator_utils.py @@ -1,4 +1,4 @@ -# Copyright (C) 2017-2022 Cleanlab Inc. +# Copyright (C) 2017-2023 Cleanlab Inc. # This file is part of cleanlab. # # cleanlab is free software: you can redistribute it and/or modify diff --git a/cleanlab/internal/multilabel_scorer.py b/cleanlab/internal/multilabel_scorer.py index 287a7a7e34..dd58312a2f 100644 --- a/cleanlab/internal/multilabel_scorer.py +++ b/cleanlab/internal/multilabel_scorer.py @@ -1,4 +1,4 @@ -# Copyright (C) 2017-2022 Cleanlab Inc. +# Copyright (C) 2017-2023 Cleanlab Inc. # This file is part of cleanlab. # # cleanlab is free software: you can redistribute it and/or modify diff --git a/cleanlab/internal/multilabel_utils.py b/cleanlab/internal/multilabel_utils.py index 22df37cf8f..57fb5da17b 100644 --- a/cleanlab/internal/multilabel_utils.py +++ b/cleanlab/internal/multilabel_utils.py @@ -1,4 +1,4 @@ -# Copyright (C) 2017-2022 Cleanlab Inc. +# Copyright (C) 2017-2023 Cleanlab Inc. # This file is part of cleanlab. # # cleanlab is free software: you can redistribute it and/or modify diff --git a/cleanlab/internal/token_classification_utils.py b/cleanlab/internal/token_classification_utils.py index fdc012e3a6..ab384294b4 100644 --- a/cleanlab/internal/token_classification_utils.py +++ b/cleanlab/internal/token_classification_utils.py @@ -1,4 +1,4 @@ -# Copyright (C) 2017-2022 Cleanlab Inc. +# Copyright (C) 2017-2023 Cleanlab Inc. # This file is part of cleanlab. # # cleanlab is free software: you can redistribute it and/or modify diff --git a/cleanlab/internal/util.py b/cleanlab/internal/util.py index ea7ef5f8c3..79ee8e2337 100644 --- a/cleanlab/internal/util.py +++ b/cleanlab/internal/util.py @@ -1,4 +1,4 @@ -# Copyright (C) 2017-2022 Cleanlab Inc. +# Copyright (C) 2017-2023 Cleanlab Inc. # This file is part of cleanlab. # # cleanlab is free software: you can redistribute it and/or modify diff --git a/cleanlab/internal/validation.py b/cleanlab/internal/validation.py index 5ce017d1d7..dce6cc9a6c 100644 --- a/cleanlab/internal/validation.py +++ b/cleanlab/internal/validation.py @@ -1,4 +1,4 @@ -# Copyright (C) 2017-2022 Cleanlab Inc. +# Copyright (C) 2017-2023 Cleanlab Inc. # This file is part of cleanlab. # # cleanlab is free software: you can redistribute it and/or modify diff --git a/cleanlab/multiannotator.py b/cleanlab/multiannotator.py index 7b57e2e3cd..34ff224255 100644 --- a/cleanlab/multiannotator.py +++ b/cleanlab/multiannotator.py @@ -1,4 +1,4 @@ -# Copyright (C) 2017-2022 Cleanlab Inc. +# Copyright (C) 2017-2023 Cleanlab Inc. # This file is part of cleanlab. # # cleanlab is free software: you can redistribute it and/or modify diff --git a/cleanlab/multilabel_classification.py b/cleanlab/multilabel_classification.py index 45307adbfa..f2d3a3c135 100644 --- a/cleanlab/multilabel_classification.py +++ b/cleanlab/multilabel_classification.py @@ -1,4 +1,4 @@ -# Copyright (C) 2017-2022 Cleanlab Inc. +# Copyright (C) 2017-2023 Cleanlab Inc. # This file is part of cleanlab. # # cleanlab is free software: you can redistribute it and/or modify diff --git a/cleanlab/outlier.py b/cleanlab/outlier.py index ad07691596..57011788f8 100644 --- a/cleanlab/outlier.py +++ b/cleanlab/outlier.py @@ -1,4 +1,4 @@ -# Copyright (C) 2017-2022 Cleanlab Inc. +# Copyright (C) 2017-2023 Cleanlab Inc. # This file is part of cleanlab. # # cleanlab is free software: you can redistribute it and/or modify diff --git a/cleanlab/rank.py b/cleanlab/rank.py index ef2e03b5a3..ae0f455a86 100644 --- a/cleanlab/rank.py +++ b/cleanlab/rank.py @@ -1,4 +1,4 @@ -# Copyright (C) 2017-2022 Cleanlab Inc. +# Copyright (C) 2017-2023 Cleanlab Inc. # This file is part of cleanlab. # # cleanlab is free software: you can redistribute it and/or modify diff --git a/cleanlab/token_classification/filter.py b/cleanlab/token_classification/filter.py index fcaf25b2fe..d10ee050e5 100644 --- a/cleanlab/token_classification/filter.py +++ b/cleanlab/token_classification/filter.py @@ -1,4 +1,4 @@ -# Copyright (C) 2017-2022 Cleanlab Inc. +# Copyright (C) 2017-2023 Cleanlab Inc. # This file is part of cleanlab. # # cleanlab is free software: you can redistribute it and/or modify diff --git a/cleanlab/token_classification/rank.py b/cleanlab/token_classification/rank.py index 69fdb13931..40d379e0f9 100644 --- a/cleanlab/token_classification/rank.py +++ b/cleanlab/token_classification/rank.py @@ -1,4 +1,4 @@ -# Copyright (C) 2017-2022 Cleanlab Inc. +# Copyright (C) 2017-2023 Cleanlab Inc. # This file is part of cleanlab. # # cleanlab is free software: you can redistribute it and/or modify diff --git a/cleanlab/token_classification/summary.py b/cleanlab/token_classification/summary.py index dc93de720b..bf1fe45580 100644 --- a/cleanlab/token_classification/summary.py +++ b/cleanlab/token_classification/summary.py @@ -1,4 +1,4 @@ -# Copyright (C) 2017-2022 Cleanlab Inc. +# Copyright (C) 2017-2023 Cleanlab Inc. # This file is part of cleanlab. # # cleanlab is free software: you can redistribute it and/or modify diff --git a/cleanlab/version.py b/cleanlab/version.py index 7c36fadd30..14c5fc056f 100644 --- a/cleanlab/version.py +++ b/cleanlab/version.py @@ -1,4 +1,4 @@ -# Copyright (C) 2017-2022 Cleanlab Inc. +# Copyright (C) 2017-2023 Cleanlab Inc. # This file is part of cleanlab. # # cleanlab is free software: you can redistribute it and/or modify diff --git a/tests/test_classification.py b/tests/test_classification.py index 0f0277f098..41c9a47b69 100644 --- a/tests/test_classification.py +++ b/tests/test_classification.py @@ -1,4 +1,4 @@ -# Copyright (C) 2017-2022 Cleanlab Inc. +# Copyright (C) 2017-2023 Cleanlab Inc. # This file is part of cleanlab. # # cleanlab is free software: you can redistribute it and/or modify diff --git a/tests/test_dataset.py b/tests/test_dataset.py index 4532ed6534..a96d26967a 100644 --- a/tests/test_dataset.py +++ b/tests/test_dataset.py @@ -1,4 +1,4 @@ -# Copyright (C) 2017-2022 Cleanlab Inc. +# Copyright (C) 2017-2023 Cleanlab Inc. # This file is part of cleanlab. # # cleanlab is free software: you can redistribute it and/or modify diff --git a/tests/test_filter_count.py b/tests/test_filter_count.py index d7984534f7..c48d4f1995 100644 --- a/tests/test_filter_count.py +++ b/tests/test_filter_count.py @@ -1,4 +1,4 @@ -# Copyright (C) 2017-2022 Cleanlab Inc. +# Copyright (C) 2017-2023 Cleanlab Inc. # This file is part of cleanlab. # # cleanlab is free software: you can redistribute it and/or modify diff --git a/tests/test_frameworks.py b/tests/test_frameworks.py index 09604cc88f..e4fccb7eae 100644 --- a/tests/test_frameworks.py +++ b/tests/test_frameworks.py @@ -1,4 +1,4 @@ -# Copyright (C) 2017-2022 Cleanlab Inc. +# Copyright (C) 2017-2023 Cleanlab Inc. # This file is part of cleanlab. # # cleanlab is free software: you can redistribute it and/or modify @@ -16,7 +16,7 @@ """ Scripts to test cleanlab usage with deep learning frameworks: -pytorch, skorch, tensorflow, keras +pytorch, skorch, tensorflow, keras """ import pytest diff --git a/tests/test_latent_algebra.py b/tests/test_latent_algebra.py index bfa5e0f0ca..b55ea711e5 100644 --- a/tests/test_latent_algebra.py +++ b/tests/test_latent_algebra.py @@ -1,4 +1,4 @@ -# Copyright (C) 2017-2022 Cleanlab Inc. +# Copyright (C) 2017-2023 Cleanlab Inc. # This file is part of cleanlab. # # cleanlab is free software: you can redistribute it and/or modify diff --git a/tests/test_multilabel_classification.py b/tests/test_multilabel_classification.py index 74ce2e361c..9454b884d3 100644 --- a/tests/test_multilabel_classification.py +++ b/tests/test_multilabel_classification.py @@ -1,4 +1,4 @@ -# Copyright (C) 2017-2022 Cleanlab Inc. +# Copyright (C) 2017-2023 Cleanlab Inc. # This file is part of cleanlab. # # cleanlab is free software: you can redistribute it and/or modify diff --git a/tests/test_outlier.py b/tests/test_outlier.py index 6a07f16fdf..8d330a5892 100644 --- a/tests/test_outlier.py +++ b/tests/test_outlier.py @@ -1,4 +1,4 @@ -# Copyright (C) 2017-2022 Cleanlab Inc. +# Copyright (C) 2017-2023 Cleanlab Inc. # This file is part of cleanlab. # # cleanlab is free software: you can redistribute it and/or modify diff --git a/tests/test_rank.py b/tests/test_rank.py index 53344217c9..3d3c2e1155 100644 --- a/tests/test_rank.py +++ b/tests/test_rank.py @@ -1,4 +1,4 @@ -# Copyright (C) 2017-2022 Cleanlab Inc. +# Copyright (C) 2017-2023 Cleanlab Inc. # This file is part of cleanlab. # # cleanlab is free software: you can redistribute it and/or modify From 4a5d0653fea0c0342eacb05042f112e702ce9d5a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?El=C3=ADas=20Snorrason?= Date: Sat, 7 Jan 2023 07:45:50 -0700 Subject: [PATCH 089/258] Handle missing type parameters for generic type "ndarray" (#587) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * refactor(multi-label): 🏷️ parametrize `NDArray` A generic type variable, `T`, that represents the precision of a data type. While the data types for probabilities and scores are identical, it conceptually makes sense to define separate type aliases for each. `np` is only used in defining the floating data type, which is only used for type hints. * mention shape of array in the docstring description + other clarity improvements Co-authored-by: Jonas Mueller <1390638+jwmueller@users.noreply.github.com> --- cleanlab/multilabel_classification.py | 23 +++++++++++++---------- 1 file changed, 13 insertions(+), 10 deletions(-) diff --git a/cleanlab/multilabel_classification.py b/cleanlab/multilabel_classification.py index f2d3a3c135..d436d72dc8 100644 --- a/cleanlab/multilabel_classification.py +++ b/cleanlab/multilabel_classification.py @@ -20,8 +20,9 @@ Unlike in standard multi-class classification, predicted class probabilities from model need not sum to 1 for each row in multi-label classification. """ -import numpy as np -from typing import List +import numpy as np # noqa: F401: Imported for type annotations +import numpy.typing as npt +from typing import List, TypeVar from cleanlab.internal.validation import assert_valid_inputs from cleanlab.internal.util import get_num_classes @@ -29,14 +30,17 @@ from cleanlab.internal.multilabel_utils import int2onehot +T = TypeVar("T", bound=npt.NBitBase) + + def get_label_quality_scores( labels: List, - pred_probs: np.ndarray, + pred_probs: npt.NDArray["np.floating[T]"], *, method: str = "self_confidence", adjust_pred_probs: bool = False, aggregator_kwargs: dict = {"method": "exponential_moving_average", "alpha": 0.8} -) -> np.ndarray: +) -> npt.NDArray["np.floating[T]"]: """Computes a label quality score each example in a multi-label classification dataset. Scores are between 0 and 1 with lower scores indicating examples whose label more likely contains an error. @@ -57,12 +61,11 @@ def get_label_quality_scores( *Format requirements*: For dataset with K classes, individual class labels must be integers in 0, 1, ..., K-1. pred_probs : np.ndarray - An array of shape ``(N, K)`` of model-predicted probabilities, - ``P(label=k|x)``. Each row of this matrix corresponds - to an example `x` and contains the model-predicted probabilities that - `x` belongs to each possible class, for each of the K classes. The - columns must be ordered such that these probabilities correspond to - class 0, 1, ..., K-1. In multi-label classification, the rows of `pred_probs` need not sum to 1. + A 2D array of shape ``(N, K)`` of model-predicted class probabilities ``P(label=k|x)``. + Each row of this matrix corresponds to an example `x` and contains the predicted probabilities + that `x` belongs to each possible class, for each of the K classes. + The columns of this array must be ordered such that these probabilities correspond to class 0, 1, ..., K-1. + In multi-label classification (where classes are not mutually exclusive), the rows of `pred_probs` need not sum to 1. Note ---- From feb369692437834302d805c6a1d6dde89021ca66 Mon Sep 17 00:00:00 2001 From: Jonas Mueller <1390638+jwmueller@users.noreply.github.com> Date: Mon, 9 Jan 2023 09:31:11 -0800 Subject: [PATCH 090/258] decide -> suggest --- README.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index ad8387034e..52e303655f 100644 --- a/README.md +++ b/README.md @@ -23,7 +23,7 @@ cleanlab.dataset.health_summary(labels, confident_joint=cl.confident_joint) Get started with: [documentation](https://docs.cleanlab.ai/), [tutorials](https://docs.cleanlab.ai/stable/tutorials/image.html), [examples](https://github.com/cleanlab/examples), and [blogs](https://cleanlab.ai/blog/). - Learn to run cleanlab on your data in 5 minutes for classification with: [image](https://docs.cleanlab.ai/stable/tutorials/image.html), [text](https://docs.cleanlab.ai/stable/tutorials/text.html), [audio](https://docs.cleanlab.ai/stable/tutorials/audio.html), or [tabular](https://docs.cleanlab.ai/stable/tutorials/tabular.html) data. -- Use cleanlab to automatically: [find mislabeled data + train robust models](https://docs.cleanlab.ai/stable/tutorials/indepth_overview.html), [detect outliers](https://docs.cleanlab.ai/stable/tutorials/outliers.html), [estimate consensus + annotator-quality for multi-annotator datasets](https://docs.cleanlab.ai/stable/tutorials/multiannotator.html), [decide what data is best to (re)label next](https://github.com/cleanlab/examples/blob/master/active_learning_multiannotator/active_learning.ipynb). +- Use cleanlab to automatically: [find mislabeled data + train robust models](https://docs.cleanlab.ai/stable/tutorials/indepth_overview.html), [detect outliers](https://docs.cleanlab.ai/stable/tutorials/outliers.html), [estimate consensus + annotator-quality for multi-annotator datasets](https://docs.cleanlab.ai/stable/tutorials/multiannotator.html), [suggest which data is best to (re)label next](https://github.com/cleanlab/examples/blob/master/active_learning_multiannotator/active_learning.ipynb). [![pypi](https://img.shields.io/pypi/v/cleanlab.svg)](https://pypi.org/pypi/cleanlab/) @@ -161,7 +161,7 @@ cleanlab is useful across a wide variety of Machine Learning tasks. Specific tas 2. [Multi-label classification](https://docs.cleanlab.ai/stable/tutorials/multilabel_classification.html) (e.g. image/document tagging) 3. [Token classification](https://docs.cleanlab.ai/stable/tutorials/token_classification.html) (e.g. entity recognition in text) 4. [Classification with data labeled by multiple annotators](https://docs.cleanlab.ai/stable/tutorials/multiannotator.html) -5. [Active learning with multiple annotators](https://github.com/cleanlab/examples/blob/master/active_learning_multiannotator/active_learning.ipynb) (decide which data to label or re-label to improve model most) +5. [Active learning with multiple annotators](https://github.com/cleanlab/examples/blob/master/active_learning_multiannotator/active_learning.ipynb) (suggest which data to label or re-label to improve model most) 6. [Out of distribution detection](https://docs.cleanlab.ai/stable/tutorials/outliers.html) For many other ML tasks, cleanlab can still help you improve your dataset if appropriately applied. From 71e21a983a561641b3794790fd9e5334e7846817 Mon Sep 17 00:00:00 2001 From: Hui Wen <45724323+huiwengoh@users.noreply.github.com> Date: Tue, 10 Jan 2023 06:12:19 +0800 Subject: [PATCH 091/258] remove temp scaling from ensemble active learning when data has single annotator (#597) --- cleanlab/multiannotator.py | 16 ++++++++++------ 1 file changed, 10 insertions(+), 6 deletions(-) diff --git a/cleanlab/multiannotator.py b/cleanlab/multiannotator.py index 34ff224255..bf653e1da0 100644 --- a/cleanlab/multiannotator.py +++ b/cleanlab/multiannotator.py @@ -700,15 +700,12 @@ def get_active_learning_scores_ensemble( num_classes = get_num_classes(pred_probs=pred_probs[0]) # temp scale pred_probs - optimal_temp = np.full(len(pred_probs), np.NaN) - for i in range(len(pred_probs)): - curr_pred_probs = pred_probs[i] - curr_optimal_temp = find_best_temp_scaler(labels_multiannotator, curr_pred_probs) - pred_probs[i] = temp_scale_pred_probs(curr_pred_probs, curr_optimal_temp) - optimal_temp[i] = curr_optimal_temp # if all examples are only labeled by a single annotator if labels_multiannotator.apply(lambda s: len(s.dropna()) == 1, axis=1).all(): + # do not temp scale for single annotator case, temperature is defined here for later use + optimal_temp = np.full(len(pred_probs), 1.0) + assert_valid_inputs_multiannotator( labels_multiannotator, pred_probs, ensemble=True, allow_single_label=True ) @@ -725,6 +722,13 @@ def get_active_learning_scores_ensemble( avg_annotator_weight = np.mean(annotator_weight) else: + optimal_temp = np.full(len(pred_probs), np.NaN) + for i in range(len(pred_probs)): + curr_pred_probs = pred_probs[i] + curr_optimal_temp = find_best_temp_scaler(labels_multiannotator, curr_pred_probs) + pred_probs[i] = temp_scale_pred_probs(curr_pred_probs, curr_optimal_temp) + optimal_temp[i] = curr_optimal_temp + multiannotator_info = get_label_quality_multiannotator_ensemble( labels_multiannotator, pred_probs, From 503a57adaf6318c4149f71523f7a232dbc34c4e4 Mon Sep 17 00:00:00 2001 From: unna97 <31486108+unna97@users.noreply.github.com> Date: Tue, 10 Jan 2023 19:16:16 +0530 Subject: [PATCH 092/258] Adding type hints for mypy strict compatibility (#585) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * Handling missing type & docs in cleanlab/token_classification_utils.py :label: - Added typehints for the cleanlabs/token_classification_utils.py file for mypy strict mode - Fixed corresponding docstrings refers #587 * Handling missing type & docs in cleanlab/multilabel_classification.py :label: - Fixing all errors for mypy strict for the file * docs(internal): fix "number of new classes" variable in docstring Co-authored-by: Elías Snorrason --- cleanlab/internal/token_classification_utils.py | 14 ++++++++++---- cleanlab/multilabel_classification.py | 6 +++--- 2 files changed, 13 insertions(+), 7 deletions(-) diff --git a/cleanlab/internal/token_classification_utils.py b/cleanlab/internal/token_classification_utils.py index ab384294b4..525e3d9077 100644 --- a/cleanlab/internal/token_classification_utils.py +++ b/cleanlab/internal/token_classification_utils.py @@ -22,7 +22,11 @@ import string import numpy as np from termcolor import colored -from typing import List, Optional, Callable, Tuple +from typing import List, Optional, Callable, Tuple, TypeVar +import numpy.typing as npt + + +T = TypeVar("T", bound=npt.NBitBase) def get_sentence(words: List[str]) -> str: @@ -171,14 +175,16 @@ def mapping(entities: List[int], maps: List[int]) -> List[int]: return list(map(f, entities)) -def merge_probs(probs: np.ndarray, maps: List[int]) -> np.ndarray: +def merge_probs( + probs: npt.NDArray["np.floating[T]"], maps: List[int] +) -> npt.NDArray["np.floating[T]"]: """ Merges model-predictive probabilities with desired mapping Parameters ---------- probs: - np.array of shape `(N, K)`, where N is the number of tokens, and K is the number of classes for the model + A 2D np.array of shape `(N, K)`, where N is the number of tokens, and K is the number of classes for the model maps: a list of mapped index, such that the probability of the token being in the i'th class is mapped to the @@ -188,7 +194,7 @@ def merge_probs(probs: np.ndarray, maps: List[int]) -> np.ndarray: Returns --------- probs_merged: - np.array of shape ``(N, K')``, where `K` is the number of new classes. Probabilities are merged and + A 2D np.array of shape ``(N, K')``, where `K'` is the number of new classes. Probabilities are merged and re-normalized if necessary. Examples diff --git a/cleanlab/multilabel_classification.py b/cleanlab/multilabel_classification.py index d436d72dc8..b49b6203da 100644 --- a/cleanlab/multilabel_classification.py +++ b/cleanlab/multilabel_classification.py @@ -22,7 +22,7 @@ import numpy as np # noqa: F401: Imported for type annotations import numpy.typing as npt -from typing import List, TypeVar +from typing import List, TypeVar, Dict, Any from cleanlab.internal.validation import assert_valid_inputs from cleanlab.internal.util import get_num_classes @@ -34,12 +34,12 @@ def get_label_quality_scores( - labels: List, + labels: List[List[int]], pred_probs: npt.NDArray["np.floating[T]"], *, method: str = "self_confidence", adjust_pred_probs: bool = False, - aggregator_kwargs: dict = {"method": "exponential_moving_average", "alpha": 0.8} + aggregator_kwargs: Dict[str, Any] = {"method": "exponential_moving_average", "alpha": 0.8} ) -> npt.NDArray["np.floating[T]"]: """Computes a label quality score each example in a multi-label classification dataset. From 1cf563c2a1dc752c0e4ec4ac9c815f795860f04e Mon Sep 17 00:00:00 2001 From: Ikko Eltociear Ashimine Date: Fri, 20 Jan 2023 04:55:31 +0900 Subject: [PATCH 093/258] fix typo in outliers.ipynb (#603) occuring -> occurring --- docs/source/tutorials/outliers.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/source/tutorials/outliers.ipynb b/docs/source/tutorials/outliers.ipynb index f4888055f1..8f3fe5df71 100644 --- a/docs/source/tutorials/outliers.ipynb +++ b/docs/source/tutorials/outliers.ipynb @@ -420,7 +420,7 @@ "source": [ "### Scoring outliers in a given dataset (training data)\n", "\n", - "Fitting cleanlab's ``OutOfDistribution`` class on ``feature_embeddings`` will find any naturally occuring outliers in a given dataset. These examples are atypical images that look strange or different from the majority of examples in the dataset. In our case, these correspond to odd-looking images of animals that do not resemble typical animals depicted in **cifar10**. This method produces a score in [0,1] for each example, where lower values correspond to more atypical examples (more likely out-of-distribution)." + "Fitting cleanlab's ``OutOfDistribution`` class on ``feature_embeddings`` will find any naturally occurring outliers in a given dataset. These examples are atypical images that look strange or different from the majority of examples in the dataset. In our case, these correspond to odd-looking images of animals that do not resemble typical animals depicted in **cifar10**. This method produces a score in [0,1] for each example, where lower values correspond to more atypical examples (more likely out-of-distribution)." ] }, { From a31b3cac78d0d1a23be1810903c0f319363610c5 Mon Sep 17 00:00:00 2001 From: Chris Mauck <38672284+cmauck10@users.noreply.github.com> Date: Thu, 19 Jan 2023 15:34:36 -0600 Subject: [PATCH 094/258] tags in links (#604) --- README.md | 6 +++--- docs/source/index.rst | 2 +- docs/source/tutorials/faq.ipynb | 6 +++--- 3 files changed, 7 insertions(+), 7 deletions(-) diff --git a/README.md b/README.md index 52e303655f..8cefb1e2e9 100644 --- a/README.md +++ b/README.md @@ -34,7 +34,7 @@ Get started with: [documentation](https://docs.cleanlab.ai/), [tutorials](https: [![docs](https://img.shields.io/static/v1?logo=github&style=flat&color=pink&label=docs&message=cleanlab)](https://docs.cleanlab.ai/) [![Slack Community](https://img.shields.io/static/v1?logo=slack&style=flat&color=white&label=slack&message=community)](https://cleanlab.ai/slack) [![Twitter](https://img.shields.io/twitter/follow/CleanlabAI?style=social)](https://twitter.com/CleanlabAI) -[![Cleanlab Studio](https://raw.githubusercontent.com/cleanlab/assets/master/shields/cl-studio-shield.svg)](https://cleanlab.ai/studio) +[![Cleanlab Studio](https://raw.githubusercontent.com/cleanlab/assets/master/shields/cl-studio-shield.svg)](https://cleanlab.ai/studio/?utm_source=github&utm_medium=readme&utm_campaign=clostostudio) ----- @@ -535,9 +535,9 @@ To understand/cite other cleanlab functionality not described above, check out o - [NeurIPS 2021 paper: Pervasive Label Errors in Test Sets Destabilize Machine Learning Benchmarks](https://arxiv.org/abs/2103.14749) -- [Cleanlab Studio](https://cleanlab.ai/studio): No-code Data Improvement +- [Cleanlab Studio](https://cleanlab.ai/studio/?utm_source=github&utm_medium=readme&utm_campaign=clostostudio): No-code Data Improvement -While this open-source library **finds** data issues, an interface is needed to efficiently **fix** these issues in your dataset. [Cleanlab Studio](https://cleanlab.ai/studio) is a no-code platform to find and fix problems in real-world ML datasets. Studio automatically runs optimized versions of the algorithms from this open-source library on top of AutoML models fit to your data, and presents detected issues in a smart data editing interface. Think of it like a data cleaning assistant that helps you quickly improve the quality of your data (via AI/automation + streamlined UX). +While this open-source library **finds** data issues, an interface is needed to efficiently **fix** these issues in your dataset. [Cleanlab Studio](https://cleanlab.ai/studio/?utm_source=github&utm_medium=readme&utm_campaign=clostostudio) is a no-code platform to find and fix problems in real-world ML datasets. Studio automatically runs optimized versions of the algorithms from this open-source library on top of AutoML models fit to your data, and presents detected issues in a smart data editing interface. Think of it like a data cleaning assistant that helps you quickly improve the quality of your data (via AI/automation + streamlined UX). ## Join our community diff --git a/docs/source/index.rst b/docs/source/index.rst index bb36ac8a0c..7e62505e44 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -160,4 +160,4 @@ Please see our `contributing guidelines PyPI Conda - Cleanlab Studio + Cleanlab Studio diff --git a/docs/source/tutorials/faq.ipynb b/docs/source/tutorials/faq.ipynb index fdd9ddc04a..989f9b3711 100644 --- a/docs/source/tutorials/faq.ipynb +++ b/docs/source/tutorials/faq.ipynb @@ -202,7 +202,7 @@ "metadata": {}, "source": [ "We caution against just blindly taking the predicted label for granted, many of these suggestions may be wrong! \n", - "You will be able to produce a much better version of your dataset interactively using [Cleanlab Studio](https://cleanlab.ai/studio/), which helps you efficiently fix issues like this in large datasets." + "You will be able to produce a much better version of your dataset interactively using [Cleanlab Studio](https://cleanlab.ai/studio/?utm_source=github&utm_medium=docs&utm_campaign=clostostudio), which helps you efficiently fix issues like this in large datasets." ] }, { @@ -372,8 +372,8 @@ "id": "1a117547", "metadata": {}, "source": [ - "These questions are automatically handled for you in [Cleanlab Studio](https://cleanlab.ai/studio) -- our platform for no-code data improvement.\n", - "While this open-source library **finds** data issues, an interface is needed to efficiently **fix** these issues in your dataset. [Cleanlab Studio](https://cleanlab.ai/studio) is a no-code platform to find and fix problems in real-world ML datasets. Studio automatically runs optimized versions of the algorithms from this open-source library on top of AutoML models fit to your data, and presents detected issues in a smart data editing interface. Think of it like a data cleaning assistant that helps you quickly improve the quality of your data (via AI/automation + streamlined UX)." + "These questions are automatically handled for you in [Cleanlab Studio](https://cleanlab.ai/studio/?utm_source=github&utm_medium=docs&utm_campaign=clostostudio) -- our platform for no-code data improvement.\n", + "While this open-source library **finds** data issues, an interface is needed to efficiently **fix** these issues in your dataset. [Cleanlab Studio](https://cleanlab.ai/studio/?utm_source=github&utm_medium=docs&utm_campaign=clostostudio) is a no-code platform to find and fix problems in real-world ML datasets. Studio automatically runs optimized versions of the algorithms from this open-source library on top of AutoML models fit to your data, and presents detected issues in a smart data editing interface. Think of it like a data cleaning assistant that helps you quickly improve the quality of your data (via AI/automation + streamlined UX)." ] }, { From 2b6c56424d176e0cccd6ea4f523c8a1b791a2d4a Mon Sep 17 00:00:00 2001 From: clu0 <33559427+clu0@users.noreply.github.com> Date: Thu, 19 Jan 2023 20:14:03 -0500 Subject: [PATCH 095/258] 10x speedup in find_label_issues on linux via better multiprocessing (#596) and bug fixes related to partition vs sort Co-authored-by: Jonas Mueller <1390638+jwmueller@users.noreply.github.com> --- cleanlab/filter.py | 249 ++++++++++++++++++------------------- requirements-dev.txt | 1 + tests/test_filter_count.py | 51 ++++++++ 3 files changed, 176 insertions(+), 125 deletions(-) diff --git a/cleanlab/filter.py b/cleanlab/filter.py index e507011416..6e31786f6c 100644 --- a/cleanlab/filter.py +++ b/cleanlab/filter.py @@ -26,11 +26,11 @@ import numpy as np from sklearn.metrics import confusion_matrix import multiprocessing -from multiprocessing.sharedctypes import RawArray import sys import warnings from typing import Any, Dict, List, Optional, Tuple, Union from functools import reduce +import platform from cleanlab.count import calibrate_confident_joint from cleanlab.rank import ( @@ -46,9 +46,8 @@ from cleanlab.internal.multilabel_utils import stack_complement, get_onehot_num_classes, int2onehot from cleanlab.typing import LabelLike -# tqdm is a module used to print time-to-complete when multiprocessing is used. -# This module is not necessary, and therefore is not a package dependency, but -# when installed it improves user experience for large datasets. +# tqdm is a package to print time-to-complete when multiprocessing is used. +# This package is not necessary, but when installed improves user experience for large datasets. try: import tqdm @@ -59,6 +58,19 @@ w = """To see estimated completion times for methods in cleanlab.filter, "pip install tqdm".""" warnings.warn(w) +# psutil is a package used to count physical cores for multiprocessing +# This package is not necessary, because we can always fall back to logical cores as the default +try: + import psutil + + psutil_exists = True +except ImportError as e: # pragma: no cover + psutil_exists = False + +# global variable for find_label_issues multiprocessing +pred_probs_by_class: Dict[int, np.ndarray] +prune_count_matrix_cols: Dict[int, np.ndarray] + def find_label_issues( labels: LabelLike, @@ -187,7 +199,7 @@ class 0, 1, ..., K-1. n_jobs : optional Number of processing threads used by multiprocessing. Default ``None`` - sets to the number of cores on your CPU. + sets to the number of cores on your CPU (physical cores if you have ``psutil`` package installed, otherwise logical cores). Set this to 1 to *disable* parallel processing (if its causing issues). Windows users may see a speed-up with ``n_jobs=1``. @@ -247,9 +259,34 @@ class 0, 1, ..., K-1. "filter_by 'confident_learning' or 'predicted_neq_given' is not supported (yet) when setting 'num_to_remove_per_class'" ) + K = get_num_classes( + labels=labels, pred_probs=pred_probs, label_matrix=confident_joint, multi_label=multi_label + ) + # Boolean set to true if dataset is large + big_dataset = K * len(labels) > 1e8 + # Set-up number of multiprocessing threads + # On Windows/macOS, when multi_label is True, multiprocessing is much slower + # even for faily large input arrays, so we default to n_jobs=1 in this case + os_name = platform.system() if n_jobs is None: - n_jobs = multiprocessing.cpu_count() + if multi_label and os_name != "Linux": + n_jobs = 1 + else: + if psutil_exists: + n_jobs = psutil.cpu_count(logical=False) # physical cores + elif big_dataset: + print( + "To default `n_jobs` to the number of physical cores for multiprocessing in find_label_issues(), please: `pip install psutil`.\n" + "Note: You can safely ignore this message. `n_jobs` only affects runtimes, results will be the same no matter its value.\n" + "Since psutil is not installed, `n_jobs` was set to the number of logical cores by default.\n" + "Disable this message by either installing psutil or specifying the `n_jobs` argument." + ) # pragma: no cover + if not n_jobs: + # either psutil does not exist + # or psutil can return None when physical cores cannot be determined + # switch to logical cores + n_jobs = multiprocessing.cpu_count() else: assert n_jobs >= 1 @@ -272,13 +309,8 @@ class 0, 1, ..., K-1. ) # Else this is standard multi-class classification - K = get_num_classes( - labels=labels, pred_probs=pred_probs, label_matrix=confident_joint, multi_label=multi_label - ) # Number of examples in each class of labels label_counts = value_counts_fill_missing_classes(labels, K, multi_label=multi_label) - # Boolean set to true if dataset is large - big_dataset = K * len(labels) > 1e8 # Ensure labels are of type np.ndarray() labels = np.asarray(labels) if confident_joint is None or filter_by == "confident_learning": @@ -310,83 +342,66 @@ class 0, 1, ..., K-1. prune_count_matrix = round_preserving_row_totals(tmp) # Prepare multiprocessing shared data - if n_jobs > 1: - _labels = RawArray("I", labels) # type: ignore - _label_counts = RawArray("I", label_counts) # type: ignore - _prune_count_matrix = RawArray("I", prune_count_matrix.flatten()) # type: ignore - _pred_probs = RawArray("f", pred_probs.flatten()) # type: ignore - else: # Multiprocessing is turned off. Create tuple with all parameters - args = ( - labels, - label_counts, - prune_count_matrix, - pred_probs, - multi_label, - min_examples_per_class, - ) + # On Linux, multiprocessing is started with fork, + # so data can be shared with global vairables + COW + # On Window/macOS, processes are started with spawn, + # so data will need to be pickled to the subprocesses through input args + chunksize = max(1, K // n_jobs) + if n_jobs == 1 or os_name == "Linux": + global pred_probs_by_class, prune_count_matrix_cols + pred_probs_by_class = {k: pred_probs[labels == k] for k in range(K)} + prune_count_matrix_cols = {k: prune_count_matrix[:, k] for k in range(K)} + args = [[k, min_examples_per_class, None] for k in range(K)] + else: + args = [ + [k, min_examples_per_class, [pred_probs[labels == k], prune_count_matrix[:, k]]] + for k in range(K) + ] # Perform Pruning with threshold probabilities from BFPRT algorithm in O(n) # Operations are parallelized across all CPU processes if filter_by == "prune_by_class" or filter_by == "both": - if n_jobs > 1: # parallelize - with multiprocessing.Pool( - n_jobs, - initializer=_init, - initargs=( - _labels, - _label_counts, - _prune_count_matrix, - prune_count_matrix.shape, - _pred_probs, - pred_probs.shape, - multi_label, - min_examples_per_class, - ), - ) as p: + if n_jobs > 1: + with multiprocessing.Pool(n_jobs) as p: if verbose: # pragma: no cover print("Parallel processing label issues by class.") sys.stdout.flush() if big_dataset and tqdm_exists: label_issues_masks_per_class = list( - tqdm.tqdm(p.imap(_prune_by_class, range(K)), total=K), + tqdm.tqdm(p.imap(_prune_by_class, args, chunksize=chunksize), total=K) ) else: - label_issues_masks_per_class = p.map(_prune_by_class, range(K)) - else: # n_jobs = 1, so no parallelization - label_issues_masks_per_class = [_prune_by_class(k, args) for k in range(K)] - label_issues_mask = np.stack(label_issues_masks_per_class).any(axis=0) + label_issues_masks_per_class = p.map(_prune_by_class, args, chunksize=chunksize) + else: + label_issues_masks_per_class = [_prune_by_class(arg) for arg in args] + + label_issues_mask = np.zeros(len(labels), dtype=bool) + for k, mask in enumerate(label_issues_masks_per_class): + if len(mask) > 1: + label_issues_mask[labels == k] = mask if filter_by == "both": label_issues_mask_by_class = label_issues_mask if filter_by == "prune_by_noise_rate" or filter_by == "both": - if n_jobs > 1: # parallelize - with multiprocessing.Pool( - n_jobs, - initializer=_init, - initargs=( - _labels, - _label_counts, - _prune_count_matrix, - prune_count_matrix.shape, - _pred_probs, - pred_probs.shape, - multi_label, - min_examples_per_class, - ), - ) as p: + if n_jobs > 1: + with multiprocessing.Pool(n_jobs) as p: if verbose: # pragma: no cover print("Parallel processing label issues by noise rate.") sys.stdout.flush() if big_dataset and tqdm_exists: label_issues_masks_per_class = list( - tqdm.tqdm(p.imap(_prune_by_count, range(K)), total=K) + tqdm.tqdm(p.imap(_prune_by_count, args, chunksize=chunksize), total=K) ) else: - label_issues_masks_per_class = p.map(_prune_by_count, range(K)) - else: # n_jobs = 1, so no parallelization - label_issues_masks_per_class = [_prune_by_count(k, args) for k in range(K)] - label_issues_mask = np.stack(label_issues_masks_per_class).any(axis=0) + label_issues_masks_per_class = p.map(_prune_by_count, args, chunksize=chunksize) + else: + label_issues_masks_per_class = [_prune_by_count(arg) for arg in args] + + label_issues_mask = np.zeros(len(labels), dtype=bool) + for k, mask in enumerate(label_issues_masks_per_class): + if len(mask) > 1: + label_issues_mask[labels == k] = mask if filter_by == "both": label_issues_mask = label_issues_mask & label_issues_mask_by_class @@ -891,7 +906,7 @@ def _get_shared_data() -> Any: # pragma: no cover # TODO figure out what the types inside args are. -def _prune_by_class(k: int, args=None) -> np.ndarray: +def _prune_by_class(args: list) -> np.ndarray: """multiprocessing Helper function for find_label_issues() that assumes globals and produces a mask for class k for each example by removing the examples with *smallest probability* of @@ -902,41 +917,34 @@ def _prune_by_class(k: int, args=None) -> np.ndarray: k : int (between 0 and num classes - 1) The class of interest.""" - if args: # Single processing - params are passed in - ( - labels, - label_counts, - prune_count_matrix, - pred_probs, - multi_label, - min_examples_per_class, - ) = args - else: # Multiprocessing - data is shared across sub-processes - ( - labels, - label_counts, - prune_count_matrix, - pred_probs, - multi_label, - min_examples_per_class, - ) = _get_shared_data() + k, min_examples_per_class, arrays = args + if arrays is None: + pred_probs = pred_probs_by_class[k] + prune_count_matrix = prune_count_matrix_cols[k] + else: + pred_probs = arrays[0] + prune_count_matrix = arrays[1] - if label_counts[k] > min_examples_per_class: # No prune if not at least min_examples_per_class - num_issues = label_counts[k] - prune_count_matrix[k][k] + label_counts = pred_probs.shape[0] + label_issues = np.zeros(label_counts, dtype=bool) + if label_counts > min_examples_per_class: # No prune if not at least min_examples_per_class + num_issues = label_counts - prune_count_matrix[k] # Get return_indices_ranked_by of the smallest prob of class k for examples with noisy label k - label_filter = np.array([k in lst for lst in labels]) if multi_label else labels == k - class_probs = pred_probs[:, k] - rank = np.partition(class_probs[label_filter], num_issues)[num_issues] - return label_filter & (class_probs < rank) - else: - warnings.warn( - f"May not flag all label issues in class: {k}, it has too few examples (see argument: `min_examples_per_class`)" - ) - return np.zeros(len(labels), dtype=bool) + # rank = np.partition(class_probs, num_issues)[num_issues] + if num_issues >= 1: + class_probs = pred_probs[:, k] + order = np.argsort(class_probs) + label_issues[order[:num_issues]] = True + return label_issues + + warnings.warn( + f"May not flag all label issues in class: {k}, it has too few examples (see argument: `min_examples_per_class`)" + ) + return label_issues # TODO figure out what the types inside args are. -def _prune_by_count(k: int, args=None) -> np.ndarray: +def _prune_by_count(args: list) -> np.ndarray: """multiprocessing Helper function for find_label_issues() that assumes globals and produces a mask for class k for each example by removing the example with noisy label k having *largest margin*, @@ -948,43 +956,34 @@ def _prune_by_count(k: int, args=None) -> np.ndarray: k : int (between 0 and num classes - 1) The true_label class of interest.""" - if args: # Single processing - params are passed in - ( - labels, - label_counts, - prune_count_matrix, - pred_probs, - multi_label, - min_examples_per_class, - ) = args - else: # Multiprocessing - data is shared across sub-processes - ( - labels, - label_counts, - prune_count_matrix, - pred_probs, - multi_label, - min_examples_per_class, - ) = _get_shared_data() + k, min_examples_per_class, arrays = args + if arrays is None: + pred_probs = pred_probs_by_class[k] + prune_count_matrix = prune_count_matrix_cols[k] + else: + pred_probs = arrays[0] + prune_count_matrix = arrays[1] - label_issues_mask = np.zeros(len(pred_probs), dtype=bool) - pred_probs_k = pred_probs[:, k] - K = get_num_classes(labels, pred_probs, multi_label=multi_label) - if label_counts[k] <= min_examples_per_class: # No prune if not at least min_examples_per_class + label_counts = pred_probs.shape[0] + label_issues_mask = np.zeros(label_counts, dtype=bool) + if label_counts <= min_examples_per_class: warnings.warn( f"May not flag all label issues in class: {k}, it has too few examples (see `min_examples_per_class` argument)" ) - return np.zeros(len(labels), dtype=bool) - for j in range(K): # j is true label index (k is noisy label index) - num2prune = prune_count_matrix[j][k] + return label_issues_mask + + K = pred_probs.shape[1] + if K < 1: + raise ValueError("Must have at least 1 class.") + for j in range(K): + num2prune = prune_count_matrix[j] # Only prune for noise rates, not diagonal entries if k != j and num2prune > 0: # num2prune's largest p(true class k) - p(noisy class k) # for x with true label j - margin = pred_probs[:, j] - pred_probs_k - label_filter = np.array([k in lst for lst in labels]) if multi_label else labels == k - cut = -np.partition(-margin[label_filter], num2prune - 1)[num2prune - 1] - label_issues_mask = label_issues_mask | (label_filter & (margin >= cut)) + margin = pred_probs[:, j] - pred_probs[:, k] + order = np.argsort(-margin) + label_issues_mask[order[:num2prune]] = True return label_issues_mask diff --git a/requirements-dev.txt b/requirements-dev.txt index 76a5b7898c..d6c7a87a63 100644 --- a/requirements-dev.txt +++ b/requirements-dev.txt @@ -12,3 +12,4 @@ torch torchvision skorch tensorflow +psutil diff --git a/tests/test_filter_count.py b/tests/test_filter_count.py index c48d4f1995..36a391009d 100644 --- a/tests/test_filter_count.py +++ b/tests/test_filter_count.py @@ -875,6 +875,57 @@ def test_missing_classes(): assert all(filter.find_label_issues(labels, pred_probs, filter_by=fb) == issues) +@pytest.mark.filterwarnings("ignore:WARNING!") +def test_find_label_issues_match_multiprocessing(): + # minimal version of this test was run in test_missing_classes + # here testing with larger input matrices + + # test with ground truth labels: + n = 5000 # consider replacing this with larger value + # some past bugs observed only with larger sample-sizes like n=200000 + m = 100 + labels = np.ones(n, dtype=int) + labels[(n // 2) :] = 0 + pred_probs = np.zeros((n, 4)) + pred_probs[:, 0] = 0.95 + pred_probs[:, 1] = 0.05 + pred_probs[0, 0] = 0.94 + pred_probs[0, 1] = 0.06 + ground_truth = np.ones(n, dtype=bool) + ground_truth[(n // 2) :] = False + ground_truth[0] = False # leave one example for min_example_per_class + # TODO: consider also testing this line without psutil installed + issues = filter.find_label_issues(labels, pred_probs) + issues1 = filter.find_label_issues(labels, pred_probs, n_jobs=1) + issues2 = filter.find_label_issues(labels, pred_probs, n_jobs=2) + assert all(issues == ground_truth) + assert all(issues == issues1) + assert all(issues == issues2) + issues = filter.find_label_issues(labels, pred_probs, filter_by="prune_by_class") + issues1 = filter.find_label_issues(labels, pred_probs, n_jobs=1, filter_by="prune_by_class") + issues2 = filter.find_label_issues(labels, pred_probs, n_jobs=2, filter_by="prune_by_class") + assert all(issues == ground_truth) + assert all(issues == issues1) + assert all(issues == issues2) + + # test with random labels + normalize = np.random.randint(low=1, high=100, size=[n, m], dtype=np.uint8) + pred_probs = np.zeros((n, m)) + for i, col in enumerate(normalize): + pred_probs[i] = col / np.sum(col) + labels = np.repeat(np.arange(m), n // m) + issues = filter.find_label_issues(labels, pred_probs) + issues1 = filter.find_label_issues(labels, pred_probs, n_jobs=1) + issues2 = filter.find_label_issues(labels, pred_probs, n_jobs=2) + assert all(issues == issues1) + assert all(issues == issues2) + issues = filter.find_label_issues(labels, pred_probs, filter_by="prune_by_class") + issues1 = filter.find_label_issues(labels, pred_probs, n_jobs=1, filter_by="prune_by_class") + issues2 = filter.find_label_issues(labels, pred_probs, n_jobs=2, filter_by="prune_by_class") + assert all(issues == issues1) + assert all(issues == issues2) + + @pytest.mark.parametrize( "return_indices_ranked_by", [None, "self_confidence", "normalized_margin", "confidence_weighted_entropy"], From b9b981dc01609182e874a38de7d831e99edff4a6 Mon Sep 17 00:00:00 2001 From: Jonas Mueller <1390638+jwmueller@users.noreply.github.com> Date: Thu, 19 Jan 2023 20:57:56 -0500 Subject: [PATCH 096/258] add cleanlab/projects to ignored URLs check list --- .github/workflows/links.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.github/workflows/links.yml b/.github/workflows/links.yml index 469100c88e..fbe9060f69 100644 --- a/.github/workflows/links.yml +++ b/.github/workflows/links.yml @@ -24,3 +24,4 @@ jobs: empty_alt_ignore: true url_ignore_re: | ^https:\/\/docs\.github\.com\/ + ^https:\/\/github\.com\/cleanlab\/cleanlab\/projects\/ From 9f655a7f6a39550e321dbc8a96a4289f40e7e59e Mon Sep 17 00:00:00 2001 From: Jonas Mueller <1390638+jwmueller@users.noreply.github.com> Date: Thu, 19 Jan 2023 21:04:56 -0500 Subject: [PATCH 097/258] remove slash at end (#606) --- .github/workflows/links.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/links.yml b/.github/workflows/links.yml index fbe9060f69..8c40f9237b 100644 --- a/.github/workflows/links.yml +++ b/.github/workflows/links.yml @@ -24,4 +24,4 @@ jobs: empty_alt_ignore: true url_ignore_re: | ^https:\/\/docs\.github\.com\/ - ^https:\/\/github\.com\/cleanlab\/cleanlab\/projects\/ + ^https:\/\/github\.com\/cleanlab\/cleanlab\/projects From f9d32b1352730807231cb8bdf3ec2a88e46d8a68 Mon Sep 17 00:00:00 2001 From: Chris Mauck <38672284+cmauck10@users.noreply.github.com> Date: Tue, 24 Jan 2023 20:12:34 -0600 Subject: [PATCH 098/258] Update tabular tutorial with better language (#609) Co-authored-by: Jonas Mueller <1390638+jwmueller@users.noreply.github.com> --- docs/source/tutorials/tabular.ipynb | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/docs/source/tutorials/tabular.ipynb b/docs/source/tutorials/tabular.ipynb index 94e577c9fe..8f3ce43b5f 100644 --- a/docs/source/tutorials/tabular.ipynb +++ b/docs/source/tutorials/tabular.ipynb @@ -11,7 +11,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "In this 5-minute quickstart tutorial, we use cleanlab with scikit-learn models to find potential label errors in a classification dataset with tabular (numeric/categorical) features. Here we study the [German Credit](https://www.openml.org/d/31) dataset which contains 1,000 individuals described by 20 features, each labeled as either \"good\" or \"bad\" credit risk. cleanlab automatically shortlists _hundreds_ of examples from this dataset that confuse our ML model; many of which are potential label errors (due to annotator mistakes), edge cases, and otherwise ambiguous examples.\n", + "In this 5-minute quickstart tutorial, we use cleanlab with scikit-learn models to find potential label errors in a classification dataset with tabular (numeric/categorical) features. Tabular (or *structured*) data are typically organized in a row/column format and stored in a SQL database or file types like: CSV, Excel, or Parquet. Here we study the [German Credit](https://www.openml.org/d/31) dataset which contains 1,000 individuals described by 20 features, each labeled as either \"good\" or \"bad\" credit risk. cleanlab automatically shortlists _hundreds_ of examples from this dataset that confuse our ML model; many of which are potential label errors (due to annotator mistakes), edge cases, and otherwise ambiguous examples.\n", "\n", "**Overview of what we'll do in this tutorial:**\n", "\n", @@ -151,7 +151,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "We first load the data features and labels.\n" + "We first load the data features and labels (which are possibly noisy).\n" ] }, { @@ -238,7 +238,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "To identify label issues, cleanlab requires a probabilistic prediction from your model for every datapoint. However, these predictions will be _overfitted_ (and thus unreliable) for examples the model was previously trained on. cleanlab is intended to only be used with **out-of-sample** predicted probabilities, i.e., on examples held out from the model during the training.\n", + "To find potential labeling errors, cleanlab requires a probabilistic prediction from your model for every datapoint. However, these predictions will be _overfitted_ (and thus unreliable) for examples the model was previously trained on. cleanlab is intended to only be used with **out-of-sample** predicted probabilities, i.e., on examples held out from the model during the training.\n", "\n", "K-fold cross-validation is a straightforward way to produce out-of-sample predicted probabilities for every datapoint in the dataset by training K copies of our model on different data subsets and using each copy to predict on the subset of data it did not see during training. An additional benefit of cross-validation is that it provides a more reliable evaluation of our model than a single training/validation split. We can obtain cross-validated out-of-sample predicted probabilities from any classifier via a simple scikit-learn wrapper:\n" ] @@ -272,7 +272,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Based on the given labels and out-of-sample predicted probabilities, cleanlab can quickly help us identify label issues in our dataset. For a dataset with N examples from K classes, the labels should be a 1D array of length N and predicted probabilities should be a 2D (N x K) array. Here we request that the indices of the identified label issues be sorted by cleanlab's self-confidence score, which measures the quality of each given label via the probability assigned to it in our model's prediction." + "Based on the given labels and out-of-sample predicted probabilities, cleanlab can quickly help us identify poorly labeled instances in our data table. For a dataset with N examples from K classes, the labels should be a 1D array of length N and predicted probabilities should be a 2D (N x K) array. Here we request that the indices of the identified label issues be sorted by cleanlab's self-confidence score, which measures the quality of each given label via the probability assigned to it in our model's prediction." ] }, { @@ -310,7 +310,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "These examples appear the most suspicious to our model and should be carefully re-examined. Perhaps the original annotators missed something when deciding on the labels for these individuals.\n" + "These examples appear the most suspicious to our model and should be carefully re-examined. Perhaps the original annotators missed something when deciding on the labels for these individuals. This is a straightforward approach to visualize the rows in a data table that might be mislabeled.\n" ] }, { @@ -480,7 +480,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.13" + "version": "3.10.8" } }, "nbformat": 4, From 888246e2d5e133d089783713f28915a7e1f9a89a Mon Sep 17 00:00:00 2001 From: Ulyana Date: Fri, 27 Jan 2023 14:47:02 -0800 Subject: [PATCH 099/258] Improve num_label_issues usage of confident_joint to match find_label_issues (#610) Co-authored-by: Jonas Mueller <1390638+jwmueller@users.noreply.github.com> --- cleanlab/count.py | 66 +++++++++++++++++------ cleanlab/filter.py | 9 +++- tests/test_filter_count.py | 108 ++++++++++++++++++++++++++++++------- 3 files changed, 149 insertions(+), 34 deletions(-) diff --git a/cleanlab/count.py b/cleanlab/count.py index ce24e559b4..188f874c7a 100644 --- a/cleanlab/count.py +++ b/cleanlab/count.py @@ -87,7 +87,7 @@ def num_label_issues( Array of estimated class label error statisics used for identifying label issues, in same format expected by :py:func:`filter.find_label_issues ` function. The `confident_joint` can be computed using :py:func:`count.compute_confident_joint `. - If not provided, it is internally computed from the given (noisy) `labels` and `pred_probs`. + It is internally computed from the given (noisy) `labels` and `pred_probs`. estimation_method : Method for estimating the number of label issues in dataset by counting the examples in the off-diagonal of the `confident_joint` ``P(label=i, true_label=j)``. @@ -100,8 +100,11 @@ def num_label_issues( two cases: 1. As we add more label and data quality scoring functions in :py:mod:`cleanlab.rank`, this approach will always work. 2. If you have a custom score to rank your data by label quality and you just need to know the cut-off of likely label issues. + - ``'off_diagonal_custom'``: Counts the number of examples in the off-diagonal of a provided `confident_joint` matrix. + - TL;DR: use this method to get the most accurate estimate of number of label issues when you don't need the indices of the label issues. + TL;DR: Use this method to get the most accurate estimate of number of label issues when you don't need the indices of the label issues. + Note: ``'off_diagonal'`` may sometimes underestimate issues for data with few classes, so consider using ``'off_diagonal_calibrated'`` instead if your data has < 4 classes. multi_label : bool, optional Set ``False`` if your dataset is for regular (multi-class) classification, where each example belongs to exactly one class. @@ -114,6 +117,14 @@ def num_label_issues( The estimated number of examples with label issues in the dataset. """ valid_methods = ["off_diagonal", "off_diagonal_calibrated"] + if isinstance(confident_joint, np.ndarray): + warn_str = ( + "The supplied `confident_joint` is ignored as `confident_joint` is recomuputed internally using " + "the supplied `labels` and `pred_probs`. If you still want to use custom `confident_joint` call function " + "with `estimation_method='off_diagonal_custom'`." + ) + warnings.warn(warn_str) + if multi_label: return _num_label_issues_multilabel( labels=labels, @@ -123,29 +134,54 @@ def num_label_issues( labels = labels_to_array(labels) assert_valid_inputs(X=None, y=labels, pred_probs=pred_probs) - if confident_joint is None: - # Original non-calibrated counts of confidently correctly and incorrectly labeled examples. - computed_confident_joint = compute_confident_joint( - labels=labels, pred_probs=pred_probs, calibrate=False + if estimation_method == "off_diagonal": + _, cl_error_indices = compute_confident_joint( + labels=labels, + pred_probs=pred_probs, + calibrate=False, + return_indices_of_off_diagonals=True, ) - else: - computed_confident_joint = confident_joint - assert isinstance(computed_confident_joint, np.ndarray) + label_issues_mask = np.zeros(len(labels), dtype=bool) + for idx in cl_error_indices: + label_issues_mask[idx] = True - if estimation_method == "off_diagonal": - num_issues: int = np.sum(computed_confident_joint) - np.trace(computed_confident_joint) + # Remove label issues if given label == model prediction + pred = pred_probs.argmax(axis=1) + for i, pred_label in enumerate(pred): + if pred_label == labels[i]: + label_issues_mask[i] = False + num_issues = np.sum(label_issues_mask) elif estimation_method == "off_diagonal_calibrated": + calculated_confident_joint = compute_confident_joint( + labels=labels, + pred_probs=pred_probs, + calibrate=True, + ) + assert isinstance(calculated_confident_joint, np.ndarray) # Estimate_joint calibrates the row sums to match the prior distribution of given labels and normalizes to sum to 1 - joint = estimate_joint(labels, pred_probs, confident_joint=computed_confident_joint) + joint = estimate_joint(labels, pred_probs, confident_joint=calculated_confident_joint) frac_issues = 1.0 - joint.trace() num_issues = np.rint(frac_issues * len(labels)).astype(int) + elif estimation_method == "off_diagonal_custom": + if not isinstance(confident_joint, np.ndarray): + raise ValueError( + f""" + No `confident_joint` provided. For 'estimation_method' = {estimation_method} you need to provide pre-calculated + `confident_joint` matrix. Use a different `estimation_method` if you want the `confident_joint` matrix to + be calculated for you. + """ + ) + else: + joint = estimate_joint(labels, pred_probs, confident_joint=confident_joint) + frac_issues = 1.0 - joint.trace() + num_issues = np.rint(frac_issues * len(labels)).astype(int) else: raise ValueError( f""" - {estimation_method} is not a valid estimation method! - Please choose a valid estimation method: {valid_methods} - """ + {estimation_method} is not a valid estimation method! + Please choose a valid estimation method: {valid_methods} + """ ) return num_issues diff --git a/cleanlab/filter.py b/cleanlab/filter.py index 6e31786f6c..0e07ea191a 100644 --- a/cleanlab/filter.py +++ b/cleanlab/filter.py @@ -245,7 +245,7 @@ class 0, 1, ..., K-1. frac_noise != 1.0 or num_to_remove_per_class is not None ): warn_str = ( - "WARNING! frac_noise and num_to_remove_per_class parameters are only supported" + "frac_noise and num_to_remove_per_class parameters are only supported" " for filter_by 'prune_by_noise_rate', 'prune_by_class', and 'both'. They " "are not supported for methods 'confident_learning' or " "'predicted_neq_given'." @@ -258,6 +258,13 @@ class 0, 1, ..., K-1. raise ValueError( "filter_by 'confident_learning' or 'predicted_neq_given' is not supported (yet) when setting 'num_to_remove_per_class'" ) + if filter_by is "confident_learning" and isinstance(confident_joint, np.ndarray): + warn_str = ( + "The supplied `confident_joint` is ignored when `filter_by = 'confident_learning'`; confident joint will be " + "re-estimated from the given labels. To use your supplied `confident_joint`, please specify a different " + "`filter_by` value." + ) + warnings.warn(warn_str) K = get_num_classes( labels=labels, pred_probs=pred_probs, label_matrix=confident_joint, multi_label=multi_label diff --git a/tests/test_filter_count.py b/tests/test_filter_count.py index 36a391009d..81962b9a81 100644 --- a/tests/test_filter_count.py +++ b/tests/test_filter_count.py @@ -715,22 +715,51 @@ def test_find_label_issue_filters_match_origin_functions(): assert "not supported" in str(e) -@pytest.mark.parametrize("confident_joint", [None, True]) -def test_num_label_issues(confident_joint): - cj_calibrated_off_diag_sum = data["cj"].sum() - data["cj"].trace() - n = count.num_label_issues( - labels=data["labels"], - pred_probs=data["pred_probs"], - confident_joint=data["cj"], +def test_num_label_issues_different_estimation_types(): + # these numbers are hardcoded as data[] does not create a difference in both functions + y = np.array([0, 1, 1, 1, 1, 0, 0, 1, 0]) + pred_probs = np.array( + [ + [0.7110397298505661, 0.2889602701494339], + [0.6367131487519773, 0.36328685124802274], + [0.7571834730987641, 0.24281652690123584], + [0.6394163729473307, 0.3605836270526695], + [0.5853684039196656, 0.4146315960803345], + [0.6675968116482668, 0.33240318835173316], + [0.7240647829106976, 0.2759352170893023], + [0.740474240697777, 0.25952575930222266], + [0.7148252196621883, 0.28517478033781196], + ] + ) + + n3 = count.num_label_issues( + labels=y, + pred_probs=pred_probs, + estimation_method="off_diagonal_calibrated", + ) + + n2 = count.num_label_issues( + labels=y, + pred_probs=pred_probs, estimation_method="off_diagonal", - ) # data["cj"] is already calibrated and estimation method does not do extra calibration + ) + + f2 = filter.find_label_issues(labels=y, pred_probs=pred_probs, filter_by="confident_learning") + + assert np.sum(f2) == n2 + assert n3 != n2 - n1 = count.num_label_issues( + +@pytest.mark.filterwarnings() +def test_num_label_issues(): + cj_calibrated_off_diag_sum = data["cj"].sum() - data["cj"].trace() + + n1 = count.num_label_issues( # should throw warning as cj is passed in but also recalculated labels=data["labels"], pred_probs=data["pred_probs"], confident_joint=data["cj"], estimation_method="off_diagonal_calibrated", - ) # data["cj"] is already calibrated but recalibrating it should not change the values + ) n2 = count.num_label_issues( labels=data["labels"], @@ -738,21 +767,47 @@ def test_num_label_issues(confident_joint): estimation_method="off_diagonal_calibrated", ) # this should calculate and calibrate the confident joint into same matrix as data["cj"] - # data["cj"] is already calibrated and estimation method does not do extra calibration - assert n == cj_calibrated_off_diag_sum - # data["cj"] is already calibrated but recalibrating it should not change the values - assert n == n1 + n_custom = count.num_label_issues( + labels=data["labels"], + pred_probs=data["pred_probs"], + confident_joint=data["cj"], + estimation_method="off_diagonal_custom", + ) + + ones_joint = np.ones_like(data["cj"]) + n_custom_bad = count.num_label_issues( + labels=data["labels"], + pred_probs=data["pred_probs"], + confident_joint=ones_joint, + estimation_method="off_diagonal_custom", + ) + + # data["cj"] is already calibrated and recalibrating it should not change the values + assert n2 == cj_calibrated_off_diag_sum # should calculate and calibrate the confident joint into same matrix as data["cj"] - assert n == n2 + assert n1 == n2 + # estimation_method='off_diagonal_custom' should use the passed in confident joint correctly + assert n_custom == n1 + assert n_custom_bad != n1 - f = filter.find_label_issues( + f = filter.find_label_issues( # this should throw warning since cj passed in and filter by confident_learning labels=data["labels"], pred_probs=data["pred_probs"], confident_joint=data["cj"] ) assert sum(f) == 35 - f1 = filter.find_label_issues( - labels=data["labels"], pred_probs=data["pred_probs"], filter_by="confident_learning" + f1 = filter.find_label_issues( # this should throw warning since cj passed in and filter by confident_learning + labels=data["labels"], + pred_probs=data["pred_probs"], + filter_by="confident_learning", + confident_joint=data["cj"], + ) + + n = count.num_label_issues( # should throw warning as cj is passed in but also recalculated + labels=data["labels"], + pred_probs=data["pred_probs"], + confident_joint=data["cj"], + estimation_method="off_diagonal", ) n3 = count.num_label_issues( @@ -761,6 +816,7 @@ def test_num_label_issues(confident_joint): ) assert sum(f1) == n3 # values should be equivalent for `filter_by='confident_learning'` + assert n == n3 # passing in cj should not affect calculation # check wrong estimation_method throws ValueError try: @@ -778,6 +834,22 @@ def test_num_label_issues(confident_joint): estimation_method="not_a_real_method", ) + # check not passing in cj with estimation_method_custom throws ValueError + try: + count.num_label_issues( + labels=data["labels"], + pred_probs=data["pred_probs"], + estimation_method="off_diagonal_custom", + ) + except Exception as e: + assert "you need to provide pre-calculated" in str(e) + with pytest.raises(ValueError) as e: + count.num_label_issues( + labels=data["labels"], + pred_probs=data["pred_probs"], + estimation_method="off_diagonal_custom", + ) + @pytest.mark.parametrize("confident_joint", [None, True]) def test_num_label_issues_multilabel(confident_joint): From 5f9fd95c454dffa10b8cb089384b88d87e53ed50 Mon Sep 17 00:00:00 2001 From: Jonas Mueller <1390638+jwmueller@users.noreply.github.com> Date: Sun, 29 Jan 2023 23:48:49 -0800 Subject: [PATCH 100/258] update crowdlab paper name --- docs/source/tutorials/multiannotator.ipynb | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/source/tutorials/multiannotator.ipynb b/docs/source/tutorials/multiannotator.ipynb index 2fb03e5e38..a4263da465 100644 --- a/docs/source/tutorials/multiannotator.ipynb +++ b/docs/source/tutorials/multiannotator.ipynb @@ -715,9 +715,9 @@ "\n", "## How does cleanlab.multiannotator work?\n", "\n", - "All estimates above are produced via the CROWDLAB algorithm, described and benchmarked in this paper:\n", + "All estimates above are produced via the CROWDLAB algorithm, described in this paper that contains extensive benchmarks which show CROWDLAB can produce better estimates than popular methods like Dawid-Skene and GLAD:\n", "\n", - "[Utilizing supervised models to infer consensus labels and their quality from data with multiple annotators](https://arxiv.org/abs/2210.06812)" + "[CROWDLAB: Supervised learning to infer consensus labels and quality scores for data with multiple annotators](https://arxiv.org/abs/2210.06812)" ] }, { From d6f40d89b85c1ed347fe3bfcd4b09fd6785daf0e Mon Sep 17 00:00:00 2001 From: Jonas Mueller <1390638+jwmueller@users.noreply.github.com> Date: Mon, 30 Jan 2023 10:55:11 -0800 Subject: [PATCH 101/258] crowdlab paper name update --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 8cefb1e2e9..1fc52ef554 100644 --- a/README.md +++ b/README.md @@ -515,7 +515,7 @@ cleanlab is based on peer-reviewed research. Here are relevant papers to cite if
CROWDLAB for data with multiple annotators (NeurIPS '22) (click to show bibtex) @inproceedings{goh2022crowdlab, - title={Utilizing supervised models to infer consensus labels and their quality from data with multiple annotators}, + title={CROWDLAB: Supervised learning to infer consensus labels and quality scores for data with multiple annotators}, author={Goh, Hui Wen and Tkachenko, Ulyana and Mueller, Jonas}, booktitle={NeurIPS Human in the Loop Learning Workshop}, year={2022} From 5c1ba64bea3892709a7f558c04725c468e09974f Mon Sep 17 00:00:00 2001 From: Sanjana Date: Mon, 30 Jan 2023 15:56:40 -0800 Subject: [PATCH 102/258] Removed duplicate classifier from setup.py (#612) --- setup.py | 2 -- 1 file changed, 2 deletions(-) diff --git a/setup.py b/setup.py index e4b03739c8..edeefce993 100644 --- a/setup.py +++ b/setup.py @@ -62,10 +62,8 @@ def run(self): "Programming Language :: Python", "Topic :: Software Development", "Topic :: Scientific/Engineering", - "Topic :: Scientific/Engineering", "Topic :: Scientific/Engineering :: Mathematics", "Topic :: Scientific/Engineering :: Artificial Intelligence", - "Topic :: Software Development", "Topic :: Software Development :: Libraries", "Topic :: Software Development :: Libraries :: Python Modules", ], From 0c02ec953bc980e8c1d6ca970c3090c4da8d1384 Mon Sep 17 00:00:00 2001 From: "Curtis G. Northcutt" Date: Tue, 31 Jan 2023 23:26:20 -0800 Subject: [PATCH 103/258] Add two methods to filter.find_label_issues (#595) "low_self_confidence" or "low_ normalized_margin" Co-authored-by: huiwengoh <45724323+huiwengoh@users.noreply.github.com> Co-authored-by: Jonas Mueller <1390638+jwmueller@users.noreply.github.com> --- cleanlab/count.py | 9 +++- cleanlab/filter.py | 98 ++++++++++++++++++++++++++++++++------ tests/test_filter_count.py | 62 ++++++++++++++++++++++++ 3 files changed, 153 insertions(+), 16 deletions(-) diff --git a/cleanlab/count.py b/cleanlab/count.py index 188f874c7a..de86abd9f6 100644 --- a/cleanlab/count.py +++ b/cleanlab/count.py @@ -205,12 +205,19 @@ def _num_label_issues_multilabel( ------- num_issues : int The estimated number of examples with label issues in the multi-label dataset. + + Note: We set the filter_by method as 'confident_learning' to match the non-multilabel case + (analog to the off_diagonal estimation method) """ from cleanlab.filter import find_label_issues issues_idx = find_label_issues( - labels=labels, pred_probs=pred_probs, confident_joint=confident_joint, multi_label=True + labels=labels, + pred_probs=pred_probs, + confident_joint=confident_joint, + multi_label=True, + filter_by="confident_learning", # specified to match num_label_issues ) return sum(issues_idx) diff --git a/cleanlab/filter.py b/cleanlab/filter.py index 0e07ea191a..bcc33e1037 100644 --- a/cleanlab/filter.py +++ b/cleanlab/filter.py @@ -32,10 +32,8 @@ from functools import reduce import platform -from cleanlab.count import calibrate_confident_joint -from cleanlab.rank import ( - order_label_issues, -) +from cleanlab.count import calibrate_confident_joint, num_label_issues +from cleanlab.rank import order_label_issues, get_label_quality_scores import cleanlab.internal.multilabel_scorer as ml_scorer from cleanlab.internal.validation import assert_valid_inputs from cleanlab.internal.util import ( @@ -141,7 +139,7 @@ class 0, 1, ..., K-1. label quality score (see :py:func:`rank.get_label_quality_scores `). - filter_by : {'prune_by_class', 'prune_by_noise_rate', 'both', 'confident_learning', 'predicted_neq_given'}, default='prune_by_noise_rate' + filter_by : {'prune_by_class', 'prune_by_noise_rate', 'both', 'confident_learning', 'predicted_neq_given', 'low_normalized_margin', 'low_self_confidence'}, default='prune_by_noise_rate' Method to determine which examples are flagged as having label issue, so you can filter/prune them from the dataset. Options: - ``'prune_by_noise_rate'``: filters examples with *high probability* of being mislabeled for every non-diagonal in the confident joint (see `prune_counts_matrix` in `filter.py`). These are the examples where (with high confidence) the given label is unlikely to match the predicted label for the example. @@ -149,6 +147,8 @@ class 0, 1, ..., K-1. - ``'both'``: filters only those examples that would be filtered by both ``'prune_by_noise_rate'`` and ``'prune_by_class'``. - ``'confident_learning'``: filters the examples counted as part of the off-diagonals of the confident joint. These are the examples that are confidently predicted to be a different label than their given label. - ``'predicted_neq_given'``: filters examples for which the predicted class (i.e. argmax of the predicted probabilities) does not match the given label. + - ``'low_normalized_margin'``: filters the examples with *smallest* normalized margin label quality score. The number of issues returned matches :py:func:`count.num_label_issues `. + - ``'low_self_confidence'``: filters the examples with *smallest* self confidence label quality score. The number of issues returned matches :py:func:`count.num_label_issues `. multi_label : bool, optional If ``True``, labels should be an iterable (e.g. list) of iterables, containing a @@ -223,6 +223,8 @@ class 0, 1, ..., K-1. rank_by_kwargs = {} assert filter_by in [ + "low_normalized_margin", + "low_self_confidence", "prune_by_noise_rate", "prune_by_class", "both", @@ -241,22 +243,32 @@ class 0, 1, ..., K-1. allow_one_class=allow_one_class, ) - if filter_by in ["confident_learning", "predicted_neq_given"] and ( - frac_noise != 1.0 or num_to_remove_per_class is not None - ): + if filter_by in [ + "confident_learning", + "predicted_neq_given", + "low_normalized_margin", + "low_self_confidences", + ] and (frac_noise != 1.0 or num_to_remove_per_class is not None): warn_str = ( "frac_noise and num_to_remove_per_class parameters are only supported" " for filter_by 'prune_by_noise_rate', 'prune_by_class', and 'both'. They " - "are not supported for methods 'confident_learning' or " - "'predicted_neq_given'." + "are not supported for methods 'confident_learning', 'predicted_neq_given', " + "'low_normalized_margin' or 'low_self_confidence'." ) warnings.warn(warn_str) if (num_to_remove_per_class is not None) and ( - filter_by in ["confident_learning", "predicted_neq_given"] + filter_by + in [ + "confident_learning", + "predicted_neq_given", + "low_normalized_margin", + "low_self_confidences", + ] ): - # TODO - add support for these two filters + # TODO - add support for these filters raise ValueError( - "filter_by 'confident_learning' or 'predicted_neq_given' is not supported (yet) when setting 'num_to_remove_per_class'" + "filter_by 'confident_learning', 'predicted_neq_given', 'low_normalized_margin' " + "or 'low_self_confidence' is not supported (yet) when setting 'num_to_remove_per_class'" ) if filter_by is "confident_learning" and isinstance(confident_joint, np.ndarray): warn_str = ( @@ -329,6 +341,25 @@ class 0, 1, ..., K-1. multi_label=multi_label, return_indices_of_off_diagonals=True, ) + + if filter_by in ["low_normalized_margin", "low_self_confidence"]: + # TODO: consider setting adjust_pred_probs to true based on benchmarks (or adding it kwargs, or ignoring and leaving as false by default) + scores = get_label_quality_scores( + labels, + pred_probs, + method=filter_by[4:], + adjust_pred_probs=False, + ) + num_errors = num_label_issues( + labels, pred_probs, multi_label=multi_label # TODO: Check usage of multilabel + ) + # Find label issues O(nlogn) solution (mapped to boolean mask later in the method) + cl_error_indices = np.argsort(scores)[:num_errors] + # The following is the O(n) fastest solution (check for one-off errors), but the problem is if lots of the scores are identical you will overcount, + # you can end up returning more or less and they aren't ranked in the boolean form so there's no way to drop the highest scores randomly + # boundary = np.partition(scores, num_errors)[num_errors] # O(n) solution + # label_issues_mask = scores <= boundary + if filter_by in ["prune_by_noise_rate", "prune_by_class", "both"]: # Create `prune_count_matrix` with the number of examples to remove in each class and # leave at least min_examples_per_class examples per class. @@ -413,7 +444,7 @@ class 0, 1, ..., K-1. if filter_by == "both": label_issues_mask = label_issues_mask & label_issues_mask_by_class - if filter_by == "confident_learning": + if filter_by in ["confident_learning", "low_normalized_margin", "low_self_confidence"]: label_issues_mask = np.zeros(len(labels), dtype=bool) for idx in cl_error_indices: label_issues_mask[idx] = True @@ -462,6 +493,42 @@ def _find_label_issues_multilabel( This is done via a one-vs-rest reduction for each class and the results are subsequently aggregated across all classes. Here `labels` must be formatted as an iterable of iterables, e.g. ``List[List[int]]``. """ + + if filter_by in ["low_normalized_margin", "low_self_confidence"]: + num_errors = sum( + find_label_issues( + labels=labels, + pred_probs=pred_probs, + confident_joint=confident_joint, + multi_label=True, + filter_by="confident_learning", + ) + ) + + y_one, num_classes = get_onehot_num_classes(labels, pred_probs) + label_quality_scores = ml_scorer.get_label_quality_scores( + labels=y_one, + pred_probs=pred_probs, + ) + + cl_error_indices = np.argsort(label_quality_scores)[:num_errors] + label_issues_mask = np.zeros(len(labels), dtype=bool) + for idx in cl_error_indices: + label_issues_mask[idx] = True + + if return_indices_ranked_by is not None: + label_quality_scores_issues = ml_scorer.get_label_quality_scores( + labels=y_one[label_issues_mask], + pred_probs=pred_probs[label_issues_mask], + method=ml_scorer.MultilabelScorer( + base_scorer=ml_scorer.ClassLabelScorer.from_str(return_indices_ranked_by), + ), + base_scorer_kwargs=rank_by_kwargs, + ) + return cl_error_indices[np.argsort(label_quality_scores_issues)] + + return label_issues_mask + per_class_issues = _find_multilabel_issues_per_class( labels, pred_probs, @@ -529,7 +596,8 @@ class 0, 1, ..., K-1. They need not sum to 1.0 rank_by_kwargs : dict, optional Refer to documentation for this argument in filter.find_label_issues() for details. - filter_by : {'prune_by_class', 'prune_by_noise_rate', 'both', 'confident_learning', 'predicted_neq_given'}, default='prune_by_noise_rate' + filter_by : {'prune_by_class', 'prune_by_noise_rate', 'both', 'confident_learning', 'predicted_neq_given', + 'low_normalized_margin', 'low_self_confidences'}, default='prune_by_noise_rate' Refer to documentation for this argument in filter.find_label_issues() for details. frac_noise : float, default=1.0 diff --git a/tests/test_filter_count.py b/tests/test_filter_count.py index 81962b9a81..4e0de2c08a 100644 --- a/tests/test_filter_count.py +++ b/tests/test_filter_count.py @@ -865,6 +865,7 @@ def test_num_label_issues_multilabel(confident_joint): labels=dataset["labels"], pred_probs=dataset["pred_probs"], confident_joint=dataset["cj"] if confident_joint else None, + filter_by="confident_learning", multi_label=True, ) assert sum(f) == n @@ -1131,3 +1132,64 @@ def test_estimate_py_and_noise_matrices_missing_classes(): ] ) _ = estimate_py_and_noise_matrices_from_probabilities(labels, pred_probs3) + + +def test_low_filter_by_methods(): + dataset = data + num_issues = count.num_label_issues(dataset["labels"], dataset["pred_probs"]) + + # test filter by low_normalized_margin, check num issues is same as using count.num_label_issues + label_issues_nm = filter.find_label_issues( + dataset["labels"], dataset["pred_probs"], filter_by="low_normalized_margin" + ) + assert sum(label_issues_nm) == num_issues + + # test filter by low_self_confidence, check num issues is same as using count.num_label_issues + label_issues_sc = filter.find_label_issues( + dataset["labels"], + dataset["pred_probs"], + filter_by="low_self_confidence", + return_indices_ranked_by="normalized_margin", + ) + assert len(label_issues_sc) == num_issues + + label_issues_sc_sort = filter.find_label_issues( + dataset["labels"], + dataset["pred_probs"], + filter_by="low_self_confidence", + return_indices_ranked_by="confidence_weighted_entropy", + ) + assert set(label_issues_sc) == set(label_issues_sc_sort) + + +def test_low_filter_by_methods_multilabel(): + dataset = multilabel_data + num_issues = count.num_label_issues(dataset["labels"], dataset["pred_probs"], multi_label=True) + + # test filter by low_normalized_margin, check num issues is same as using count.num_label_issues + label_issues_nm = filter.find_label_issues( + dataset["labels"], + dataset["pred_probs"], + filter_by="low_normalized_margin", + multi_label=True, + ) + assert sum(label_issues_nm) == num_issues + + # test filter by low_self_confidence, check num issues is same as using count.num_label_issues + label_issues_sc = filter.find_label_issues( + dataset["labels"], + dataset["pred_probs"], + filter_by="low_self_confidence", + multi_label=True, + return_indices_ranked_by="confidence_weighted_entropy", + ) + assert len(label_issues_sc) == num_issues + + label_issues_sc_sort = filter.find_label_issues( + dataset["labels"], + dataset["pred_probs"], + filter_by="low_self_confidence", + multi_label=True, + return_indices_ranked_by="self_confidence", + ) + assert set(label_issues_sc) == set(label_issues_sc_sort) From 35d5323479b340c6076f0136c8e0f7d161762dad Mon Sep 17 00:00:00 2001 From: Ulyana Date: Wed, 1 Feb 2023 20:07:31 -0800 Subject: [PATCH 104/258] Fix dictionary type annotation for OutOfDistribution object (#616) * Also improve params dict default to be None --- cleanlab/outlier.py | 8 +++++--- tests/test_outlier.py | 5 +++-- 2 files changed, 8 insertions(+), 5 deletions(-) diff --git a/cleanlab/outlier.py b/cleanlab/outlier.py index 57011788f8..0ac6ce5d4b 100644 --- a/cleanlab/outlier.py +++ b/cleanlab/outlier.py @@ -93,7 +93,7 @@ class OutOfDistribution: OUTLIER_PARAMS = {"k", "t", "knn"} OOD_PARAMS = {"confident_thresholds", "adjust_pred_probs", "method"} - DEFAULT_PARAM_DICT: Dict[Union[str, int, None], Union[str, int, None, np.ndarray]] = { + DEFAULT_PARAM_DICT: Dict[str, Union[str, int, None, np.ndarray]] = { "k": None, # ood features param "t": 1, # ood features param "knn": None, # ood features param @@ -102,9 +102,11 @@ class OutOfDistribution: "confident_thresholds": None, # ood pred_probs param } - def __init__(self, params: dict = {}): + def __init__(self, params: Optional[dict] = None) -> None: self._assert_valid_params(params, self.DEFAULT_PARAM_DICT) self.params = self.DEFAULT_PARAM_DICT + if params is None: + params = {} self.params = {**self.params, **params} def fit_score( @@ -280,7 +282,7 @@ def _assert_valid_params(params, param_keys): """ Helper method to check passed in params valid and get list of parameters in param that are not in param_keys. """ - if len(params) > 0: + if params is not None: wrong_params = list(set(params.keys()).difference(set(param_keys))) if len(wrong_params) > 0: raise ValueError( diff --git a/tests/test_outlier.py b/tests/test_outlier.py index 8d330a5892..f1f5b2bfd6 100644 --- a/tests/test_outlier.py +++ b/tests/test_outlier.py @@ -251,11 +251,12 @@ def test_class_public_func(): # Testing regular fit OOD_ood = OutOfDistribution() + print(OOD_ood.params) OOD_ood.fit(pred_probs=pred_probs, labels=labels) - + print(OOD_ood.params) OOD_outlier = OutOfDistribution() OOD_outlier.fit(features=features) - + print(OOD_outlier.params) assert OOD_ood.params["confident_thresholds"] is not None and OOD_ood.params["knn"] is None assert ( OOD_outlier.params["knn"] is not None and OOD_outlier.params["confident_thresholds"] is None From 266d9479dbc7a55eed8582081aa6b71862fa8596 Mon Sep 17 00:00:00 2001 From: Jonas Mueller <1390638+jwmueller@users.noreply.github.com> Date: Wed, 1 Feb 2023 22:53:02 -0800 Subject: [PATCH 105/258] shorten notebook name in link (#617) --- docs/source/tutorials/multiannotator.ipynb | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/source/tutorials/multiannotator.ipynb b/docs/source/tutorials/multiannotator.ipynb index a4263da465..617551272b 100644 --- a/docs/source/tutorials/multiannotator.ipynb +++ b/docs/source/tutorials/multiannotator.ipynb @@ -15,7 +15,7 @@ "source": [ "This 5-minute quickstart tutorial shows how to use cleanlab for classification data that has been labeled by multiple annotators (where each example has been labeled by at least one annotator, but not every annotator has labeled every example). Compared to existing crowdsourcing tools, cleanlab helps you better analyze such data by leveraging a trained classifier model in addition to the raw annotations. With one line of code, you can automatically compute:\n", "\n", - "- A **consensus label** for each example that aggregates the individual annotations more accurately than alternative aggregation via majority-vote or other algorithms used in crowdsourcing.\n", + "- A **consensus label** for each example (i.e. *truth inference*) that aggregates the individual annotations (more accurately than algorithms from crowdsourcing like majority-vote, Dawid-Skene, or GLAD).\n", "- a **quality score for each consensus label** which measures our confidence that this label is correct (via well-calibrated estimates that account for the: number annotators which have labeled this example, overall quality of each annotator, and quality of our trained ML models).\n", "- An analogous **label quality score** for each individual label chosen by one annotator for a particular example.\n", "- An **overall quality score for each annotator** which measures our confidence in the overall correctness of labels obtained from this annotator.\n", @@ -710,7 +710,7 @@ "You can also repeatedly iterate this process of getting better consensus labels using the model's out-of-sample predicted probabilities and then retraining the model with the improved labels to get even better predicted probabilities!\n", "For details, see our [examples](https://github.com/cleanlab/examples) notebook on [Iterative use of Cleanlab to Improve Classification Models (and Consensus Labels) from Data Labeled by Multiple Annotators](https://github.com/cleanlab/examples/blob/master/multiannotator_cifar10/multiannotator_cifar10.ipynb).\n", "\n", - "If possible, the best way to improve your model is to collect additional labels for both previously annotated data and extra not-yet-labeled examples. To decide which data is most informative to label next, use `cleanlab.multiannotator.get_active_learning_scores()` rather than the methods shown here. This is demonstrated in our [examples](https://github.com/cleanlab/examples) notebook on [Active Learning with Multiple Data Annotators via CROWDLAB](https://github.com/cleanlab/examples/blob/master/active_learning_multiannotator/active_learning.ipynb).\n", + "If possible, the best way to improve your model is to collect additional labels for both previously annotated data and extra not-yet-labeled examples. To decide which data is most informative to label next, use `cleanlab.multiannotator.get_active_learning_scores()` rather than the methods shown here. This is demonstrated in our [examples](https://github.com/cleanlab/examples) notebook on [Active Learning with Multiple Data Annotators](https://github.com/cleanlab/examples/blob/master/active_learning_multiannotator/active_learning.ipynb).\n", "\n", "\n", "## How does cleanlab.multiannotator work?\n", From 6ed61e0bb30e023fb8b1dedbcdc44d9bcb3eb8d0 Mon Sep 17 00:00:00 2001 From: Jonas Mueller <1390638+jwmueller@users.noreply.github.com> Date: Thu, 2 Feb 2023 01:13:59 -0800 Subject: [PATCH 106/258] cap black version in CI (#618) --- .github/workflows/ci.yml | 2 ++ 1 file changed, 2 insertions(+) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index ec5e8bb98a..3dddf8e3f6 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -59,6 +59,8 @@ jobs: steps: - uses: actions/checkout@v3 - uses: psf/black@stable + with: + version: "~= 22.0" flake8: name: Check for unused/wildcard imports runs-on: ubuntu-latest From c191d8781daf92e5a8c962685814a1a18a267e94 Mon Sep 17 00:00:00 2001 From: Ulyana Date: Tue, 7 Feb 2023 10:01:45 -0800 Subject: [PATCH 107/258] Fix format compatibility with latest black==23. release (#620) --- .github/workflows/ci.yml | 2 -- cleanlab/classification.py | 2 -- cleanlab/experimental/coteaching.py | 1 + cleanlab/experimental/mnist_pytorch.py | 1 - cleanlab/internal/multiannotator_utils.py | 2 +- cleanlab/multiannotator.py | 1 - cleanlab/rank.py | 5 ----- tests/test_multilabel_classification.py | 2 -- tests/test_rank.py | 1 - 9 files changed, 2 insertions(+), 15 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 3dddf8e3f6..ec5e8bb98a 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -59,8 +59,6 @@ jobs: steps: - uses: actions/checkout@v3 - uses: psf/black@stable - with: - version: "~= 22.0" flake8: name: Check for unused/wildcard imports runs-on: ubuntu-latest diff --git a/cleanlab/classification.py b/cleanlab/classification.py index 407afef0f6..66126de932 100644 --- a/cleanlab/classification.py +++ b/cleanlab/classification.py @@ -229,7 +229,6 @@ def __init__( label_quality_scores_kwargs={}, verbose=False, ): - if clf is None: # Use logistic regression if no classifier is provided. clf = LogReg(multi_class="auto", solver="lbfgs") @@ -645,7 +644,6 @@ def score(self, X, y, sample_weight=None) -> float: """ if hasattr(self.clf, "score"): - # Check if sample_weight in clf.score() if "sample_weight" in inspect.getfullargspec(self.clf.score).args: return self.clf.score(X, y, sample_weight=sample_weight) diff --git a/cleanlab/experimental/coteaching.py b/cleanlab/experimental/coteaching.py index 8d46f523f5..83223ff523 100644 --- a/cleanlab/experimental/coteaching.py +++ b/cleanlab/experimental/coteaching.py @@ -35,6 +35,7 @@ MINIMUM_BATCH_SIZE = 16 + # Loss function for Co-Teaching def loss_coteaching( y_1, diff --git a/cleanlab/experimental/mnist_pytorch.py b/cleanlab/experimental/mnist_pytorch.py index 3166b68f16..180f628f82 100644 --- a/cleanlab/experimental/mnist_pytorch.py +++ b/cleanlab/experimental/mnist_pytorch.py @@ -311,7 +311,6 @@ def fit(self, train_idx, train_labels=None, sample_weight=None, loader="train"): # Train for self.epochs epochs for epoch in range(1, self.epochs + 1): - # Enable dropout and batch norm layers self.model.train() for batch_idx, (data, target) in enumerate(train_loader): diff --git a/cleanlab/internal/multiannotator_utils.py b/cleanlab/internal/multiannotator_utils.py index 93cec654fc..27e73eb079 100644 --- a/cleanlab/internal/multiannotator_utils.py +++ b/cleanlab/internal/multiannotator_utils.py @@ -200,7 +200,7 @@ def format_multiannotator_labels(labels: LabelLike) -> Tuple[pd.DataFrame, dict] try: unique_labels = unique_labels[~np.isnan(unique_labels)] unique_labels.sort() - except (TypeError): # np.unique / np.sort cannot handle string values or pd.NA types + except TypeError: # np.unique / np.sort cannot handle string values or pd.NA types nan_mask = np.array([(l is np.NaN) or (l is pd.NA) or (l == "nan") for l in unique_labels]) unique_labels = unique_labels[~nan_mask] unique_labels.sort() diff --git a/cleanlab/multiannotator.py b/cleanlab/multiannotator.py index bf653e1da0..682142bff7 100644 --- a/cleanlab/multiannotator.py +++ b/cleanlab/multiannotator.py @@ -1227,7 +1227,6 @@ def _get_post_pred_probs_and_weights( quality_method: str = "crowdlab", verbose: bool = True, ) -> Tuple[np.ndarray, Any, Any]: - """Return the posterior predicted probabilities of each example given a specified quality method. Parameters diff --git a/cleanlab/rank.py b/cleanlab/rank.py index ae0f455a86..b00deafff3 100644 --- a/cleanlab/rank.py +++ b/cleanlab/rank.py @@ -140,7 +140,6 @@ class 0, 1, ..., K-1. # Adjust predicted probabilities if adjust_pred_probs: - # Check if adjust_pred_probs is supported for the chosen method if method == "confidence_weighted_entropy": raise ValueError(f"adjust_pred_probs is not currently supported for {method}.") @@ -259,14 +258,12 @@ def get_label_quality_ensemble_scores( # This weighting scheme performs search of t in log_loss_search_T_values for "best" log loss if weight_ensemble_members_by == "log_loss_search": - # Initialize variables for log loss search pred_probs_avg_log_loss_weighted = None neg_log_loss_weights = None best_eval_log_loss = float("inf") for t in log_loss_search_T_values: - neg_log_loss_list = [] # pred_probs for each model @@ -299,7 +296,6 @@ def get_label_quality_ensemble_scores( scores_list = [] accuracy_list = [] for pred_probs in pred_probs_list: - # Calculate scores and accuracy scores = get_label_quality_scores( labels=labels, @@ -349,7 +345,6 @@ def get_label_quality_ensemble_scores( label_quality_scores = (scores_ensemble * weights).sum(axis=1) elif weight_ensemble_members_by == "custom": - # Check custom_weights for errors assert ( custom_weights is not None diff --git a/tests/test_multilabel_classification.py b/tests/test_multilabel_classification.py index 9454b884d3..ac1d3afb57 100644 --- a/tests/test_multilabel_classification.py +++ b/tests/test_multilabel_classification.py @@ -388,7 +388,6 @@ def test_multilabel_py(given_labels, expected): @pytest.mark.parametrize("K", [2, 3, 4], ids=["K=2", "K=3", "K=4"]) def test_get_split_generator(cv, K): - all_configurations = np.array(list(itertools.product([0, 1], repeat=K))) given_labels = np.repeat(all_configurations, 2, axis=0) @@ -412,7 +411,6 @@ def test_get_split_generator(cv, K): # Test split_generator with rare/missing multilabel configurations @pytest.mark.parametrize("K", [2, 3, 4], ids=["K=2", "K=3", "K=4"]) def test_get_split_generator_rare_configurations(cv, K): - all_configurations = np.array(list(itertools.product([0, 1], repeat=K))) given_labels = np.repeat(all_configurations, 2, axis=0) diff --git a/tests/test_rank.py b/tests/test_rank.py index 3d3c2e1155..e928587774 100644 --- a/tests/test_rank.py +++ b/tests/test_rank.py @@ -153,7 +153,6 @@ def test_order_label_issues_using_scoring_func_ranking(scoring_method_func, adju # do not run the test below if the method does not support adjust_pred_probs # confidence_weighted_entropy scoring method does not support adjust_pred_probs if not (adjust_pred_probs == True and method == "confidence_weighted_entropy"): - indices = np.arange(len(data["label_errors_mask"]))[ data["label_errors_mask"] ] # indices of label issues From 6aaee8332b92c377f800c6c0263cc2b90a308cee Mon Sep 17 00:00:00 2001 From: Hui Wen <45724323+huiwengoh@users.noreply.github.com> Date: Wed, 8 Feb 2023 02:03:32 +0800 Subject: [PATCH 108/258] Create new cleanlab.models module (#601) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Jonas Mueller <1390638+jwmueller@users.noreply.github.com> Co-authored-by: Elías Snorrason --- .github/workflows/ci.yml | 6 + cleanlab/experimental/README.md | 4 - cleanlab/models/README.md | 11 ++ cleanlab/models/__init__.py | 0 cleanlab/{experimental => models}/fasttext.py | 2 +- cleanlab/{experimental => models}/keras.py | 91 +++++++++--- docs/source/cleanlab/experimental/index.rst | 2 - .../{experimental => models}/fasttext.rst | 2 +- docs/source/cleanlab/models/index.rst | 15 ++ .../{experimental => models}/keras.rst | 2 +- docs/source/index.rst | 1 + docs/source/tutorials/text.ipynb | 22 ++- requirements-dev.txt | 1 + setup.cfg | 1 + tests/test_frameworks.py | 133 +++++++++++++++++- 15 files changed, 257 insertions(+), 36 deletions(-) create mode 100644 cleanlab/models/README.md create mode 100644 cleanlab/models/__init__.py rename cleanlab/{experimental => models}/fasttext.py (99%) rename cleanlab/{experimental => models}/keras.py (69%) rename docs/source/cleanlab/{experimental => models}/fasttext.rst (65%) create mode 100644 docs/source/cleanlab/models/index.rst rename docs/source/cleanlab/{experimental => models}/keras.rst (58%) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index ec5e8bb98a..73ac0fa216 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -30,6 +30,10 @@ jobs: run: python3 -c "import cleanlab" - name: Install development dependencies run: pip install -r requirements-dev.txt + - name: Install fasttext for non-Windows machines + if: matrix.os != 'windows-latest' + run: | + pip install fasttext - name: Overwrite tensorflow version on Windows if: matrix.os == 'windows-latest' run: | @@ -37,6 +41,8 @@ jobs: pip install tensorflow-cpu - name: Test with coverage run: pytest --verbose --cov=cleanlab/ --cov-config .coveragerc --cov-report=xml + env: + TEST_FASTTEXT: true - uses: codecov/codecov-action@v3 typecheck: name: Type check diff --git a/cleanlab/experimental/README.md b/cleanlab/experimental/README.md index 3c93ec9c71..d16e67c99b 100644 --- a/cleanlab/experimental/README.md +++ b/cleanlab/experimental/README.md @@ -5,10 +5,6 @@ Methods in this `experimental` module are bleeding edge and may have sharp edges Some of these files include various models that can be used with cleanlab to find issues in specific types of data. These require dependencies on deep learning and other machine learning packages that are not official cleanlab dependencies. You must install these dependencies on your own if you wish to use them. The dependencies are as follows: -* keras.py - a wrapper to make any Keras model compatible with cleanlab and sklearn - - tensorflow -* fasttext.py - a cleanlab-compatible FastText classifier for text data - - fasttext * mnist_pytorch.py - a cleanlab-compatible simplified AlexNet for MNIST using PyTorch - torch - torchvision diff --git a/cleanlab/models/README.md b/cleanlab/models/README.md new file mode 100644 index 0000000000..6551aa13ea --- /dev/null +++ b/cleanlab/models/README.md @@ -0,0 +1,11 @@ +# Useful models adapted for use with cleanlab + +Methods in this ``models`` module are not guaranteed to be stable between different ``cleanlab`` versions. + +Some of these files include various models that can be used with cleanlab to find issues in specific types of data. These require dependencies on deep learning and other machine learning packages that are not official cleanlab dependencies. You must install these dependencies on your own if you wish to use them. + +The dependencies are as follows: +* keras.py - a wrapper to make any Keras model compatible with cleanlab and sklearn + - tensorflow +* fasttext.py - a cleanlab-compatible FastText classifier for text data + - fasttext diff --git a/cleanlab/models/__init__.py b/cleanlab/models/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/cleanlab/experimental/fasttext.py b/cleanlab/models/fasttext.py similarity index 99% rename from cleanlab/experimental/fasttext.py rename to cleanlab/models/fasttext.py index ad1a7923a4..1da6d766ad 100644 --- a/cleanlab/experimental/fasttext.py +++ b/cleanlab/models/fasttext.py @@ -151,7 +151,7 @@ def _create_train_data(self, data_indices): masked_fn = "fastTextClf_" + str(int(time.time())) + ".txt" open(masked_fn, "w").close() # Read in training data one line at a time - with open(self.train_data_fn, "rU") as rf: + with open(self.train_data_fn, "r") as rf: idx = 0 data_idx = data_indices.pop() for line in rf: diff --git a/cleanlab/experimental/keras.py b/cleanlab/models/keras.py similarity index 69% rename from cleanlab/experimental/keras.py rename to cleanlab/models/keras.py index 4e34567b47..d44ea6559f 100644 --- a/cleanlab/experimental/keras.py +++ b/cleanlab/models/keras.py @@ -36,10 +36,9 @@ """ import tensorflow as tf +import keras # type: ignore import numpy as np -import pandas as pd from typing import Callable, Optional -from cleanlab.internal.validation import assert_valid_inputs class KerasWrapperModel: @@ -75,44 +74,63 @@ def __init__( compile_kwargs: dict = { "loss": tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True) }, + params: Optional[dict] = None, ): + if params is None: + params = {} + self.model = model self.model_kwargs = model_kwargs self.compile_kwargs = compile_kwargs + self.params = params self.net = None def get_params(self, deep=True): + """Returns the parameters of the Keras model.""" return { "model": self.model, "model_kwargs": self.model_kwargs, "compile_kwargs": self.compile_kwargs, + "params": self.params, } + def set_params(self, **params): + """Set the parameters of the Keras model.""" + self.params.update(params) + return self + def fit(self, X, y=None, **kwargs): - """Trains a Keras classifier. + """Trains a Keras model. Parameters ---------- X : tf.Dataset or np.array or pd.DataFrame - If `X` is a tensorflow dataset object, it must already contain the labels as is required for standard Keras fit. + If ``X`` is a tensorflow dataset object, it must already contain the labels as is required for standard Keras fit. y : np.array or pd.DataFrame, default = None - If `X` is a tensorflow dataset object, you can optionally provide the labels again here as argument `y` to be compatible with sklearn, + If ``X`` is a tensorflow dataset object, you can optionally provide the labels again here as argument `y` to be compatible with sklearn, but they are ignored. - If `X` is a numpy array or pandas dataframe, the labels have to be passed in using this argument. + If ``X`` is a numpy array or pandas dataframe, the labels have to be passed in using this argument. """ self.net = self.model(**self.model_kwargs) self.net.compile(**self.compile_kwargs) - if isinstance(X, (np.ndarray, pd.DataFrame)): - assert_valid_inputs(X, y) + # TODO: check for generators + if y is not None and not isinstance(X, (tf.data.Dataset, keras.utils.Sequence)): kwargs["y"] = y - self.net.fit(X, **kwargs) + self.net.fit(X, **{**self.params, **kwargs}) def predict_proba(self, X, *, apply_softmax=True, **kwargs): - """Set extra argument `apply_softmax` to True to indicate your network only outputs logits not probabilities.""" + """Predict class probabilities for all classes using the wrapped Keras model. + Set extra argument `apply_softmax` to True to indicate your network only outputs logits not probabilities. + + Parameters + ---------- + X : tf.Dataset or np.array or pd.DataFrame + Data in the same format as the original ``X`` provided to ``fit()``. + """ if self.net is None: raise ValueError("must call fit() before predict()") pred_probs = self.net.predict(X, **kwargs) @@ -121,10 +139,19 @@ def predict_proba(self, X, *, apply_softmax=True, **kwargs): return pred_probs def predict(self, X, **kwargs): + """Predict class labels using the wrapped Keras model. + + Parameters + ---------- + X : tf.Dataset or np.array or pd.DataFrame + Data in the same format as the original ``X`` provided to ``fit()``. + + """ pred_probs = self.predict_proba(X, **kwargs) return np.argmax(pred_probs, axis=1) def summary(self, **kwargs): + """Returns the summary of the Keras model.""" self.net.summary(**kwargs) @@ -154,43 +181,63 @@ def __init__( compile_kwargs: dict = { "loss": tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True) }, + params: Optional[dict] = None, ): + if params is None: + params = {} + self.layers = layers self.name = name self.compile_kwargs = compile_kwargs + self.params = params self.net = None def get_params(self, deep=True): + """Returns the parameters of the Keras model.""" return { "layers": self.layers, "name": self.name, "compile_kwargs": self.compile_kwargs, + "params": self.params, } + def set_params(self, **params): + """Set the parameters of the Keras model.""" + for key, value in params.items(): + self.params[key] = value + return self + def fit(self, X, y=None, **kwargs): - """Trains a Sequential Keras classifier. + """Trains a Sequential Keras model. Parameters ---------- X : tf.Dataset or np.array or pd.DataFrame - If `X` is a tensorflow dataset object, it must already contain the labels as is required for standard Keras fit. + If ``X`` is a tensorflow dataset object, it must already contain the labels as is required for standard Keras fit. y : np.array or pd.DataFrame, default = None - If `X` is a tensorflow dataset object, you can optionally provide the labels again here as argument `y` to be compatible with sklearn, + If ``X`` is a tensorflow dataset object, you can optionally provide the labels again here as argument `y` to be compatible with sklearn, but they are ignored. - If `X` is a numpy array or pandas dataframe, the labels have to be passed in using this argument. + If ``X`` is a numpy array or pandas dataframe, the labels have to be passed in using this argument. """ self.net = tf.keras.models.Sequential(self.layers, self.name) self.net.compile(**self.compile_kwargs) - if isinstance(X, (np.ndarray, pd.DataFrame)): - assert_valid_inputs(X, y) + # TODO: check for generators + if y is not None and not isinstance(X, (tf.data.Dataset, keras.utils.Sequence)): kwargs["y"] = y - self.net.fit(X, **kwargs) + self.net.fit(X, **{**self.params, **kwargs}) def predict_proba(self, X, *, apply_softmax=True, **kwargs): - """Set extra argument `apply_softmax` to True to indicate your network only outputs logits not probabilities.""" + """Predict class probabilities for all classes using the wrapped Keras model. + Set extra argument `apply_softmax` to True to indicate your network only outputs logits not probabilities. + + Parameters + ---------- + X : tf.Dataset or np.array or pd.DataFrame + Data in the same format as the original ``X`` provided to ``fit()``. + """ if self.net is None: raise ValueError("must call fit() before predict()") pred_probs = self.net.predict(X, **kwargs) @@ -199,8 +246,16 @@ def predict_proba(self, X, *, apply_softmax=True, **kwargs): return pred_probs def predict(self, X, **kwargs): + """Predict class labels using the wrapped Keras model. + + Parameters + ---------- + X : tf.Dataset or np.array or pd.DataFrame + Data in the same format as the original ``X`` provided to ``fit()``. + """ pred_probs = self.predict_proba(X, **kwargs) return np.argmax(pred_probs, axis=1) def summary(self, **kwargs): + """Returns the summary of the Keras model.""" self.net.summary(**kwargs) diff --git a/docs/source/cleanlab/experimental/index.rst b/docs/source/cleanlab/experimental/index.rst index 4d32910206..935152c86c 100644 --- a/docs/source/cleanlab/experimental/index.rst +++ b/docs/source/cleanlab/experimental/index.rst @@ -11,8 +11,6 @@ experimental :show-inheritance: .. toctree:: - keras - fasttext mnist_pytorch coteaching cifar_cnn diff --git a/docs/source/cleanlab/experimental/fasttext.rst b/docs/source/cleanlab/models/fasttext.rst similarity index 65% rename from docs/source/cleanlab/experimental/fasttext.rst rename to docs/source/cleanlab/models/fasttext.rst index 792b769342..78efe7677a 100644 --- a/docs/source/cleanlab/experimental/fasttext.rst +++ b/docs/source/cleanlab/models/fasttext.rst @@ -1,7 +1,7 @@ fasttext ======== -.. automodule:: cleanlab.experimental.fasttext +.. automodule:: cleanlab.models.fasttext :autosummary: :members: :undoc-members: diff --git a/docs/source/cleanlab/models/index.rst b/docs/source/cleanlab/models/index.rst new file mode 100644 index 0000000000..d095a7b18f --- /dev/null +++ b/docs/source/cleanlab/models/index.rst @@ -0,0 +1,15 @@ +models +====== + +.. warning:: + Methods in this ``models`` module are not guaranteed to be stable between different ``cleanlab`` versions. + +.. automodule:: cleanlab.models + :autosummary: + :members: + :undoc-members: + :show-inheritance: + +.. toctree:: + keras + fasttext \ No newline at end of file diff --git a/docs/source/cleanlab/experimental/keras.rst b/docs/source/cleanlab/models/keras.rst similarity index 58% rename from docs/source/cleanlab/experimental/keras.rst rename to docs/source/cleanlab/models/keras.rst index f35f93c455..c9ff1b3138 100644 --- a/docs/source/cleanlab/experimental/keras.rst +++ b/docs/source/cleanlab/models/keras.rst @@ -1,7 +1,7 @@ keras ===== -.. automodule:: cleanlab.experimental.keras +.. automodule:: cleanlab.models.keras :autosummary: :members: :undoc-members: diff --git a/docs/source/index.rst b/docs/source/index.rst index 7e62505e44..76bebb5ace 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -142,6 +142,7 @@ Please see our `contributing guidelines `\n", @@ -284,7 +291,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "We use a `TextVectorization` layer to preprocess, tokenize, and vectorize our text data, thus making it suitable as input for a neural network.\n" + "Then, we use a `TextVectorization` layer to preprocess, tokenize, and vectorize our text data to a suitabable format for a neural network." ] }, { @@ -326,6 +333,13 @@ "test_texts = vectorize_layer(raw_test_texts).numpy()" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Our subsequent neural network models will directly operate on elements of `train_texts` and `test_texts` in order to classify reviews." + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -377,7 +391,7 @@ "source": [ "We can define the `CleanLearning` object with the neural network model and use `find_label_issues` to identify potential label errors.\n", "\n", - "`CleanLearning` provides a wrapper class that can easily be applied to any scikit-learn compatible model, which can be used to find potential label issues or train a more robust model if the original data contains noisy labels." + "`CleanLearning` provides a wrapper class that can easily be applied to any scikit-learn compatible model, which can be used to find potential label issues and train a more robust model if the original data contains noisy labels." ] }, { diff --git a/requirements-dev.txt b/requirements-dev.txt index d6c7a87a63..1dc5dc705c 100644 --- a/requirements-dev.txt +++ b/requirements-dev.txt @@ -13,3 +13,4 @@ torchvision skorch tensorflow psutil +wget diff --git a/setup.cfg b/setup.cfg index 04a05501c6..8888d3b898 100644 --- a/setup.cfg +++ b/setup.cfg @@ -5,3 +5,4 @@ per-file-ignores = cleanlab/__init__.py: F401 cleanlab/token_classification/__init__.py: F401 cleanlab/benchmarking/__init__.py: F401 + cleanlab/models/__init__.py: F401 diff --git a/tests/test_frameworks.py b/tests/test_frameworks.py index e4fccb7eae..f26e532b89 100644 --- a/tests/test_frameworks.py +++ b/tests/test_frameworks.py @@ -15,8 +15,8 @@ # along with cleanlab. If not, see . """ -Scripts to test cleanlab usage with deep learning frameworks: -pytorch, skorch, tensorflow, keras +Scripts to test cleanlab usage with various ML frameworks: +pytorch, skorch, tensorflow, keras, fasttext """ import pytest @@ -27,6 +27,7 @@ import sys import os +import wget from copy import deepcopy import random import numpy as np @@ -38,9 +39,13 @@ import tensorflow as tf import torch import skorch +from sklearn.pipeline import Pipeline +from sklearn.preprocessing import StandardScaler +from sklearn.model_selection import GridSearchCV from cleanlab.classification import CleanLearning -from cleanlab.experimental.keras import KerasWrapperSequential, KerasWrapperModel +from cleanlab.models.keras import KerasWrapperSequential, KerasWrapperModel +from cleanlab.internal.util import format_labels def python_version_ok(): # tensorflow and torch do not play nice with older Python @@ -48,6 +53,11 @@ def python_version_ok(): # tensorflow and torch do not play nice with older Pyt return (version.major >= 3) and (version.minor >= 7) +def run_fasttext_test(): + # run test only if os enviroment is set of true and os is not Windows + return os.environ.get("TEST_FASTTEXT") == "true" and os.name != "nt" + + def dataset_w_errors(): num_classes = 2 num_features = 3 @@ -158,7 +168,7 @@ def test_tensorflow_sequential(batch_size, shuffle_config, data=DATA, hidden_uni @pytest.mark.skipif("not python_version_ok()", reason="need at least python 3.7") @pytest.mark.parametrize("batch_size,shuffle_config", [(1, 0), (32, 0), (32, 1), (32, 2)]) -def test_tensorflow_functional(batch_size, shuffle_config, data=DATA, hidden_units=128): +def test_tensorflow_functional(batch_size, shuffle_config, data=DATA, hidden_units=64): dataset_tf = tf.data.Dataset.from_tensor_slices((data["X"], data["y"])) if shuffle_config == 0: # proper shuffling for SGD dataset_shuffled = dataset_tf.shuffle(buffer_size=len(data["X"])) @@ -172,7 +182,7 @@ def test_tensorflow_functional(batch_size, shuffle_config, data=DATA, hidden_uni def make_model(num_features, num_classes): inputs = tf.keras.Input(shape=(num_features,)) - x = tf.keras.layers.Dense(64, activation="relu")(inputs) + x = tf.keras.layers.Dense(hidden_units, activation="relu")(inputs) outputs = tf.keras.layers.Dense(num_classes)(x) model = tf.keras.Model(inputs=inputs, outputs=outputs, name="test_model") @@ -226,6 +236,66 @@ def test_tensorflow_rarelabel(batch_size, data=DATA_RARE_LABEL, hidden_units=8): preds = cl.predict(dataset_tf) +def test_keras_sklearn_compatability(data=DATA, hidden_units=32): + # test pipeline on Sequential API + model = KerasWrapperSequential( + [ + tf.keras.layers.Dense(128, input_shape=[data["num_features"]], activation="relu"), + tf.keras.layers.Dense(data["num_classes"]), + ], + ) + + pipeline = Pipeline([("scale", StandardScaler()), ("net", model)]) + pipeline.fit(data["X"], data["y"]) + preds = pipeline.predict(data["X"]) + + # test gridsearch on Sequential API + model = KerasWrapperSequential( + [ + tf.keras.layers.Dense( + hidden_units, input_shape=[data["num_features"]], activation="relu" + ), + tf.keras.layers.Dense(data["num_classes"]), + ], + ) + + params = {"batch_size": [32, 64], "epochs": [2, 3]} + gs = GridSearchCV( + model, params, refit=False, cv=3, verbose=2, scoring="accuracy", error_score="raise" + ) + gs.fit(data["X"], data["y"]) + + # test pipeline on functional API + def make_model(num_features, num_classes): + inputs = tf.keras.Input(shape=(num_features,)) + x = tf.keras.layers.Dense(64, activation="relu")(inputs) + outputs = tf.keras.layers.Dense(num_classes)(x) + model = tf.keras.Model(inputs=inputs, outputs=outputs, name="test_model") + + return model + + model = KerasWrapperModel( + make_model, + model_kwargs={"num_features": data["num_features"], "num_classes": data["num_classes"]}, + ) + + pipeline = Pipeline([("scale", StandardScaler()), ("net", model)]) + pipeline.fit(data["X"], data["y"]) + preds = pipeline.predict(data["X"]) + + # test gridsearch on Sequential API + model = KerasWrapperModel( + make_model, + model_kwargs={"num_features": data["num_features"], "num_classes": data["num_classes"]}, + ) + + params = {"batch_size": [32, 64], "epochs": [2, 3]} + gs = GridSearchCV( + model, params, refit=False, cv=3, verbose=2, scoring="accuracy", error_score="raise" + ) + gs.fit(data["X"], data["y"]) + + @pytest.mark.skipif("not python_version_ok()", reason="need at least python 3.7") def test_torch(data=DATA, hidden_units=128): dataset = torch.utils.data.TensorDataset( @@ -286,3 +356,56 @@ def forward(self, X): cl = CleanLearning(net) cl.fit(dataset, data["y"], clf_kwargs={"epochs": 2}) pred_probs = cl.predict(dataset) + + +# test fasttext only if not on windows and environment variable TEST_FASTTEXT has been set to "true" +@pytest.mark.skipif( + "not run_fasttext_test()", reason="fasttext is not easily pip install-able on windows" +) +def test_fasttext(): + from cleanlab.models.fasttext import FastTextClassifier, data_loader + + dir = "tests/fasttext_data" + if not os.path.isdir(dir): + os.makedirs(dir) + + try: + if not os.path.isfile("tests/fasttext_data/tweets_train.txt"): + wget.download( + "http://s.cleanlab.ai/tweets_fasttext/tweets_train.txt", "tests/fasttext_data" + ) + if not os.path.isfile("tests/fasttext_data/tweets_test.txt"): + wget.download( + "http://s.cleanlab.ai/tweets_fasttext/tweets_test.txt", "tests/fasttext_data" + ) + except: + raise RuntimeError( + "Download failed (potentially due to lack of internet connection or invalid url). " + "To skip this unittest, set the env variable TEST_FASTTEXT = false." + ) + + labels = np.ravel([x[0] for x in data_loader("tests/fasttext_data/tweets_train.txt")]) + labels = [lab[9:] for lab in labels] + labels, label_map = format_labels(labels) + X = np.array(range(len(labels))) + + # test basic fasttext methods + ftc = FastTextClassifier( + train_data_fn="tests/fasttext_data/tweets_train.txt", + test_data_fn="tests/fasttext_data/tweets_test.txt", + ) + ftc.fit() + pred_labels = ftc.predict() + pred_probs = ftc.predict_proba() + + # test CleanLearning + ftc = FastTextClassifier( + train_data_fn="tests/fasttext_data/tweets_train.txt", + test_data_fn="tests/fasttext_data/tweets_test.txt", + ) + cl = CleanLearning(ftc) + + issues = cl.find_label_issues(X=X, labels=labels) + cl.fit(X=X, labels=labels, label_issues=issues) + pred_labels = cl.predict() + pred_probs = cl.predict_proba() From e2611e76a1a11595a7b4ec84ac699e39ba1424bc Mon Sep 17 00:00:00 2001 From: Jonas Mueller <1390638+jwmueller@users.noreply.github.com> Date: Tue, 7 Feb 2023 13:26:35 -0800 Subject: [PATCH 109/258] upgrade torch in docs (#607) * upgrade versions of docs dependencies: torch, torchvision, speechbrain, etc --- docs/requirements.txt | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/docs/requirements.txt b/docs/requirements.txt index 1c944c18a7..070524aa36 100644 --- a/docs/requirements.txt +++ b/docs/requirements.txt @@ -8,19 +8,19 @@ ipython==8.0.1 ipykernel==6.8.0 ipywidgets==7.6.5 sphinx-multiversion==0.2.4 -torchvision==0.12.0 sphinx-copybutton==0.5.0 sphinxcontrib-katex==0.8.6 -matplotlib==3.5.1 -skorch==0.11.0 +sphinx-autodoc-typehints==1.19.2 +matplotlib==3.6.3 +requests==2.28.2 tensorflow-datasets==4.5.2 tensorflow==2.9.1 -speechbrain==0.5.12 tensorflow-io==0.26.0 -huggingface_hub==0.7 -torchaudio==0.11.0 +speechbrain==0.5.13 +huggingface_hub==0.11.1 fasttext==0.9.2 -timm==0.6.5 -torch==1.11.0 -requests==2.28.0 -sphinx-autodoc-typehints==1.19.2 +torch==1.13.1 +skorch==0.12.1 +torchvision==0.14.1 +torchaudio==0.13.1 +timm==0.6.12 From 5f6493f5098e03460c887ab28d073f9432750686 Mon Sep 17 00:00:00 2001 From: Jonas Mueller <1390638+jwmueller@users.noreply.github.com> Date: Thu, 9 Feb 2023 16:33:47 -0800 Subject: [PATCH 110/258] fix bug: confidences -> confidence (#623) --- cleanlab/filter.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/cleanlab/filter.py b/cleanlab/filter.py index bcc33e1037..5752c4fc7d 100644 --- a/cleanlab/filter.py +++ b/cleanlab/filter.py @@ -247,7 +247,7 @@ class 0, 1, ..., K-1. "confident_learning", "predicted_neq_given", "low_normalized_margin", - "low_self_confidences", + "low_self_confidence", ] and (frac_noise != 1.0 or num_to_remove_per_class is not None): warn_str = ( "frac_noise and num_to_remove_per_class parameters are only supported" @@ -262,7 +262,7 @@ class 0, 1, ..., K-1. "confident_learning", "predicted_neq_given", "low_normalized_margin", - "low_self_confidences", + "low_self_confidence", ] ): # TODO - add support for these filters @@ -597,7 +597,7 @@ class 0, 1, ..., K-1. They need not sum to 1.0 Refer to documentation for this argument in filter.find_label_issues() for details. filter_by : {'prune_by_class', 'prune_by_noise_rate', 'both', 'confident_learning', 'predicted_neq_given', - 'low_normalized_margin', 'low_self_confidences'}, default='prune_by_noise_rate' + 'low_normalized_margin', 'low_self_confidence'}, default='prune_by_noise_rate' Refer to documentation for this argument in filter.find_label_issues() for details. frac_noise : float, default=1.0 From d99788b9de1ec065b6a1c4ef87fb4314db79cadb Mon Sep 17 00:00:00 2001 From: Ulyana Date: Fri, 10 Feb 2023 08:28:29 -0800 Subject: [PATCH 111/258] Fixed duplicate issue removal in find_label_issues (#624) Co-authored-by: Jonas Mueller <1390638+jwmueller@users.noreply.github.com> --- cleanlab/filter.py | 12 ++++++------ tests/test_filter_count.py | 23 +++++++++++++++++++++++ 2 files changed, 29 insertions(+), 6 deletions(-) diff --git a/cleanlab/filter.py b/cleanlab/filter.py index 5752c4fc7d..2838fc441f 100644 --- a/cleanlab/filter.py +++ b/cleanlab/filter.py @@ -452,12 +452,12 @@ class 0, 1, ..., K-1. if filter_by == "predicted_neq_given": label_issues_mask = find_predicted_neq_given(labels, pred_probs, multi_label=multi_label) - # Remove label issues if given label == model prediction - # TODO: consider use of _multiclass_crossval_predict() here - pred = pred_probs.argmax(axis=1) - for i, pred_label in enumerate(pred): - if pred_label == labels[i]: - label_issues_mask[i] = False + if filter_by not in ["low_self_confidence", "low_normalized_margin"]: + # Remove label issues if given label == model prediction if issues haven't been removed yet + pred = pred_probs.argmax(axis=1) + for i, pred_label in enumerate(pred): + if pred_label == labels[i]: + label_issues_mask[i] = False if verbose: print("Number of label issues found: {}".format(sum(label_issues_mask))) diff --git a/tests/test_filter_count.py b/tests/test_filter_count.py index 4e0de2c08a..2da04a8482 100644 --- a/tests/test_filter_count.py +++ b/tests/test_filter_count.py @@ -750,6 +750,29 @@ def test_num_label_issues_different_estimation_types(): assert n3 != n2 +def test_find_label_issues_same_value(): + f1 = filter.find_label_issues( + labels=data["labels"], + pred_probs=data["pred_probs"], + filter_by="confident_learning", + ) + + f2 = filter.find_label_issues( + labels=data["labels"], + pred_probs=data["pred_probs"], + filter_by="low_self_confidence", + ) + + f3 = filter.find_label_issues( + labels=data["labels"], + pred_probs=data["pred_probs"], + filter_by="low_normalized_margin", + ) + + assert np.sum(f1) == np.sum(f2) + assert np.sum(f2) == np.sum(f3) + + @pytest.mark.filterwarnings() def test_num_label_issues(): cj_calibrated_off_diag_sum = data["cj"].sum() - data["cj"].trace() From 686cbf63f1c14799814de06c8be1f9974a4502d0 Mon Sep 17 00:00:00 2001 From: Jonas Mueller <1390638+jwmueller@users.noreply.github.com> Date: Fri, 10 Feb 2023 16:59:16 -0800 Subject: [PATCH 112/258] Method to estimate label issues with limited memory via mini-batches (#615) Co-authored-by: clu0 <33559427+clu0@users.noreply.github.com> --- cleanlab/experimental/README.md | 2 +- cleanlab/experimental/label_issues_batched.py | 542 ++++++++++++++++++ cleanlab/filter.py | 2 +- cleanlab/rank.py | 41 +- docs/source/tutorials/faq.ipynb | 179 +++++- tests/test_filter_count.py | 78 +++ 6 files changed, 821 insertions(+), 23 deletions(-) create mode 100644 cleanlab/experimental/label_issues_batched.py diff --git a/cleanlab/experimental/README.md b/cleanlab/experimental/README.md index d16e67c99b..91155f9801 100644 --- a/cleanlab/experimental/README.md +++ b/cleanlab/experimental/README.md @@ -2,7 +2,7 @@ Methods in this `experimental` module are bleeding edge and may have sharp edges. They are not guaranteed to be stable between different cleanlab versions. -Some of these files include various models that can be used with cleanlab to find issues in specific types of data. These require dependencies on deep learning and other machine learning packages that are not official cleanlab dependencies. You must install these dependencies on your own if you wish to use them. +Some of these files include various models that can be used with cleanlab to find issues in specific types of data. These require dependencies on deep learning and other machine learning packages that are not official cleanlab dependencies. You must install these dependencies on your own if you wish to use them. The dependencies are as follows: * mnist_pytorch.py - a cleanlab-compatible simplified AlexNet for MNIST using PyTorch diff --git a/cleanlab/experimental/label_issues_batched.py b/cleanlab/experimental/label_issues_batched.py new file mode 100644 index 0000000000..509e56b790 --- /dev/null +++ b/cleanlab/experimental/label_issues_batched.py @@ -0,0 +1,542 @@ +# Copyright (C) 2017-2023 Cleanlab Inc. +# This file is part of cleanlab. +# +# cleanlab is free software: you can redistribute it and/or modify +# it under the terms of the GNU Affero General Public License as published +# by the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# cleanlab is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU Affero General Public License for more details. +# +# You should have received a copy of the GNU Affero General Public License +# along with cleanlab. If not, see . + +""" +Implementation of :py:func:`filter.find_label_issues ` +that does not need much memory by operating in mini-batches. +You can also use this approach to estimate label quality scores or the number of label issues +for big datasets with limited memory. + +With default settings, the results returned from this approach closely approximate those returned from: +``cleanlab.filter.find_label_issues(..., filter_by="low_self_confidence", return_indices_ranked_by="self_confidence")`` + +To run this approach, either follow the examples script below, +or use the ``find_label_issues_batched()`` convenience function defined in this module. + +The recommended usage demonstrated in the examples script involves two passes over your data: +one pass to compute `confident_thresholds`, another to evaluate each label. +To maximize efficiency, try to use the largest batch_size your memory allows. +To reduce runtime further, you can run the first pass on a subset of your dataset +as long as it contains enough data from each class to estimate `confident_thresholds` accurately. + +In the examples script below: +- `labels` is a (big) 1D ``np.ndarray`` of class labels represented as integers in ``0,1,...,K-1``. +- ``pred_probs`` = is a (big) 2D ``np.ndarray`` of predicted class probabilities, +where each row is an example, each column represents a class. + +`labels` and `pred_probs` can be stored in a file instead where you load chunks of them at a time. +Methods to load arrays in chunks include: ``np.load(...,mmap_mode='r')``, ``numpy.memmap()``, +HDF5 or Zarr files, see: https://pythonspeed.com/articles/mmap-vs-zarr-hdf5/ + +Examples +-------- +>>> n = len(labels) +>>> batch_size = 10000 # you can change this in between batches, set as big as your RAM allows +>>> lab = LabelInspector(num_class = pred_probs.shape[1]) +>>> # First compute confident thresholds (for faster results, can also do this on a random subset of your data): +>>> i = 0 +>>> while i < n: +>>> end_index = i + batch_size +>>> labels_batch = labels[i:end_index] +>>> pred_probs_batch = pred_probs[i:end_index,:] +>>> i = end_index +>>> lab.update_confident_thresholds(labels_batch, pred_probs_batch) +>>> # See what we calculated: +>>> confident_thresholds = lab.get_confident_thresholds() +>>> # Evaluate the quality of the labels (run this on full dataset you want to evaluate): +>>> i = 0 +>>> while i < n: +>>> end_index = i + batch_size +>>> labels_batch = labels[i:end_index] +>>> pred_probs_batch = pred_probs[i:end_index,:] +>>> i = end_index +>>> batch_results = lab.score_label_quality(labels_batch, pred_probs_batch) +>>> # Indices of examples with label issues, sorted by label quality score (most severe to least severe): +>>> indices_of_examples_with_issues = lab.get_label_issues() +>>> # If your `pred_probs` and `labels` are arrays already in memory, +>>> # then you can use this shortcut for all of the above: +>>> indices_of_examples_with_issues = find_label_issues_batched(labels, pred_probs, batch_size=10000) +""" + +import numpy as np +from typing import Optional, List + +from cleanlab.count import get_confident_thresholds +from cleanlab.rank import find_top_issues, _compute_label_quality_scores +from cleanlab.typing import LabelLike +from cleanlab.internal.util import value_counts_fill_missing_classes + + +EPS = 1e-6 # small number + + +class LabelInspector: + """ + Class for finding label issues in big datasets where memory becomes a problem for other cleanlab methods. + Only create one such object per dataset and do not try to use the same ``LabelInspector`` across 2 datasets. + For efficiency, this class does little input checking. + You can first run :py:func:`filter.find_label_issues ` + on a small subset of your data to verify your inputs are properly formatted. + Do NOT modify any of the attributes of this class yourself! + Multi-label classification is not supported by this class, it is only for multi-class classification. + + Parameters + ---------- + num_class : int + The number of classes in your multi-class classification task. + + store_results : bool, optional + Whether this object will store all label quality scores, a 1D array of shape ``(N,)`` + where ``N`` is the total number of examples in your dataset. + Set this to False if you encounter memory problems even for small batch sizes (~1000). + If ``False``, you can still identify the label issues yourself by aggregating + the label quality scores for each batch, sorting them across all batches, and returning the top ``T`` indices + with ``T = self.get_num_issues()``. + + verbose : bool, optional + Whether to suppress print statements or not. + + quality_score_kwargs : dict, optional + Keyword arguments to pass into :py:func:`rank.get_label_quality_scores `. + + num_issue_kwargs : dict, optional + Keyword arguments to :py:func:`count.num_label_issues()` ` + to control estimation of the number of label issues. + The only supported kwarg here for now is: `estimation_method`. + """ + + def __init__( + self, + *, + num_class: int, + store_results: bool = True, + verbose: bool = True, + quality_score_kwargs: Optional[dict] = None, + num_issue_kwargs: Optional[dict] = None, + ): + if quality_score_kwargs is None: + quality_score_kwargs = {} + if num_issue_kwargs is None: + num_issue_kwargs = {} + + self.num_class = num_class + self.store_results = store_results + self.verbose = verbose + self.quality_score_kwargs = quality_score_kwargs # extra arguments for ``rank.get_label_quality_scores()`` to control label quality scoring + self.num_issue_kwargs = num_issue_kwargs # extra arguments for ``count.num_label_issues()`` to control estimation of the number of label issues (only supported argument for now is: `estimation_method`). + self.off_diagonal_calibrated = False + if num_issue_kwargs.get("estimation_method") == "off_diagonal_calibrated": + # store extra attributes later needed for calibration: + self.off_diagonal_calibrated = True + self.prune_counts = np.zeros(self.num_class) + self.class_counts = np.zeros(self.num_class) + self.normalization = np.zeros(self.num_class) + else: + self.prune_count = 0 # number of label issues estimated based on data seen so far (only used when estimation_method is not calibrated) + + if self.store_results: + self.label_quality_scores: List[float] = [] + + self.confident_thresholds = np.zeros( + (num_class,) + ) # current estimate of thresholds based on data seen so far + self.examples_per_class = np.zeros( + (num_class,) + ) # current counts of examples with each given label seen so far + self.examples_processed_thresh = ( + 0 # number of examples seen so far for estimating thresholds + ) + self.examples_processed_quality = 0 # number of examples seen so far for estimating label quality and number of label issues + + def get_confident_thresholds(self, silent: bool = False) -> np.ndarray: + """ + Fetches already-computed confident thresholds from the data seen so far + in same format as: :py:func:`count.get_confident_thresholds `. + + + Returns + ------- + confident_thresholds : np.ndarray + An array of shape ``(K, )`` where ``K`` is the number of classes. + """ + if self.examples_processed_thresh < 1: + raise ValueError( + "Have not computed any confident_thresholds yet. Call `update_confident_thresholds()` first." + ) + else: + if self.verbose and not silent: + print( + f"Total number of examples used to estimate confident thresholds: {self.examples_processed_thresh}" + ) + return self.confident_thresholds + + def get_num_issues(self, silent: bool = False) -> int: + """ + Fetches already-computed estimate of the number of label issues in the data seen so far + in the same format as: :py:func:`count.num_label_issues `. + + Note: The estimated number of issues may differ from :py:func:`count.num_label_issues ` + by 1 due to rounding differences. + + Returns + ------- + num_issues : + The estimated number of examples with label issues in the data seen so far. + """ + if self.examples_processed_quality < 1: + raise ValueError( + "Have not evaluated any labels yet. Call `score_label_quality()` first." + ) + else: + if self.verbose and not silent: + print( + f"Total number of examples whose labels have been evaluated: {self.examples_processed_quality}" + ) + if self.off_diagonal_calibrated: + calibrated_prune_counts = ( + self.prune_counts + * self.class_counts + / np.clip(self.normalization, a_min=EPS, a_max=None) + ) # avoid division by 0 + return np.rint(np.sum(calibrated_prune_counts)).astype("int") + else: # not calibrated + return self.prune_count + + def get_quality_scores(self) -> np.ndarray: + """ + Fetches already-computed estimate of the label quality of each example seen so far + in the same format as: :py:func:`rank.get_label_quality_scores `. + + Returns + ------- + label_quality_scores : np.ndarray + Contains one score (between 0 and 1) per example seen so far. + Lower scores indicate more likely mislabeled examples. + """ + if not self.store_results: + raise ValueError( + "Must initialize the LabelInspector with `store_results` == True. " + "Otherwise you can assemble the label quality scores yourself based on " + "the scores returned for each batch of data from `score_label_quality()`" + ) + else: + return np.asarray(self.label_quality_scores) + + def get_label_issues(self) -> np.ndarray: + """ + Fetches already-computed estimate of indices of examples with label issues in the data seen so far, + in the same format as: :py:func:`filter.find_label_issues ` + with its `return_indices_ranked_by` argument specified. + + Note: this method corresponds to ``filter.find_label_issues(..., filter_by=METHOD1, return_indices_ranked_by=METHOD2) + where by default: ``METHOD1="low_self_confidence"``, ``METHOD2="self_confidence"`` + or if this object was instantiated with ``quality_score_kwargs = {"method": "normalized_margin"}`` then we instead have: + ``METHOD1="low_normalized_margin"``, ``METHOD2="normalized_margin"``. + + Note: The estimated number of issues may differ from :py:func:`filter.find_label_issues ` + by 1 due to rounding differences. + + Returns + ------- + issue_indices : np.ndarray + Indices of examples with label issues, sorted by label quality score. + """ + if not self.store_results: + raise ValueError( + "Must initialize the LabelInspector with `store_results` == True. " + "Otherwise you can identify label issues yourself based on the scores from all " + "the batches of data and the total number of issues returned by `get_num_issues()`" + ) + if self.examples_processed_quality < 1: + raise ValueError( + "Have not evaluated any labels yet. Call `score_label_quality()` first." + ) + if self.verbose: + print( + f"Total number of examples whose labels have been evaluated: {self.examples_processed_quality}" + ) + return find_top_issues(self.get_quality_scores(), top=self.get_num_issues(silent=True)) + + def update_confident_thresholds(self, labels: LabelLike, pred_probs: np.ndarray): + """ + Updates the estimate of confident_thresholds stored in this class using a new batch of data. + Inputs should be in same format as for: :py:func:`count.get_confident_thresholds `. + + Parameters + ---------- + labels: np.ndarray or list + Given class labels for each example in the batch, values in ``0,1,2,...,K-1``. + + pred_probs: np.ndarray + 2D array of model-predicted class probabilities for each example in the batch. + """ + labels = _batch_check(labels, pred_probs, self.num_class) + batch_size = len(labels) + batch_thresholds = get_confident_thresholds( + labels, pred_probs + ) # values for missing classes may exceed 1 but should not matter since we multiply by this class counts in the batch + batch_class_counts = value_counts_fill_missing_classes(labels, num_classes=self.num_class) + self.confident_thresholds = ( + self.examples_per_class * self.confident_thresholds + + batch_class_counts * batch_thresholds + ) / np.clip( + self.examples_per_class + batch_class_counts, a_min=1, a_max=None + ) # avoid division by 0 + self.examples_per_class += batch_class_counts + self.examples_processed_thresh += batch_size + + def score_label_quality( + self, labels: LabelLike, pred_probs: np.ndarray, *, update_num_issues: bool = True + ) -> np.ndarray: + """ + Scores the label quality of each example in the provided batch of data, + and also updates the number of label issues stored in this class. + Inputs should be in same format as for: :py:func:`rank.get_label_quality_scores `.. + + Parameters + ---------- + labels: np.ndarray or list + Given class labels for each example in the batch, values in ``0,1,2,...,K-1``. + + pred_probs: np.ndarray + 2D array of model-predicted class probabilities for each example in the batch of data. + + update_num_issues: bool, optional + Whether or not to update the number of label issues or only compute label quality scores. + For lower runtimes, set this to ``False`` if you only want to score label quality and not find label issues. + + Returns + ------- + label_quality_scores : np.ndarray + Contains one score (between 0 and 1) for each example in the batch of data. + """ + labels = _batch_check(labels, pred_probs, self.num_class) + batch_size = len(labels) + scores = _compute_label_quality_scores( + labels, + pred_probs, + confident_thresholds=self.get_confident_thresholds(silent=True), + **self.quality_score_kwargs, + ) + class_counts = value_counts_fill_missing_classes(labels, num_classes=self.num_class) + if update_num_issues: + self._update_num_label_issues(labels, pred_probs, **self.num_issue_kwargs) + self.examples_processed_quality += batch_size + if self.store_results: + self.label_quality_scores += list(scores) + + return scores + + def _update_num_label_issues(self, labels: LabelLike, pred_probs: np.ndarray, **kwargs): + """ + Update the estimate of num_label_issues stored in this class using a new batch of data. + Kwargs are ignored here for now (included for forwards compatibility). + Instead of being specified here, `estimation_method` should be declared when this class is initialized. + """ + if self.examples_processed_thresh < 1: + raise ValueError( + "Have not computed any confident_thresholds yet. Call `update_confident_thresholds()` first." + ) + batch_size = len(labels) + pred_class = np.argmax(pred_probs, axis=1) + # for efficiency, this pred_class index is also used where older implementation instead used: + # max_ind = np.argmax(pred_probs * (pred_probs >= adj_confident_thresholds), axis=1) + pred_confidence = pred_probs[np.arange(batch_size), pred_class] + # add margin for floating point comparison operations: + adj_confident_thresholds = self.confident_thresholds - EPS + if not self.off_diagonal_calibrated: + prune_count_batch = np.sum( + ( + pred_probs[np.arange(batch_size), pred_class] + >= adj_confident_thresholds[pred_class] + ) + & (pred_class != labels) + ) + self.prune_count += prune_count_batch + else: # calibrated + self.class_counts += value_counts_fill_missing_classes( + labels, num_classes=self.num_class + ) + to_increment = ( + pred_probs[np.arange(batch_size), pred_class] + >= adj_confident_thresholds[pred_class] + ) + for class_label in range(self.num_class): + labels_equal_to_class = labels == class_label + self.normalization[class_label] += np.sum(labels_equal_to_class & to_increment) + self.prune_counts[class_label] += np.sum( + labels_equal_to_class & to_increment & (pred_class != labels) + ) + + +def _batch_check(labels: LabelLike, pred_probs: np.ndarray, num_class: int) -> np.ndarray: + """ + Basic checks to ensure batch of data looks ok. For efficiency, this check is quite minimal. + + Returns + ------- + labels : np.ndarray + `labels` formatted as a 1D array. + """ + batch_size = pred_probs.shape[0] + labels = np.asarray(labels) + if batch_size < 10: + raise ValueError("Please run this with batches containing at least 10 examples.") + if len(labels) != batch_size: + raise ValueError("labels and pred_probs must have same length") + if pred_probs.shape[1] != num_class: + raise ValueError("num_class must equal pred_probs.shape[1]") + + return labels + + +def find_label_issues_batched( + *, + labels_file: Optional[str] = None, + pred_probs_file: Optional[str] = None, + labels: Optional[LabelLike] = None, + pred_probs: Optional[np.ndarray] = None, + batch_size: int = 10000, + verbose: bool = True, + quality_score_kwargs: Optional[dict] = None, + num_issue_kwargs: Optional[dict] = None, +) -> np.ndarray: + """ + Variant of :py:func:`filter.find_label_issues ` + that requires less memory by reading `pred_probs`, `labels` in mini-batches, if provided as files. + Only .npy files are supported (not .npz), and these must be loadable via: ``np.load(your_file, mmap_mode="r")``. + If you want to read from other file-types (eg. HDF5 or Zarr) instead, + see the example usage of the ``LabelInspector`` class. + + This function basically implements the example ``LabelInspector`` usage script, + but you can further customize that script by running it yourself. + See the documentation of ``LabelInspector`` to learn more about how this method works internally. + + With default settings, the results returned from this method closely approximate those returned from: + ``cleanlab.filter.find_label_issues(..., filter_by="low_self_confidence", return_indices_ranked_by="self_confidence")`` + + Parameters + ---------- + labels_file: str, optional + Path to .npy file where the entire 1D `labels` numpy array is stored on disk (list format is not supported). + This is loaded using: ``np.load(labels_file, mmap_mode="r")`` + so make sure this file was created via: ``np.save()`` or other compatible methods. + + pred_probs_file: str, optional + Path to .npy file where the entire `pred_probs` numpy array is stored on disk. + This is loaded using: ``np.load(pred_probs_file, mmap_mode="r")`` + so make sure this file was created via: ``np.save()`` or other compatible methods. + + labels: np.ndarray or list, optional + Given class labels for each example in the dataset, (int) values in ``0,1,2,...,K-1``. + Recommend providing `labels_file` instead of `labels` to avoid loading big objects into memory. + + pred_probs: np.ndarray, optional + 2D array of model-predicted class probabilities (floats) for each example in the dataset. + Recommend providing `pred_probs_file` instead of `pred_probs` to avoid loading big objects into memory. + + batch_size : int, optional + Size of mini-batches to use for estimating the label issues. + To maximize efficiency, try to use the largest `batch_size` your memory allows. + + verbose : bool, optional + Whether to suppress print statements or not. + + quality_score_kwargs : dict, optional + Keyword arguments to pass into :py:func:`rank.get_label_quality_scores `. + + num_issue_kwargs : dict, optional + Keyword arguments to :py:func:`count.num_label_issues()` ` + to control estimation of the number of label issues. + The only supported kwarg here for now is: `estimation_method`. + + Returns + ------- + issue_indices : np.ndarray + Indices of examples with label issues, sorted by label quality score. + """ + if labels_file is not None: + if labels is not None: + raise ValueError("only specify one of: `labels` or `labels_file`") + if not isinstance(labels_file, str): + raise ValueError( + "labels_file must be str specifying path to .npy file containing the array of labels" + ) + labels = np.load(labels_file, mmap_mode="r") + assert isinstance(labels, np.ndarray) + + if pred_probs_file is not None: + if pred_probs is not None: + raise ValueError("only specify one of: `pred_probs` or `pred_probs_file`") + if not isinstance(pred_probs_file, str): + raise ValueError( + "pred_probs_file must be str specifying path to .npy file containing 2D array of pred_probs" + ) + pred_probs = np.load(pred_probs_file, mmap_mode="r") + assert isinstance(pred_probs, np.ndarray) + if verbose: + print( + f"mmap-loaded numpy arrays have: {len(pred_probs)} examples, {pred_probs.shape[1]} classes" + ) + if labels is None: + raise ValueError("must provide one of: `labels` or `labels_file`") + if pred_probs is None: + raise ValueError("must provide one of: `pred_probs` or `pred_probs_file`") + + assert isinstance(pred_probs, np.ndarray) + if len(labels) != len(pred_probs): + raise ValueError( + f"len(labels)={len(labels)} does not match len(pred_probs)={len(pred_probs)}. Perhaps an issue loading mmap numpy arrays from file." + ) + lab = LabelInspector( + num_class=pred_probs.shape[1], + verbose=verbose, + quality_score_kwargs=quality_score_kwargs, + num_issue_kwargs=num_issue_kwargs, + ) + n = len(labels) + if verbose: + from tqdm.auto import tqdm + + pbar = tqdm(desc="number of examples processed for estimating thresholds", total=n) + i = 0 + while i < n: + end_index = i + batch_size + labels_batch = labels[i:end_index] + pred_probs_batch = pred_probs[i:end_index, :] + i = end_index + lab.update_confident_thresholds(labels_batch, pred_probs_batch) + if verbose: + pbar.update(batch_size) + + # Next evaluate the quality of the labels (run this on full dataset you want to evaluate): + if verbose: + pbar.close() + pbar = tqdm(desc="number of examples processed for checking labels", total=n) + i = 0 + while i < n: + end_index = i + batch_size + labels_batch = labels[i:end_index] + pred_probs_batch = pred_probs[i:end_index, :] + i = end_index + batch_results = lab.score_label_quality(labels_batch, pred_probs_batch) + if verbose: + pbar.update(batch_size) + + if verbose: + pbar.close() + + return lab.get_label_issues() diff --git a/cleanlab/filter.py b/cleanlab/filter.py index 2838fc441f..e6f2cc803d 100644 --- a/cleanlab/filter.py +++ b/cleanlab/filter.py @@ -270,7 +270,7 @@ class 0, 1, ..., K-1. "filter_by 'confident_learning', 'predicted_neq_given', 'low_normalized_margin' " "or 'low_self_confidence' is not supported (yet) when setting 'num_to_remove_per_class'" ) - if filter_by is "confident_learning" and isinstance(confident_joint, np.ndarray): + if filter_by == "confident_learning" and isinstance(confident_joint, np.ndarray): warn_str = ( "The supplied `confident_joint` is ignored when `filter_by = 'confident_learning'`; confident joint will be " "re-estimated from the given labels. To use your supplied `confident_joint`, please specify a different " diff --git a/cleanlab/rank.py b/cleanlab/rank.py index b00deafff3..5be235f6bf 100644 --- a/cleanlab/rank.py +++ b/cleanlab/rank.py @@ -119,15 +119,28 @@ class 0, 1, ..., K-1. assert_valid_inputs( X=None, y=labels, pred_probs=pred_probs, multi_label=False, allow_one_class=True ) + return _compute_label_quality_scores( + labels=labels, pred_probs=pred_probs, method=method, adjust_pred_probs=adjust_pred_probs + ) + - # Available scoring functions to choose from +def _compute_label_quality_scores( + labels: np.ndarray, + pred_probs: np.ndarray, + *, + method: str = "self_confidence", + adjust_pred_probs: bool = False, + confident_thresholds: Optional[np.ndarray] = None, +) -> np.ndarray: + """Internal implementation of get_label_quality_scores that assumes inputs + have already been checked and are valid. This speeds things up. + Can also take in pre-computed confident_thresholds to further accelerate things. + """ scoring_funcs = { "self_confidence": get_self_confidence_for_each_label, "normalized_margin": get_normalized_margin_for_each_label, "confidence_weighted_entropy": get_confidence_weighted_entropy_for_each_label, } - - # Select scoring function try: scoring_func = scoring_funcs[method] except KeyError: @@ -137,21 +150,15 @@ class 0, 1, ..., K-1. Please choose a valid rank_by: self_confidence, normalized_margin, confidence_weighted_entropy """ ) - - # Adjust predicted probabilities if adjust_pred_probs: - # Check if adjust_pred_probs is supported for the chosen method if method == "confidence_weighted_entropy": raise ValueError(f"adjust_pred_probs is not currently supported for {method}.") + pred_probs = _subtract_confident_thresholds( + labels=labels, pred_probs=pred_probs, confident_thresholds=confident_thresholds + ) - pred_probs = _subtract_confident_thresholds(labels, pred_probs) - - # Pass keyword arguments for scoring function - input = {"labels": labels, "pred_probs": pred_probs} - - # Calculate scores - label_quality_scores = scoring_func(**input) - + scoring_inputs = {"labels": labels, "pred_probs": pred_probs} + label_quality_scores = scoring_func(**scoring_inputs) return label_quality_scores @@ -494,9 +501,9 @@ def get_self_confidence_for_each_label( Lower scores indicate more likely mislabeled examples. """ - # np.mean is used so that this works for multi-labels (list of lists) - label_quality_scores = np.array([np.mean(pred_probs[i, l]) for i, l in enumerate(labels)]) - return label_quality_scores + # To make this work for multi-label (but it will slow down runtime), replace: + # pred_probs[i, l] -> np.mean(pred_probs[i, l]) + return np.array([pred_probs[i, l] for i, l in enumerate(labels)]) def get_normalized_margin_for_each_label( diff --git a/docs/source/tutorials/faq.ipynb b/docs/source/tutorials/faq.ipynb index 989f9b3711..6f9972505a 100644 --- a/docs/source/tutorials/faq.ipynb +++ b/docs/source/tutorials/faq.ipynb @@ -19,7 +19,7 @@ }, "outputs": [], "source": [ - "# This cell is for internal CI purposes. Run it to ensure all other cells below can be executed in your own notebook\n", + "# This cell is hidden on docs.cleanlab.ai. Execute it to ensure all other cells below can be executed in your own notebook\n", "\n", "import os \n", "import logging \n", @@ -38,7 +38,10 @@ "pred_probs[np.arange(N),labels] += 4 # make pred_probs accurate\n", "pred_probs = pred_probs/pred_probs.sum(axis=1)[:, np.newaxis]\n", "data = np.array([[label+np.random.uniform(), label+np.random.uniform()] for label in labels])\n", - "labels[-num_errors:] = 0 # introduce label errors\n", + "# introduce label errors in last few examples:\n", + "og0_indices = labels[-num_errors:] == 0\n", + "labels[-num_errors:] = 0\n", + "labels[-num_errors:][og0_indices] = 1\n", "\n", "your_classifier=sklearn.linear_model.LogisticRegression() # toy classifier" ] @@ -205,6 +208,174 @@ "You will be able to produce a much better version of your dataset interactively using [Cleanlab Studio](https://cleanlab.ai/studio/?utm_source=github&utm_medium=docs&utm_campaign=clostostudio), which helps you efficiently fix issues like this in large datasets." ] }, + { + "cell_type": "markdown", + "id": "21f42f24", + "metadata": {}, + "source": [ + "### How can I find label issues in big datasets with limited memory? " + ] + }, + { + "cell_type": "markdown", + "id": "089f505e", + "metadata": {}, + "source": [ + "For a dataset with many rows and/or classes, there are more efficient methods in the `label_issues_batched` module. These methods read data in mini-batches and you can reduce the `batch_size` to control how much memory they require. Below is an example of how to use the `find_label_issues_batched()` method from this module, which can load mini-batches of data from `labels`, `pred_probs` saved as .npy files on disk. Check out the `LabelInspector` class from this module if you instead have `labels`, `pred_probs` saved as other file-types (eg. HDF5 or Zarr)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "41714b51", + "metadata": {}, + "outputs": [], + "source": [ + "# We'll assume your big arrays of labels, pred_probs have been saved to file like this:\n", + "from tempfile import mkdtemp\n", + "import os.path as path\n", + "\n", + "labels_file = path.join(mkdtemp(), \"labels.npy\")\n", + "pred_probs_file = path.join(mkdtemp(), \"pred_probs.npy\")\n", + "np.save(labels_file, labels)\n", + "np.save(pred_probs_file, pred_probs)\n", + "\n", + "# Code to find label issues by loading data from file in batches:\n", + "from cleanlab.experimental.label_issues_batched import find_label_issues_batched\n", + "\n", + "batch_size = 10000 # for efficiency, set this to as large of a value as your memory can handle\n", + "\n", + "# Indices of examples with label issues, sorted by label quality score (most severe to least severe):\n", + "indices_of_examples_with_issues = find_label_issues_batched(\n", + " labels_file=labels_file, pred_probs_file=pred_probs_file, batch_size=batch_size\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "20476c70", + "metadata": { + "nbsphinx": "hidden" + }, + "outputs": [], + "source": [ + "# This cell is hidden on docs.cleanlab.ai, and is only for internal testing. You can ignore it.\n", + "\n", + "issue_indices = cleanlab.filter.find_label_issues(labels, pred_probs, filter_by = \"confident_learning\", return_indices_ranked_by=\"self_confidence\")\n", + "assert np.abs(len(issue_indices) - len(indices_of_examples_with_issues)) < 2, \"num issues differ in batched mode\"\n", + "set1 = set(issue_indices)\n", + "set2 = set(indices_of_examples_with_issues)\n", + "intersection = len(list(set1.intersection(set2)))\n", + "union = len(set1) + len(set2) - intersection\n", + "assert float(intersection) / union > 0.9, \"issue indices differ in batched mode\"" + ] + }, + { + "cell_type": "markdown", + "id": "438b424d", + "metadata": {}, + "source": [ + "**To use less memory and get results faster if your dataset has many classes:** Try merging the rare classes into a single \"Other\" class before you find label issues. The resulting issues won't be affected much since cleanlab anyway does not have enough data to accurately diagnose label errors in classes that are rarely seen. To do this, you should aggregate all the probability assigned to the rare classes in `pred_probs` into a single new dimension of `pred_probs_merged` (where this new array no longer has columns for the rare classes). Here is a function that does this for you, which you can also modify as needed:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6983cdad", + "metadata": { + "nbsphinx": "hidden" + }, + "outputs": [], + "source": [ + "# This cell is hidden on docs.cleanlab.ai\n", + "# Add two rare additional classes to the dataset:\n", + "\n", + "num_rare_instances = 3\n", + "small_prob = 1e-4\n", + "pred_probs = np.hstack((pred_probs, np.ones((len(pred_probs),2))*small_prob))\n", + "pred_probs = pred_probs / np.sum(pred_probs, axis=1)[:, np.newaxis]\n", + "labels[:num_rare_instances] = 3\n", + "labels[num_rare_instances:(2*num_rare_instances)] = 4" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9092b8a0", + "metadata": {}, + "outputs": [], + "source": [ + "from cleanlab.internal.util import value_counts # use this to count how often each class occurs in labels\n", + "\n", + "def merge_rare_classes(labels, pred_probs, count_threshold = 10):\n", + " \"\"\" \n", + " Returns: labels, pred_probs after we merge all rare classes into a single 'Other' class.\n", + " Merged pred_probs has less columns. Rare classes are any occuring less than `count_threshold` times.\n", + " Also returns: `class_mapping_orig2new`, a dict to map new classes in merged labels back to classes \n", + " in original labels, useful for interpreting outputs from `dataset.heath_summary()` or `count.confident_joint()`.\n", + " \"\"\"\n", + " num_classes = pred_probs.shape[1]\n", + " num_examples_per_class = value_counts(labels, num_classes=num_classes)\n", + " rare_classes = [c for c in range(num_classes) if num_examples_per_class[c] < count_threshold]\n", + " if len(rare_classes) < 1:\n", + " raise ValueError(\"No rare classes found at the given `count_threshold`, merging is unnecessary unless you increase it.\")\n", + "\n", + " num_classes_merged = num_classes - len(rare_classes) + 1 # one extra class for all the merged ones\n", + " other_class = num_classes_merged - 1\n", + " labels_merged = labels.copy()\n", + " class_mapping_orig2new = {} # key = original class in `labels`, value = new class in `labels_merged`\n", + " new_c = 0\n", + " for c in range(num_classes):\n", + " if c in rare_classes:\n", + " class_mapping_orig2new[c] = other_class\n", + " else:\n", + " class_mapping_orig2new[c] = new_c\n", + " new_c += 1\n", + " labels_merged[labels == c] = class_mapping_orig2new[c]\n", + "\n", + " merged_prob = np.sum(pred_probs[:, rare_classes], axis=1, keepdims=True) # total probability over all merged classes for each example\n", + " pred_probs_merged = np.hstack((np.delete(pred_probs, rare_classes, axis=1), merged_prob)) # assumes new_class is as close to original_class in sorted order as is possible after removing the merged original classes\n", + " # check a few rows of probabilities after merging to verify they still sum to 1:\n", + " num_check = 1000 # only check a few rows for efficiency\n", + " ones_array_ref = np.ones(min(num_check,len(pred_probs)))\n", + " if np.isclose(np.sum(pred_probs[:num_check], axis=1), ones_array_ref).all() and (not np.isclose(np.sum(pred_probs_merged[:num_check], axis=1), ones_array_ref).all()):\n", + " raise ValueError(\"merged pred_probs do not sum to 1 in each row, check that merging was correctly done.\")\n", + " \n", + " return (labels_merged, pred_probs_merged, class_mapping_orig2new)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b0a01109", + "metadata": {}, + "outputs": [], + "source": [ + "from cleanlab.filter import find_label_issues # can alternatively use find_label_issues_batched() shown above\n", + "\n", + "labels_merged, pred_probs_merged, class_mapping_orig2new = merge_rare_classes(labels, pred_probs, count_threshold=5)\n", + "examples_w_issues = find_label_issues(labels_merged, pred_probs_merged, return_indices_ranked_by=\"self_confidence\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8b1da032", + "metadata": { + "nbsphinx": "hidden" + }, + "outputs": [], + "source": [ + "# This cell is hidden on docs.cleanlab.ai, and is only for internal testing. You can ignore it.\n", + "\n", + "rare_classes = [c for c in class_mapping_orig2new.keys() if class_mapping_orig2new[c] == pred_probs_merged.shape[1]-1]\n", + "og_examples_w_issues = find_label_issues(labels, pred_probs, return_indices_ranked_by=\"self_confidence\")\n", + "examples_of_interest = [x for x in examples_w_issues if labels[x] not in rare_classes]\n", + "og_examples_of_interest = [x for x in og_examples_w_issues if labels[x] not in rare_classes]\n", + "assert set(examples_of_interest) == set(og_examples_of_interest), \"merged label issues differ from non-merged label issues\"" + ] + }, { "cell_type": "markdown", "id": "3868ee8b", @@ -224,7 +395,7 @@ "You can still use cleanlab with other data formats though! Just separately obtain predicted probabilities (`pred_probs`) from your model via cross-validation and pass them as inputs. \n", "\n", "\n", - "If CleanLearning is running successfully but not improving predictive accuracy of your model, here are some tips:\n", + "If CleanLearning is running successfully but not improving predictive accuracy of your model, here are some tips:\n", "\n", "1. Use cleanlab to find label issues in your test data as well (we recommend pooling `labels` across both training and test data into one input for `find_label_issues()`). Then manually review and fix label issues identified in the test data to verify accuracy measurements are actually meaningful.\n", "\n", @@ -426,7 +597,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.13" + "version": "3.9.15" } }, "nbformat": 4, diff --git a/tests/test_filter_count.py b/tests/test_filter_count.py index 2da04a8482..8cc624f6a3 100644 --- a/tests/test_filter_count.py +++ b/tests/test_filter_count.py @@ -24,12 +24,15 @@ from cleanlab.benchmarking.noise_generation import generate_noisy_labels from cleanlab.internal.util import value_counts from cleanlab.internal.multilabel_utils import int2onehot +from cleanlab.experimental.label_issues_batched import find_label_issues_batched import numpy as np import scipy import pytest from sklearn.multioutput import MultiOutputClassifier from sklearn.linear_model import LogisticRegression from sklearn.model_selection import cross_val_predict +from tempfile import mkdtemp +import os.path as path def make_data( @@ -894,6 +897,81 @@ def test_num_label_issues_multilabel(confident_joint): assert sum(f) == n +def test_batched_label_issues(): + f1 = filter.find_label_issues( + labels=data["labels"], + pred_probs=data["pred_probs"], + return_indices_ranked_by="self_confidence", + filter_by="confident_learning", + # TODO: replace the above line with: + # filter_by="low_self_confidence", + ) + f2 = find_label_issues_batched( + labels=data["labels"], + pred_probs=data["pred_probs"], + batch_size=int(len(data["labels"]) / 4.0), + ) + f3 = find_label_issues_batched( + labels=data["labels"], + pred_probs=data["pred_probs"], + batch_size=int(len(data["labels"]) / 2.0), + ) + f4 = find_label_issues_batched( + labels=data["labels"], pred_probs=data["pred_probs"], batch_size=len(data["labels"]) + 100 + ) + assert np.all(f4 == f3) + assert np.all(f4 == f2) + assert len(f2) == len(f1) + # check jaccard similarity: + intersection = len(list(set(f1).intersection(set(f2)))) + union = len(set(f1)) + len(set(f2)) - intersection + assert float(intersection) / union > 0.6 + n1 = count.num_label_issues( + labels=data["labels"], + pred_probs=data["pred_probs"], + estimation_method="off_diagonal_calibrated", + ) + quality_score_kwargs = {"method": "normalized_margin"} + num_issue_kwargs = {"estimation_method": "off_diagonal_calibrated"} + extra_args = { + "quality_score_kwargs": quality_score_kwargs, + "num_issue_kwargs": num_issue_kwargs, + } + f5 = find_label_issues_batched( + labels=data["labels"], + pred_probs=data["pred_probs"], + batch_size=int(len(data["labels"]) / 4.0), + **extra_args, + ) + f6 = find_label_issues_batched( + labels=data["labels"], + pred_probs=data["pred_probs"], + batch_size=int(len(data["labels"]) / 2.0), + **extra_args, + ) + f7 = find_label_issues_batched( + labels=data["labels"], + pred_probs=data["pred_probs"], + batch_size=len(data["labels"]) + 100, + **extra_args, + ) + assert not np.array_equal(f5, f2) + assert np.all(f7 == f5) + assert np.all(f6 == f5) + assert np.abs(len(f5) - n1) < 2 + # Test batches loaded from file: + labels_file = path.join(mkdtemp(), "labels.npy") + pred_probs_file = path.join(mkdtemp(), "pred_probs.npy") + np.save(labels_file, data["labels"]) + np.save(pred_probs_file, data["pred_probs"]) + f8 = find_label_issues_batched( + labels_file=labels_file, + pred_probs_file=pred_probs_file, + batch_size=int(len(data["labels"]) / 4.0), + ) + assert np.all(f8 == f3) + + def test_issue_158(): # ref: https://github.com/cleanlab/cleanlab/issues/158 pred_probs = np.array( From 5319a124d4f759b80acbc9eaa4cd7ac5b3cfd4ac Mon Sep 17 00:00:00 2001 From: Jonas Mueller <1390638+jwmueller@users.noreply.github.com> Date: Fri, 10 Feb 2023 17:30:03 -0800 Subject: [PATCH 113/258] Make label_issues_batched documentation appear (#627) --- docs/source/cleanlab/experimental/index.rst | 1 + .../source/cleanlab/experimental/label_issues_batched.rst | 8 ++++++++ 2 files changed, 9 insertions(+) create mode 100644 docs/source/cleanlab/experimental/label_issues_batched.rst diff --git a/docs/source/cleanlab/experimental/index.rst b/docs/source/cleanlab/experimental/index.rst index 935152c86c..35af09b504 100644 --- a/docs/source/cleanlab/experimental/index.rst +++ b/docs/source/cleanlab/experimental/index.rst @@ -11,6 +11,7 @@ experimental :show-inheritance: .. toctree:: + label_issues_batched mnist_pytorch coteaching cifar_cnn diff --git a/docs/source/cleanlab/experimental/label_issues_batched.rst b/docs/source/cleanlab/experimental/label_issues_batched.rst new file mode 100644 index 0000000000..1262958fed --- /dev/null +++ b/docs/source/cleanlab/experimental/label_issues_batched.rst @@ -0,0 +1,8 @@ +label_issues_batched +==================== + +.. automodule:: cleanlab.experimental.label_issues_batched + :autosummary: + :members: + :undoc-members: + :show-inheritance: From ac98282dcb0f375d1f7b90527dbde3f117648f28 Mon Sep 17 00:00:00 2001 From: Jonas Mueller <1390638+jwmueller@users.noreply.github.com> Date: Fri, 10 Feb 2023 18:29:00 -0800 Subject: [PATCH 114/258] add example script for find_label_issues_batched (#629) --- cleanlab/experimental/label_issues_batched.py | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/cleanlab/experimental/label_issues_batched.py b/cleanlab/experimental/label_issues_batched.py index 509e56b790..ebd164a867 100644 --- a/cleanlab/experimental/label_issues_batched.py +++ b/cleanlab/experimental/label_issues_batched.py @@ -467,6 +467,11 @@ def find_label_issues_batched( ------- issue_indices : np.ndarray Indices of examples with label issues, sorted by label quality score. + + Examples + -------- + >>> batch_size = 10000 # for efficiency, set this to as large of a value as your memory can handle + >>> issues = find_label_issues_batched(labels_file="LABELS.npy", pred_probs_file="PREDPROBS.npy", batch_size=batch_size) """ if labels_file is not None: if labels is not None: From 4d2753ae058fd10ee3a997282e718f5b78a840a8 Mon Sep 17 00:00:00 2001 From: Hui Wen <45724323+huiwengoh@users.noreply.github.com> Date: Mon, 13 Feb 2023 10:40:52 +0800 Subject: [PATCH 115/258] Fix KerasWrapper summary method (#631) --- cleanlab/models/keras.py | 26 +++++++++++++++++--------- tests/test_frameworks.py | 4 ++++ 2 files changed, 21 insertions(+), 9 deletions(-) diff --git a/cleanlab/models/keras.py b/cleanlab/models/keras.py index d44ea6559f..5935cd5ef9 100644 --- a/cleanlab/models/keras.py +++ b/cleanlab/models/keras.py @@ -112,9 +112,9 @@ def fit(self, X, y=None, **kwargs): but they are ignored. If ``X`` is a numpy array or pandas dataframe, the labels have to be passed in using this argument. """ - - self.net = self.model(**self.model_kwargs) - self.net.compile(**self.compile_kwargs) + if self.net is None: + self.net = self.model(**self.model_kwargs) + self.net.compile(**self.compile_kwargs) # TODO: check for generators if y is not None and not isinstance(X, (tf.data.Dataset, keras.utils.Sequence)): @@ -152,7 +152,11 @@ def predict(self, X, **kwargs): def summary(self, **kwargs): """Returns the summary of the Keras model.""" - self.net.summary(**kwargs) + if self.net is None: + self.net = self.model(**self.model_kwargs) + self.net.compile(**self.compile_kwargs) + + return self.net.summary(**kwargs) class KerasWrapperSequential: @@ -203,8 +207,7 @@ def get_params(self, deep=True): def set_params(self, **params): """Set the parameters of the Keras model.""" - for key, value in params.items(): - self.params[key] = value + self.params.update(params) return self def fit(self, X, y=None, **kwargs): @@ -220,8 +223,9 @@ def fit(self, X, y=None, **kwargs): but they are ignored. If ``X`` is a numpy array or pandas dataframe, the labels have to be passed in using this argument. """ - self.net = tf.keras.models.Sequential(self.layers, self.name) - self.net.compile(**self.compile_kwargs) + if self.net is None: + self.net = tf.keras.models.Sequential(self.layers, self.name) + self.net.compile(**self.compile_kwargs) # TODO: check for generators if y is not None and not isinstance(X, (tf.data.Dataset, keras.utils.Sequence)): @@ -258,4 +262,8 @@ def predict(self, X, **kwargs): def summary(self, **kwargs): """Returns the summary of the Keras model.""" - self.net.summary(**kwargs) + if self.net is None: + self.net = tf.keras.models.Sequential(self.layers, self.name) + self.net.compile(**self.compile_kwargs) + + return self.net.summary(**kwargs) diff --git a/tests/test_frameworks.py b/tests/test_frameworks.py index f26e532b89..d14f9f0a0f 100644 --- a/tests/test_frameworks.py +++ b/tests/test_frameworks.py @@ -143,6 +143,8 @@ def test_tensorflow_sequential(batch_size, shuffle_config, data=DATA, hidden_uni ], ) + model.summary() + # Test base model works: model.fit( X=dataset_tf, @@ -193,6 +195,8 @@ def make_model(num_features, num_classes): model_kwargs={"num_features": data["num_features"], "num_classes": data["num_classes"]}, ) + model.summary() + # Test base model works: model.fit( X=dataset_tf, From 6acc7aead1bbac26c6158f7b16df892cad774dc2 Mon Sep 17 00:00:00 2001 From: Ulyana Date: Sun, 12 Feb 2023 19:45:20 -0800 Subject: [PATCH 116/258] Clarify rank.py not for multi-label classification (#626) Co-authored-by: Jonas Mueller <1390638+jwmueller@users.noreply.github.com> --- cleanlab/rank.py | 1 + 1 file changed, 1 insertion(+) diff --git a/cleanlab/rank.py b/cleanlab/rank.py index 5be235f6bf..60def50a09 100644 --- a/cleanlab/rank.py +++ b/cleanlab/rank.py @@ -25,6 +25,7 @@ Note: multi-label classification is not supported by most methods in this module, each example must be labeled as belonging to a single class, e.g. format: ``labels = np.ndarray([1,0,2,1,1,0...])``. +For multi-label classification, instead see :py:func:`multilabel_classification.get_label_quality_scores `. Note: Label quality scores are most accurate when they are computed based on out-of-sample `pred_probs` from your model. To obtain out-of-sample predicted probabilities for every datapoint in your dataset, you can use :ref:`cross-validation `. This is encouraged to get better results. From 2adb8b68b0fb2cea71a62d363466db4d80963492 Mon Sep 17 00:00:00 2001 From: Sanjana Date: Sun, 12 Feb 2023 19:46:45 -0800 Subject: [PATCH 117/258] Removed $ from shell commands to avoid it being copied (#625) --- DEVELOPMENT.md | 48 +++++++++++++++++++++++++++--------------------- 1 file changed, 27 insertions(+), 21 deletions(-) diff --git a/DEVELOPMENT.md b/DEVELOPMENT.md index 19a1d739f0..6bc352cf3c 100644 --- a/DEVELOPMENT.md +++ b/DEVELOPMENT.md @@ -13,9 +13,9 @@ and [venv](https://docs.python.org/3/library/venv.html). You can the tools and choose what is right for you. Here, we'll explain how to get set up with venv, which is built in to Python 3. -```console -$ python3 -m venv ./ENV # create a new virtual environment in the directory ENV -$ source ./ENV/bin/activate # switch to using the virtual environment +```shell +python3 -m venv ./ENV # create a new virtual environment in the directory ENV +source ./ENV/bin/activate # switch to using the virtual environment ``` You only need to create the virtual environment once, but you will need to @@ -27,9 +27,15 @@ virtual environment rather than your system Python installation. Run the following commands in the repository's root directory. -1. Install development requirements with `pip install -r requirements-dev.txt` +1. Install development requirements +```shell +pip install -r requirements-dev.txt +``` -2. Install cleanlab as an editable package with `pip install -e .` +2. Install cleanlab as an editable package +```shell +pip install -e . +``` For Macs with Apple silicon: replace `tensorflow` in requirements-dev.txt with: `tensorflow-macos==2.9.2` and `tensorflow-metal==0.5.1` @@ -38,26 +44,26 @@ For Macs with Apple silicon: replace `tensorflow` in requirements-dev.txt with: **Run all the tests:** -```console -$ pytest +```shell +pytest ``` **Run a specific file or test:** -``` -$ pytest -k +```shell +pytest -k ``` **Run with verbose output:** -``` -$ pytest --verbose +```shell +pytest --verbose ``` **Run with code coverage:** -``` -$ pytest --cov=cleanlab/ --cov-config .coveragerc --cov-report=html +```shell +pytest --cov=cleanlab/ --cov-config .coveragerc --cov-report=html ``` The coverage report will be available in `coverage_html_report/index.html`, @@ -69,13 +75,13 @@ Cleanlab uses [mypy](https://mypy.readthedocs.io/en/stable/) typing. Type checki **Check typing in all files:** -``` -$ mypy cleanlab +```shell +mypy cleanlab ``` The above is just a simplified command for demonstration, do NOT run this for testing your own type annotations! Our CI adds a few additional flags to the `mypy` command it uses in the file: -**.github/workflows/ci.yml**. +**.github/workflows/ci.yml**. To exactly match the `mypy` command that is executed in CI, copy these flags, and also ensure your version of `mypy` and related packages like `pandas-stubs` match the latest released versions (used in our CI). ### Examples @@ -84,7 +90,7 @@ You can check that the [examples](https://github.com/cleanlab/examples) still work with changes you make to cleanlab by manually running the notebooks. You can also run all example notebooks as follows: -```console +```shell git clone https://github.com/cleanlab/examples.git ``` @@ -93,7 +99,7 @@ E.g. you can edit this line to point to your local version of cleanlab as a rela Finally execute the bash script: -```console +```shell examples/run_all_notebooks.sh ``` @@ -103,7 +109,7 @@ examples/run_all_notebooks.sh cleanlab follows the [Black](https://black.readthedocs.io/) code style (see [pyproject.toml](pyproject.toml)). This is enforced by CI, so please format your code by invoking `black` before submitting a pull request. -Generally aim to follow the [PEP-8 coding style](https://peps.python.org/pep-0008/). +Generally aim to follow the [PEP-8 coding style](https://peps.python.org/pep-0008/). Please do not use wildcard `import *` in any files, instead you should always import the specific functions that you need from a module. All cleanlab code should have a maximum line length of 100 characters. @@ -114,8 +120,8 @@ This repo uses the [pre-commit framework](https://pre-commit.com/) to easily set up code style checks that run automatically whenever you make a commit. You can install the git hook scripts with: -```console -$ pre-commit install +```shell +pre-commit install ``` ### EditorConfig From 485005080398b0088c8d2f640201e234514f3f6a Mon Sep 17 00:00:00 2001 From: clu0 <33559427+clu0@users.noreply.github.com> Date: Sun, 12 Feb 2023 23:25:02 -0500 Subject: [PATCH 118/258] label_issues_batched multiprocessing (#630) 4x speedup (48 cores, 10k classes x 1M examples) Co-authored-by: Jonas Mueller <1390638+jwmueller@users.noreply.github.com> --- cleanlab/experimental/label_issues_batched.py | 217 +++++++++++++++--- tests/test_filter_count.py | 15 ++ 2 files changed, 199 insertions(+), 33 deletions(-) diff --git a/cleanlab/experimental/label_issues_batched.py b/cleanlab/experimental/label_issues_batched.py index ebd164a867..9b528973d3 100644 --- a/cleanlab/experimental/label_issues_batched.py +++ b/cleanlab/experimental/label_issues_batched.py @@ -26,7 +26,7 @@ To run this approach, either follow the examples script below, or use the ``find_label_issues_batched()`` convenience function defined in this module. -The recommended usage demonstrated in the examples script involves two passes over your data: +The recommended usage demonstrated in the examples script involves two passes over your data: one pass to compute `confident_thresholds`, another to evaluate each label. To maximize efficiency, try to use the largest batch_size your memory allows. To reduce runtime further, you can run the first pass on a subset of your dataset @@ -72,16 +72,30 @@ """ import numpy as np -from typing import Optional, List +from typing import Optional, List, Tuple, Any from cleanlab.count import get_confident_thresholds from cleanlab.rank import find_top_issues, _compute_label_quality_scores from cleanlab.typing import LabelLike from cleanlab.internal.util import value_counts_fill_missing_classes +import platform +import multiprocessing as mp + +try: + import psutil + + PSUTIL_EXISTS = True +except ImportError: # pragma: no cover + PSUTIL_EXISTS = False EPS = 1e-6 # small number +# global variable for multiproc on linux +adj_confident_thresholds_shared: np.ndarray +labels_shared: LabelLike +pred_probs_shared: np.ndarray + class LabelInspector: """ @@ -109,6 +123,10 @@ class LabelInspector: verbose : bool, optional Whether to suppress print statements or not. + n_jobs: int, optional + Number of processes for multiprocessing. Only used on Linux. + If `n_jobs=None`, will use either the number of: physical cores if psutil is installed, or logical cores otherwise. + quality_score_kwargs : dict, optional Keyword arguments to pass into :py:func:`rank.get_label_quality_scores `. @@ -126,6 +144,7 @@ def __init__( verbose: bool = True, quality_score_kwargs: Optional[dict] = None, num_issue_kwargs: Optional[dict] = None, + n_jobs: Optional[int] = None, ): if quality_score_kwargs is None: quality_score_kwargs = {} @@ -160,6 +179,26 @@ def __init__( 0 # number of examples seen so far for estimating thresholds ) self.examples_processed_quality = 0 # number of examples seen so far for estimating label quality and number of label issues + # Determine number of cores for multiprocessing: + os_name = platform.system() + if os_name != "Linux": + self.n_jobs = 1 + if n_jobs is not None and n_jobs != 1 and self.verbose: + print( + "n_jobs is overridden to 1 because multiprocessing is only supported for Linux." + ) + elif n_jobs is not None: + self.n_jobs = n_jobs + else: + if PSUTIL_EXISTS: + self.n_jobs = psutil.cpu_count(logical=False) # physical cores + if not self.n_jobs: + # switch to logical cores + self.n_jobs = mp.cpu_count() + if self.verbose: + print( + f"Multiprocessing will default to using the number of logical cores ({self.n_jobs}). To default to number of physical cores: pip install psutil" + ) def get_confident_thresholds(self, silent: bool = False) -> np.ndarray: """ @@ -299,7 +338,11 @@ def update_confident_thresholds(self, labels: LabelLike, pred_probs: np.ndarray) self.examples_processed_thresh += batch_size def score_label_quality( - self, labels: LabelLike, pred_probs: np.ndarray, *, update_num_issues: bool = True + self, + labels: LabelLike, + pred_probs: np.ndarray, + *, + update_num_issues: bool = True, ) -> np.ndarray: """ Scores the label quality of each example in the provided batch of data, @@ -340,46 +383,148 @@ def score_label_quality( return scores - def _update_num_label_issues(self, labels: LabelLike, pred_probs: np.ndarray, **kwargs): + def _update_num_label_issues( + self, + labels: LabelLike, + pred_probs: np.ndarray, + **kwargs, + ): """ Update the estimate of num_label_issues stored in this class using a new batch of data. Kwargs are ignored here for now (included for forwards compatibility). Instead of being specified here, `estimation_method` should be declared when this class is initialized. """ + + # whether to match the output of count.num_label_issues exactly + # default is False, which gives significant speedup on large batches + # and empirically matches num_label_issues even on input sizes of + # 1M x 10k + thorough = False if self.examples_processed_thresh < 1: raise ValueError( "Have not computed any confident_thresholds yet. Call `update_confident_thresholds()` first." ) - batch_size = len(labels) - pred_class = np.argmax(pred_probs, axis=1) - # for efficiency, this pred_class index is also used where older implementation instead used: - # max_ind = np.argmax(pred_probs * (pred_probs >= adj_confident_thresholds), axis=1) - pred_confidence = pred_probs[np.arange(batch_size), pred_class] - # add margin for floating point comparison operations: - adj_confident_thresholds = self.confident_thresholds - EPS - if not self.off_diagonal_calibrated: - prune_count_batch = np.sum( - ( - pred_probs[np.arange(batch_size), pred_class] - >= adj_confident_thresholds[pred_class] + + if self.n_jobs == 1: + adj_confident_thresholds = self.confident_thresholds - EPS + pred_class = np.argmax(pred_probs, axis=1) + batch_size = len(labels) + if thorough: + # add margin for floating point comparison operations: + pred_gt_thresholds = pred_probs >= adj_confident_thresholds + max_ind = np.argmax(pred_probs * pred_gt_thresholds, axis=1) + if not self.off_diagonal_calibrated: + mask = (max_ind != labels) & (pred_class != labels) + else: + # calibrated + # should we change to above? + mask = pred_class != labels + else: + max_ind = pred_class + mask = pred_class != labels + + if not self.off_diagonal_calibrated: + prune_count_batch = np.sum( + ( + pred_probs[np.arange(batch_size), max_ind] + >= adj_confident_thresholds[max_ind] + ) + & mask ) - & (pred_class != labels) - ) - self.prune_count += prune_count_batch - else: # calibrated - self.class_counts += value_counts_fill_missing_classes( - labels, num_classes=self.num_class - ) - to_increment = ( - pred_probs[np.arange(batch_size), pred_class] - >= adj_confident_thresholds[pred_class] - ) - for class_label in range(self.num_class): - labels_equal_to_class = labels == class_label - self.normalization[class_label] += np.sum(labels_equal_to_class & to_increment) - self.prune_counts[class_label] += np.sum( - labels_equal_to_class & to_increment & (pred_class != labels) + self.prune_count += prune_count_batch + else: # calibrated + self.class_counts += value_counts_fill_missing_classes( + labels, num_classes=self.num_class ) + to_increment = ( + pred_probs[np.arange(batch_size), max_ind] >= adj_confident_thresholds[max_ind] + ) + for class_label in range(self.num_class): + labels_equal_to_class = labels == class_label + self.normalization[class_label] += np.sum(labels_equal_to_class & to_increment) + self.prune_counts[class_label] += np.sum( + labels_equal_to_class + & to_increment + & (max_ind != labels) + # & (pred_class != labels) + # This is not applied in num_label_issues(..., estimation_method="off_diagonal_custom"). Do we want to add it? + ) + else: # multiprocessing implementation + global adj_confident_thresholds_shared + adj_confident_thresholds_shared = self.confident_thresholds - EPS + + global labels_shared, pred_probs_shared + labels_shared = labels + pred_probs_shared = pred_probs + if thorough: + use_thorough = np.ones(len(labels_shared), dtype=bool) + else: + use_thorough = np.zeros(len(labels_shared), dtype=bool) + inds = np.arange(len(labels_shared)) + args = zip(inds, use_thorough) + with mp.Pool(self.n_jobs) as pool: + if not self.off_diagonal_calibrated: + prune_count_batch = np.sum( + np.asarray(list(pool.imap_unordered(_compute_num_issues, args))) + ) + self.prune_count += prune_count_batch + else: + results = list(pool.imap_unordered(_compute_num_issues_calibrated, args)) + for result in results: + class_label = result[0] + self.class_counts[class_label] += 1 + self.normalization[class_label] += result[1] + self.prune_counts[class_label] += result[2] + + +def _compute_num_issues(arg: Tuple[int, bool]) -> int: + """ + Helper function for `_update_num_label_issues` multiprocessing without calibration + """ + ind = arg[0] + thorough = arg[1] + label = labels_shared[ind] + pred_prob = pred_probs_shared[ind, :] + pred_class = np.argmax(pred_prob, axis=-1) + if thorough: + pred_gt_thresholds = pred_prob >= adj_confident_thresholds_shared + max_ind = np.argmax(pred_prob * pred_gt_thresholds, axis=-1) + prune_count_batch = ( + (pred_prob[max_ind] >= adj_confident_thresholds_shared[max_ind]) + & (max_ind != label) + & (pred_class != label) + ) + else: + prune_count_batch = np.sum( + (pred_prob[pred_class] >= adj_confident_thresholds_shared[pred_class]) + & (pred_class != label) + ) + return prune_count_batch + + +def _compute_num_issues_calibrated(arg: Tuple[int, bool]) -> Tuple[Any, int, int]: + """ + Helper function for `_update_num_label_issues` multiprocessing with calibration + """ + ind = arg[0] + thorough = arg[1] + label = labels_shared[ind] + pred_prob = pred_probs_shared[ind, :] + + pred_class = np.argmax(pred_prob, axis=-1) + if thorough: + pred_gt_thresholds = pred_prob >= adj_confident_thresholds_shared + max_ind = np.argmax(pred_prob * pred_gt_thresholds, axis=-1) + to_inc = pred_prob[max_ind] >= adj_confident_thresholds_shared[max_ind] + + prune_count_batch = to_inc & (max_ind != label) + normalization_batch = to_inc + else: + to_inc = pred_prob[pred_class] >= adj_confident_thresholds_shared[pred_class] + normalization_batch = to_inc + prune_count_batch = to_inc & (pred_class != label) + + return (label, normalization_batch, prune_count_batch) def _batch_check(labels: LabelLike, pred_probs: np.ndarray, num_class: int) -> np.ndarray: @@ -410,6 +555,7 @@ def find_label_issues_batched( labels: Optional[LabelLike] = None, pred_probs: Optional[np.ndarray] = None, batch_size: int = 10000, + n_jobs: Optional[int] = None, verbose: bool = True, quality_score_kwargs: Optional[dict] = None, num_issue_kwargs: Optional[dict] = None, @@ -452,6 +598,10 @@ def find_label_issues_batched( Size of mini-batches to use for estimating the label issues. To maximize efficiency, try to use the largest `batch_size` your memory allows. + n_jobs: int, optional + Number of processes for multiprocessing. Only used on Linux. + If `n_jobs=None`, will use either the number of: physical cores if psutil is installed, or logical cores otherwise. + verbose : bool, optional Whether to suppress print statements or not. @@ -509,6 +659,7 @@ def find_label_issues_batched( lab = LabelInspector( num_class=pred_probs.shape[1], verbose=verbose, + n_jobs=n_jobs, quality_score_kwargs=quality_score_kwargs, num_issue_kwargs=num_issue_kwargs, ) @@ -537,7 +688,7 @@ def find_label_issues_batched( labels_batch = labels[i:end_index] pred_probs_batch = pred_probs[i:end_index, :] i = end_index - batch_results = lab.score_label_quality(labels_batch, pred_probs_batch) + _ = lab.score_label_quality(labels_batch, pred_probs_batch) if verbose: pbar.update(batch_size) diff --git a/tests/test_filter_count.py b/tests/test_filter_count.py index 8cc624f6a3..d4a1e8da8b 100644 --- a/tests/test_filter_count.py +++ b/tests/test_filter_count.py @@ -919,8 +919,15 @@ def test_batched_label_issues(): f4 = find_label_issues_batched( labels=data["labels"], pred_probs=data["pred_probs"], batch_size=len(data["labels"]) + 100 ) + f_single = find_label_issues_batched( + labels=data["labels"], + pred_probs=data["pred_probs"], + batch_size=len(data["labels"]), + n_jobs=1, + ) assert np.all(f4 == f3) assert np.all(f4 == f2) + assert np.all(f_single == f4) assert len(f2) == len(f1) # check jaccard similarity: intersection = len(list(set(f1).intersection(set(f2)))) @@ -955,9 +962,17 @@ def test_batched_label_issues(): batch_size=len(data["labels"]) + 100, **extra_args, ) + f_single = find_label_issues_batched( + labels=data["labels"], + pred_probs=data["pred_probs"], + batch_size=len(data["labels"]), + n_jobs=1, + **extra_args, + ) assert not np.array_equal(f5, f2) assert np.all(f7 == f5) assert np.all(f6 == f5) + assert np.all(f_single == f5) assert np.abs(len(f5) - n1) < 2 # Test batches loaded from file: labels_file = path.join(mkdtemp(), "labels.npy") From f4572dc543a1f39011f9f03d8a94dd075d3992bb Mon Sep 17 00:00:00 2001 From: Jonas Mueller <1390638+jwmueller@users.noreply.github.com> Date: Sun, 12 Feb 2023 21:31:59 -0800 Subject: [PATCH 119/258] bugfix: missing self.n_jobs --- cleanlab/experimental/label_issues_batched.py | 1 + 1 file changed, 1 insertion(+) diff --git a/cleanlab/experimental/label_issues_batched.py b/cleanlab/experimental/label_issues_batched.py index 9b528973d3..2ca60f3e15 100644 --- a/cleanlab/experimental/label_issues_batched.py +++ b/cleanlab/experimental/label_issues_batched.py @@ -190,6 +190,7 @@ def __init__( elif n_jobs is not None: self.n_jobs = n_jobs else: + self.n_jobs = None if PSUTIL_EXISTS: self.n_jobs = psutil.cpu_count(logical=False) # physical cores if not self.n_jobs: From 8c424d3b0d7d40cb133fb09e7f512b867f80e697 Mon Sep 17 00:00:00 2001 From: Jonas Mueller <1390638+jwmueller@users.noreply.github.com> Date: Sun, 12 Feb 2023 22:06:40 -0800 Subject: [PATCH 120/258] mypy tpye annotations --- cleanlab/experimental/label_issues_batched.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cleanlab/experimental/label_issues_batched.py b/cleanlab/experimental/label_issues_batched.py index 2ca60f3e15..1a1c7be424 100644 --- a/cleanlab/experimental/label_issues_batched.py +++ b/cleanlab/experimental/label_issues_batched.py @@ -180,6 +180,7 @@ def __init__( ) self.examples_processed_quality = 0 # number of examples seen so far for estimating label quality and number of label issues # Determine number of cores for multiprocessing: + self.n_jobs: Optional[int] = None os_name = platform.system() if os_name != "Linux": self.n_jobs = 1 @@ -190,7 +191,6 @@ def __init__( elif n_jobs is not None: self.n_jobs = n_jobs else: - self.n_jobs = None if PSUTIL_EXISTS: self.n_jobs = psutil.cpu_count(logical=False) # physical cores if not self.n_jobs: From 731dd419a15f817fd468c323ce6d055abed7b4f9 Mon Sep 17 00:00:00 2001 From: Jonas Mueller <1390638+jwmueller@users.noreply.github.com> Date: Sun, 12 Feb 2023 23:59:26 -0800 Subject: [PATCH 121/258] Support Zarr files in find_label_issues_batched (#632) --- cleanlab/experimental/label_issues_batched.py | 418 +++++++++--------- docs/source/tutorials/faq.ipynb | 2 +- 2 files changed, 222 insertions(+), 198 deletions(-) diff --git a/cleanlab/experimental/label_issues_batched.py b/cleanlab/experimental/label_issues_batched.py index 1a1c7be424..ee59a7958e 100644 --- a/cleanlab/experimental/label_issues_batched.py +++ b/cleanlab/experimental/label_issues_batched.py @@ -23,52 +23,8 @@ With default settings, the results returned from this approach closely approximate those returned from: ``cleanlab.filter.find_label_issues(..., filter_by="low_self_confidence", return_indices_ranked_by="self_confidence")`` -To run this approach, either follow the examples script below, -or use the ``find_label_issues_batched()`` convenience function defined in this module. - -The recommended usage demonstrated in the examples script involves two passes over your data: -one pass to compute `confident_thresholds`, another to evaluate each label. -To maximize efficiency, try to use the largest batch_size your memory allows. -To reduce runtime further, you can run the first pass on a subset of your dataset -as long as it contains enough data from each class to estimate `confident_thresholds` accurately. - -In the examples script below: -- `labels` is a (big) 1D ``np.ndarray`` of class labels represented as integers in ``0,1,...,K-1``. -- ``pred_probs`` = is a (big) 2D ``np.ndarray`` of predicted class probabilities, -where each row is an example, each column represents a class. - -`labels` and `pred_probs` can be stored in a file instead where you load chunks of them at a time. -Methods to load arrays in chunks include: ``np.load(...,mmap_mode='r')``, ``numpy.memmap()``, -HDF5 or Zarr files, see: https://pythonspeed.com/articles/mmap-vs-zarr-hdf5/ - -Examples --------- ->>> n = len(labels) ->>> batch_size = 10000 # you can change this in between batches, set as big as your RAM allows ->>> lab = LabelInspector(num_class = pred_probs.shape[1]) ->>> # First compute confident thresholds (for faster results, can also do this on a random subset of your data): ->>> i = 0 ->>> while i < n: ->>> end_index = i + batch_size ->>> labels_batch = labels[i:end_index] ->>> pred_probs_batch = pred_probs[i:end_index,:] ->>> i = end_index ->>> lab.update_confident_thresholds(labels_batch, pred_probs_batch) ->>> # See what we calculated: ->>> confident_thresholds = lab.get_confident_thresholds() ->>> # Evaluate the quality of the labels (run this on full dataset you want to evaluate): ->>> i = 0 ->>> while i < n: ->>> end_index = i + batch_size ->>> labels_batch = labels[i:end_index] ->>> pred_probs_batch = pred_probs[i:end_index,:] ->>> i = end_index ->>> batch_results = lab.score_label_quality(labels_batch, pred_probs_batch) ->>> # Indices of examples with label issues, sorted by label quality score (most severe to least severe): ->>> indices_of_examples_with_issues = lab.get_label_issues() ->>> # If your `pred_probs` and `labels` are arrays already in memory, ->>> # then you can use this shortcut for all of the above: ->>> indices_of_examples_with_issues = find_label_issues_batched(labels, pred_probs, batch_size=10000) +To run this approach, either use the ``find_label_issues_batched()`` convenience function defined in this module, +or follow the examples script for the ``LabelInspector`` class if you require greater customization. """ import numpy as np @@ -97,6 +53,180 @@ pred_probs_shared: np.ndarray +def find_label_issues_batched( + labels: Optional[LabelLike] = None, + pred_probs: Optional[np.ndarray] = None, + *, + labels_file: Optional[str] = None, + pred_probs_file: Optional[str] = None, + batch_size: int = 10000, + n_jobs: Optional[int] = None, + verbose: bool = True, + quality_score_kwargs: Optional[dict] = None, + num_issue_kwargs: Optional[dict] = None, +) -> np.ndarray: + """ + Variant of :py:func:`filter.find_label_issues ` + that requires less memory by reading from `pred_probs`, `labels` in mini-batches. + To avoid loading big `pred_probs`, `labels` arrays into memory, + provide these as memory-mapped objects like Zarr arrays or memmap arrays instead of regular numpy arrays. + See: https://pythonspeed.com/articles/mmap-vs-zarr-hdf5/ + + With default settings, the results returned from this method closely approximate those returned from: + ``cleanlab.filter.find_label_issues(..., filter_by="low_self_confidence", return_indices_ranked_by="self_confidence")`` + + This function internally implements the example usage script of the ``LabelInspector`` class, + but you can further customize that script by running it yourself instead of this function. + See the documentation of ``LabelInspector`` to learn more about how this method works internally. + + Parameters + ---------- + labels: np.ndarray-like object, optional + 1D array of given class labels for each example in the dataset, (int) values in ``0,1,2,...,K-1``. + To avoid loading big objects into memory, you should pass this as a memory-mapped object like: + Zarr array loaded with ``zarr.convenience.open(YOURFILE.zarr, mode="r")``, + or memmap array loaded with ``np.load(YOURFILE.npy, mmap_mode="r")``. + + Tip: You can save an existing numpy array to Zarr via: ``zarr.convenience.save_array(YOURFILE.zarr, your_array)``, + or to .npy file that can be loaded with mmap via: ``np.save(YOURFILE.npy, your_array)``. + + pred_probs: np.ndarray-like object, optional + 2D array of model-predicted class probabilities (floats) for each example in the dataset. + To avoid loading big objects into memory, you should pass this as a memory-mapped object like: + Zarr array loaded with ``zarr.convenience.open(YOURFILE.zarr, mode="r")`` + or memmap array loaded with ``np.load(YOURFILE.npy, mmap_mode="r")``. + + labels_file: str, optional + Specify this instead of `labels` if you want this method to load from file for you into a memmap array. + Path to .npy file where the entire 1D `labels` numpy array is stored on disk (list format is not supported). + This is loaded using: ``np.load(labels_file, mmap_mode="r")`` + so make sure this file was created via: ``np.save()`` or other compatible methods (.npz not supported). + + pred_probs_file: str, optional + Specify this instead of `pred_probs` if you want this method to load from file for you into a memmap array. + Path to .npy file where the entire `pred_probs` numpy array is stored on disk. + This is loaded using: ``np.load(pred_probs_file, mmap_mode="r")`` + so make sure this file was created via: ``np.save()`` or other compatible methods (.npz not supported). + + batch_size : int, optional + Size of mini-batches to use for estimating the label issues. + To maximize efficiency, try to use the largest `batch_size` your memory allows. + + n_jobs: int, optional + Number of processes for multiprocessing. Only used on Linux. + If `n_jobs=None`, will use either the number of: physical cores if psutil is installed, or logical cores otherwise. + + verbose : bool, optional + Whether to suppress print statements or not. + + quality_score_kwargs : dict, optional + Keyword arguments to pass into :py:func:`rank.get_label_quality_scores `. + + num_issue_kwargs : dict, optional + Keyword arguments to :py:func:`count.num_label_issues()` ` + to control estimation of the number of label issues. + The only supported kwarg here for now is: `estimation_method`. + + Returns + ------- + issue_indices : np.ndarray + Indices of examples with label issues, sorted by label quality score. + + Examples + -------- + >>> batch_size = 10000 # for efficiency, set this to as large of a value as your memory can handle + >>> # Just demonstrating how to save your existing numpy labels, pred_probs arrays to compatible .npy files: + >>> np.save("LABELS.npy", labels_array) + >>> np.save("PREDPROBS.npy", pred_probs_array) + >>> # You can load these back into memmap arrays via: labels = np.load("LABELS.npy", mmap_mode="r") + >>> # and then run this method on the memmap arrays, or just run it directly on the .npy files like this: + >>> issues = find_label_issues_batched(labels_file="LABELS.npy", pred_probs_file="PREDPROBS.npy", batch_size=batch_size) + >>> # This method also works with Zarr arrays: + >>> import zarr + >>> # Just demonstrating how to save your existing numpy labels, pred_probs arrays to compatible .zarr files: + >>> zarr.convenience.save_array("LABELS.zarr", labels_array) + >>> zarr.convenience.save_array("PREDPROBS.zarr", pred_probs_array) + >>> # You can load from such files into Zarr arrays: + >>> labels = zarr.convenience.open("LABELS.zarr", mode="r") + >>> pred_probs = zarr.convenience.open("PREDPROBS.zarr", mode="r") + >>> # This method can be directly run on Zarr arrays, memmap arrays, or regular numpy arrays: + >>> issues = find_label_issues_batched(labels=labels, pred_probs=pred_probs, batch_size=batch_size) + """ + if labels_file is not None: + if labels is not None: + raise ValueError("only specify one of: `labels` or `labels_file`") + if not isinstance(labels_file, str): + raise ValueError( + "labels_file must be str specifying path to .npy file containing the array of labels" + ) + labels = np.load(labels_file, mmap_mode="r") + assert isinstance(labels, np.ndarray) + + if pred_probs_file is not None: + if pred_probs is not None: + raise ValueError("only specify one of: `pred_probs` or `pred_probs_file`") + if not isinstance(pred_probs_file, str): + raise ValueError( + "pred_probs_file must be str specifying path to .npy file containing 2D array of pred_probs" + ) + pred_probs = np.load(pred_probs_file, mmap_mode="r") + assert isinstance(pred_probs, np.ndarray) + if verbose: + print( + f"mmap-loaded numpy arrays have: {len(pred_probs)} examples, {pred_probs.shape[1]} classes" + ) + if labels is None: + raise ValueError("must provide one of: `labels` or `labels_file`") + if pred_probs is None: + raise ValueError("must provide one of: `pred_probs` or `pred_probs_file`") + + assert pred_probs is not None + if len(labels) != len(pred_probs): + raise ValueError( + f"len(labels)={len(labels)} does not match len(pred_probs)={len(pred_probs)}. Perhaps an issue loading mmap numpy arrays from file." + ) + lab = LabelInspector( + num_class=pred_probs.shape[1], + verbose=verbose, + n_jobs=n_jobs, + quality_score_kwargs=quality_score_kwargs, + num_issue_kwargs=num_issue_kwargs, + ) + n = len(labels) + if verbose: + from tqdm.auto import tqdm + + pbar = tqdm(desc="number of examples processed for estimating thresholds", total=n) + i = 0 + while i < n: + end_index = i + batch_size + labels_batch = labels[i:end_index] + pred_probs_batch = pred_probs[i:end_index, :] + i = end_index + lab.update_confident_thresholds(labels_batch, pred_probs_batch) + if verbose: + pbar.update(batch_size) + + # Next evaluate the quality of the labels (run this on full dataset you want to evaluate): + if verbose: + pbar.close() + pbar = tqdm(desc="number of examples processed for checking labels", total=n) + i = 0 + while i < n: + end_index = i + batch_size + labels_batch = labels[i:end_index] + pred_probs_batch = pred_probs[i:end_index, :] + i = end_index + _ = lab.score_label_quality(labels_batch, pred_probs_batch) + if verbose: + pbar.update(batch_size) + + if verbose: + pbar.close() + + return lab.get_label_issues() + + class LabelInspector: """ Class for finding label issues in big datasets where memory becomes a problem for other cleanlab methods. @@ -107,6 +237,50 @@ class LabelInspector: Do NOT modify any of the attributes of this class yourself! Multi-label classification is not supported by this class, it is only for multi-class classification. + The recommended usage demonstrated in the examples script below involves two passes over your data: + one pass to compute `confident_thresholds`, another to evaluate each label. + To maximize efficiency, try to use the largest batch_size your memory allows. + To reduce runtime further, you can run the first pass on a subset of your dataset + as long as it contains enough data from each class to estimate `confident_thresholds` accurately. + + In the examples script below: + - `labels` is a (big) 1D ``np.ndarray`` of class labels represented as integers in ``0,1,...,K-1``. + - ``pred_probs`` = is a (big) 2D ``np.ndarray`` of predicted class probabilities, + where each row is an example, each column represents a class. + + `labels` and `pred_probs` can be stored in a file instead where you load chunks of them at a time. + Methods to load arrays in chunks include: ``np.load(...,mmap_mode='r')``, ``numpy.memmap()``, + HDF5 or Zarr files, see: https://pythonspeed.com/articles/mmap-vs-zarr-hdf5/ + + Examples + -------- + >>> n = len(labels) + >>> batch_size = 10000 # you can change this in between batches, set as big as your RAM allows + >>> lab = LabelInspector(num_class = pred_probs.shape[1]) + >>> # First compute confident thresholds (for faster results, can also do this on a random subset of your data): + >>> i = 0 + >>> while i < n: + >>> end_index = i + batch_size + >>> labels_batch = labels[i:end_index] + >>> pred_probs_batch = pred_probs[i:end_index,:] + >>> i = end_index + >>> lab.update_confident_thresholds(labels_batch, pred_probs_batch) + >>> # See what we calculated: + >>> confident_thresholds = lab.get_confident_thresholds() + >>> # Evaluate the quality of the labels (run this on full dataset you want to evaluate): + >>> i = 0 + >>> while i < n: + >>> end_index = i + batch_size + >>> labels_batch = labels[i:end_index] + >>> pred_probs_batch = pred_probs[i:end_index,:] + >>> i = end_index + >>> batch_results = lab.score_label_quality(labels_batch, pred_probs_batch) + >>> # Indices of examples with label issues, sorted by label quality score (most severe to least severe): + >>> indices_of_examples_with_issues = lab.get_label_issues() + >>> # If your `pred_probs` and `labels` are arrays already in memory, + >>> # then you can use this shortcut for all of the above: + >>> indices_of_examples_with_issues = find_label_issues_batched(labels, pred_probs, batch_size=10000) + Parameters ---------- num_class : int @@ -352,7 +526,7 @@ def score_label_quality( Parameters ---------- - labels: np.ndarray or list + labels: np.ndarray Given class labels for each example in the batch, values in ``0,1,2,...,K-1``. pred_probs: np.ndarray @@ -547,153 +721,3 @@ def _batch_check(labels: LabelLike, pred_probs: np.ndarray, num_class: int) -> n raise ValueError("num_class must equal pred_probs.shape[1]") return labels - - -def find_label_issues_batched( - *, - labels_file: Optional[str] = None, - pred_probs_file: Optional[str] = None, - labels: Optional[LabelLike] = None, - pred_probs: Optional[np.ndarray] = None, - batch_size: int = 10000, - n_jobs: Optional[int] = None, - verbose: bool = True, - quality_score_kwargs: Optional[dict] = None, - num_issue_kwargs: Optional[dict] = None, -) -> np.ndarray: - """ - Variant of :py:func:`filter.find_label_issues ` - that requires less memory by reading `pred_probs`, `labels` in mini-batches, if provided as files. - Only .npy files are supported (not .npz), and these must be loadable via: ``np.load(your_file, mmap_mode="r")``. - If you want to read from other file-types (eg. HDF5 or Zarr) instead, - see the example usage of the ``LabelInspector`` class. - - This function basically implements the example ``LabelInspector`` usage script, - but you can further customize that script by running it yourself. - See the documentation of ``LabelInspector`` to learn more about how this method works internally. - - With default settings, the results returned from this method closely approximate those returned from: - ``cleanlab.filter.find_label_issues(..., filter_by="low_self_confidence", return_indices_ranked_by="self_confidence")`` - - Parameters - ---------- - labels_file: str, optional - Path to .npy file where the entire 1D `labels` numpy array is stored on disk (list format is not supported). - This is loaded using: ``np.load(labels_file, mmap_mode="r")`` - so make sure this file was created via: ``np.save()`` or other compatible methods. - - pred_probs_file: str, optional - Path to .npy file where the entire `pred_probs` numpy array is stored on disk. - This is loaded using: ``np.load(pred_probs_file, mmap_mode="r")`` - so make sure this file was created via: ``np.save()`` or other compatible methods. - - labels: np.ndarray or list, optional - Given class labels for each example in the dataset, (int) values in ``0,1,2,...,K-1``. - Recommend providing `labels_file` instead of `labels` to avoid loading big objects into memory. - - pred_probs: np.ndarray, optional - 2D array of model-predicted class probabilities (floats) for each example in the dataset. - Recommend providing `pred_probs_file` instead of `pred_probs` to avoid loading big objects into memory. - - batch_size : int, optional - Size of mini-batches to use for estimating the label issues. - To maximize efficiency, try to use the largest `batch_size` your memory allows. - - n_jobs: int, optional - Number of processes for multiprocessing. Only used on Linux. - If `n_jobs=None`, will use either the number of: physical cores if psutil is installed, or logical cores otherwise. - - verbose : bool, optional - Whether to suppress print statements or not. - - quality_score_kwargs : dict, optional - Keyword arguments to pass into :py:func:`rank.get_label_quality_scores `. - - num_issue_kwargs : dict, optional - Keyword arguments to :py:func:`count.num_label_issues()` ` - to control estimation of the number of label issues. - The only supported kwarg here for now is: `estimation_method`. - - Returns - ------- - issue_indices : np.ndarray - Indices of examples with label issues, sorted by label quality score. - - Examples - -------- - >>> batch_size = 10000 # for efficiency, set this to as large of a value as your memory can handle - >>> issues = find_label_issues_batched(labels_file="LABELS.npy", pred_probs_file="PREDPROBS.npy", batch_size=batch_size) - """ - if labels_file is not None: - if labels is not None: - raise ValueError("only specify one of: `labels` or `labels_file`") - if not isinstance(labels_file, str): - raise ValueError( - "labels_file must be str specifying path to .npy file containing the array of labels" - ) - labels = np.load(labels_file, mmap_mode="r") - assert isinstance(labels, np.ndarray) - - if pred_probs_file is not None: - if pred_probs is not None: - raise ValueError("only specify one of: `pred_probs` or `pred_probs_file`") - if not isinstance(pred_probs_file, str): - raise ValueError( - "pred_probs_file must be str specifying path to .npy file containing 2D array of pred_probs" - ) - pred_probs = np.load(pred_probs_file, mmap_mode="r") - assert isinstance(pred_probs, np.ndarray) - if verbose: - print( - f"mmap-loaded numpy arrays have: {len(pred_probs)} examples, {pred_probs.shape[1]} classes" - ) - if labels is None: - raise ValueError("must provide one of: `labels` or `labels_file`") - if pred_probs is None: - raise ValueError("must provide one of: `pred_probs` or `pred_probs_file`") - - assert isinstance(pred_probs, np.ndarray) - if len(labels) != len(pred_probs): - raise ValueError( - f"len(labels)={len(labels)} does not match len(pred_probs)={len(pred_probs)}. Perhaps an issue loading mmap numpy arrays from file." - ) - lab = LabelInspector( - num_class=pred_probs.shape[1], - verbose=verbose, - n_jobs=n_jobs, - quality_score_kwargs=quality_score_kwargs, - num_issue_kwargs=num_issue_kwargs, - ) - n = len(labels) - if verbose: - from tqdm.auto import tqdm - - pbar = tqdm(desc="number of examples processed for estimating thresholds", total=n) - i = 0 - while i < n: - end_index = i + batch_size - labels_batch = labels[i:end_index] - pred_probs_batch = pred_probs[i:end_index, :] - i = end_index - lab.update_confident_thresholds(labels_batch, pred_probs_batch) - if verbose: - pbar.update(batch_size) - - # Next evaluate the quality of the labels (run this on full dataset you want to evaluate): - if verbose: - pbar.close() - pbar = tqdm(desc="number of examples processed for checking labels", total=n) - i = 0 - while i < n: - end_index = i + batch_size - labels_batch = labels[i:end_index] - pred_probs_batch = pred_probs[i:end_index, :] - i = end_index - _ = lab.score_label_quality(labels_batch, pred_probs_batch) - if verbose: - pbar.update(batch_size) - - if verbose: - pbar.close() - - return lab.get_label_issues() diff --git a/docs/source/tutorials/faq.ipynb b/docs/source/tutorials/faq.ipynb index 6f9972505a..1152e5c86e 100644 --- a/docs/source/tutorials/faq.ipynb +++ b/docs/source/tutorials/faq.ipynb @@ -221,7 +221,7 @@ "id": "089f505e", "metadata": {}, "source": [ - "For a dataset with many rows and/or classes, there are more efficient methods in the `label_issues_batched` module. These methods read data in mini-batches and you can reduce the `batch_size` to control how much memory they require. Below is an example of how to use the `find_label_issues_batched()` method from this module, which can load mini-batches of data from `labels`, `pred_probs` saved as .npy files on disk. Check out the `LabelInspector` class from this module if you instead have `labels`, `pred_probs` saved as other file-types (eg. HDF5 or Zarr)." + "For a dataset with many rows and/or classes, there are more efficient methods in the `label_issues_batched` module. These methods read data in mini-batches and you can reduce the `batch_size` to control how much memory they require. Below is an example of how to use the `find_label_issues_batched()` method from this module, which can load mini-batches of data from `labels`, `pred_probs` saved as .npy files on disk. You can also run this method on Zarr arrays loaded from .zarr files. If you need greater flexibility, check out the `LabelInspector` class from this module." ] }, { From c85bc7e58910750c2cb602216fb1367f0d817725 Mon Sep 17 00:00:00 2001 From: Jonas Mueller <1390638+jwmueller@users.noreply.github.com> Date: Mon, 13 Feb 2023 17:04:55 -0800 Subject: [PATCH 122/258] default n_jobs in label issues batched to =1 (#633) --- cleanlab/experimental/label_issues_batched.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/cleanlab/experimental/label_issues_batched.py b/cleanlab/experimental/label_issues_batched.py index ee59a7958e..8ccaadd10e 100644 --- a/cleanlab/experimental/label_issues_batched.py +++ b/cleanlab/experimental/label_issues_batched.py @@ -60,7 +60,7 @@ def find_label_issues_batched( labels_file: Optional[str] = None, pred_probs_file: Optional[str] = None, batch_size: int = 10000, - n_jobs: Optional[int] = None, + n_jobs: Optional[int] = 1, verbose: bool = True, quality_score_kwargs: Optional[dict] = None, num_issue_kwargs: Optional[dict] = None, @@ -113,7 +113,7 @@ def find_label_issues_batched( To maximize efficiency, try to use the largest `batch_size` your memory allows. n_jobs: int, optional - Number of processes for multiprocessing. Only used on Linux. + Number of processes for multiprocessing (default value = 1). Only used on Linux. If `n_jobs=None`, will use either the number of: physical cores if psutil is installed, or logical cores otherwise. verbose : bool, optional @@ -298,7 +298,7 @@ class LabelInspector: Whether to suppress print statements or not. n_jobs: int, optional - Number of processes for multiprocessing. Only used on Linux. + Number of processes for multiprocessing (default value = 1). Only used on Linux. If `n_jobs=None`, will use either the number of: physical cores if psutil is installed, or logical cores otherwise. quality_score_kwargs : dict, optional @@ -318,7 +318,7 @@ def __init__( verbose: bool = True, quality_score_kwargs: Optional[dict] = None, num_issue_kwargs: Optional[dict] = None, - n_jobs: Optional[int] = None, + n_jobs: Optional[int] = 1, ): if quality_score_kwargs is None: quality_score_kwargs = {} From 3757637d8cf30ad0712b2a2080c9f9c1147da7f4 Mon Sep 17 00:00:00 2001 From: clu0 <33559427+clu0@users.noreply.github.com> Date: Wed, 15 Feb 2023 16:14:39 -0500 Subject: [PATCH 123/258] Fix batched multiprocessing being slower on tall matrices (#634) Co-authored-by: Jonas Mueller <1390638+jwmueller@users.noreply.github.com> --- cleanlab/experimental/label_issues_batched.py | 45 ++++++++++++++----- docs/source/tutorials/faq.ipynb | 2 +- tests/test_filter_count.py | 8 +++- 3 files changed, 43 insertions(+), 12 deletions(-) diff --git a/cleanlab/experimental/label_issues_batched.py b/cleanlab/experimental/label_issues_batched.py index 8ccaadd10e..8fe52a9be6 100644 --- a/cleanlab/experimental/label_issues_batched.py +++ b/cleanlab/experimental/label_issues_batched.py @@ -631,11 +631,19 @@ def _update_num_label_issues( global labels_shared, pred_probs_shared labels_shared = labels pred_probs_shared = pred_probs + + # good values for this are ~1000-10000 in benchmarks where pred_probs has 1B entries: + processes = 5000 + if len(labels) <= processes: + chunksize = 1 + else: + chunksize = len(labels) // processes + inds = split_arr(np.arange(len(labels)), chunksize) + if thorough: - use_thorough = np.ones(len(labels_shared), dtype=bool) + use_thorough = np.ones(len(inds), dtype=bool) else: - use_thorough = np.zeros(len(labels_shared), dtype=bool) - inds = np.arange(len(labels_shared)) + use_thorough = np.zeros(len(inds), dtype=bool) args = zip(inds, use_thorough) with mp.Pool(self.n_jobs) as pool: if not self.off_diagonal_calibrated: @@ -652,7 +660,14 @@ def _update_num_label_issues( self.prune_counts[class_label] += result[2] -def _compute_num_issues(arg: Tuple[int, bool]) -> int: +def split_arr(arr: np.ndarray, chunksize: int) -> List[np.ndarray]: + """ + Helper function to split array into chunks for multiprocessing + """ + return np.split(arr, np.arange(chunksize, arr.shape[0], chunksize), axis=0) + + +def _compute_num_issues(arg: Tuple[np.ndarray, bool]) -> int: """ Helper function for `_update_num_label_issues` multiprocessing without calibration """ @@ -661,23 +676,27 @@ def _compute_num_issues(arg: Tuple[int, bool]) -> int: label = labels_shared[ind] pred_prob = pred_probs_shared[ind, :] pred_class = np.argmax(pred_prob, axis=-1) + batch_size = len(label) if thorough: pred_gt_thresholds = pred_prob >= adj_confident_thresholds_shared max_ind = np.argmax(pred_prob * pred_gt_thresholds, axis=-1) - prune_count_batch = ( - (pred_prob[max_ind] >= adj_confident_thresholds_shared[max_ind]) + prune_count_batch = np.sum( + (pred_prob[np.arange(batch_size), max_ind] >= adj_confident_thresholds_shared[max_ind]) & (max_ind != label) & (pred_class != label) ) else: prune_count_batch = np.sum( - (pred_prob[pred_class] >= adj_confident_thresholds_shared[pred_class]) + ( + pred_prob[np.arange(batch_size), pred_class] + >= adj_confident_thresholds_shared[pred_class] + ) & (pred_class != label) ) return prune_count_batch -def _compute_num_issues_calibrated(arg: Tuple[int, bool]) -> Tuple[Any, int, int]: +def _compute_num_issues_calibrated(arg: Tuple[np.ndarray, bool]) -> Tuple[Any, int, int]: """ Helper function for `_update_num_label_issues` multiprocessing with calibration """ @@ -685,17 +704,23 @@ def _compute_num_issues_calibrated(arg: Tuple[int, bool]) -> Tuple[Any, int, int thorough = arg[1] label = labels_shared[ind] pred_prob = pred_probs_shared[ind, :] + batch_size = len(label) pred_class = np.argmax(pred_prob, axis=-1) if thorough: pred_gt_thresholds = pred_prob >= adj_confident_thresholds_shared max_ind = np.argmax(pred_prob * pred_gt_thresholds, axis=-1) - to_inc = pred_prob[max_ind] >= adj_confident_thresholds_shared[max_ind] + to_inc = ( + pred_prob[np.arange(batch_size), max_ind] >= adj_confident_thresholds_shared[max_ind] + ) prune_count_batch = to_inc & (max_ind != label) normalization_batch = to_inc else: - to_inc = pred_prob[pred_class] >= adj_confident_thresholds_shared[pred_class] + to_inc = ( + pred_prob[np.arange(batch_size), pred_class] + >= adj_confident_thresholds_shared[pred_class] + ) normalization_batch = to_inc prune_count_batch = to_inc & (pred_class != label) diff --git a/docs/source/tutorials/faq.ipynb b/docs/source/tutorials/faq.ipynb index 1152e5c86e..1ecdc4f0f1 100644 --- a/docs/source/tutorials/faq.ipynb +++ b/docs/source/tutorials/faq.ipynb @@ -221,7 +221,7 @@ "id": "089f505e", "metadata": {}, "source": [ - "For a dataset with many rows and/or classes, there are more efficient methods in the `label_issues_batched` module. These methods read data in mini-batches and you can reduce the `batch_size` to control how much memory they require. Below is an example of how to use the `find_label_issues_batched()` method from this module, which can load mini-batches of data from `labels`, `pred_probs` saved as .npy files on disk. You can also run this method on Zarr arrays loaded from .zarr files. If you need greater flexibility, check out the `LabelInspector` class from this module." + "For a dataset with many rows and/or classes, there are more efficient methods in the `label_issues_batched` module. These methods read data in mini-batches and you can reduce the `batch_size` to control how much memory they require. Below is an example of how to use the `find_label_issues_batched()` method from this module, which can load mini-batches of data from `labels`, `pred_probs` saved as .npy files on disk. You can also run this method on Zarr arrays loaded from .zarr files. Try playing with the `n_jobs` argument for further multiprocessing speedups. If you need greater flexibility, check out the `LabelInspector` class from this module." ] }, { diff --git a/tests/test_filter_count.py b/tests/test_filter_count.py index d4a1e8da8b..a7b7afd259 100644 --- a/tests/test_filter_count.py +++ b/tests/test_filter_count.py @@ -915,9 +915,13 @@ def test_batched_label_issues(): labels=data["labels"], pred_probs=data["pred_probs"], batch_size=int(len(data["labels"]) / 2.0), + n_jobs=None, ) f4 = find_label_issues_batched( - labels=data["labels"], pred_probs=data["pred_probs"], batch_size=len(data["labels"]) + 100 + labels=data["labels"], + pred_probs=data["pred_probs"], + batch_size=len(data["labels"]) + 100, + n_jobs=4, ) f_single = find_label_issues_batched( labels=data["labels"], @@ -954,12 +958,14 @@ def test_batched_label_issues(): labels=data["labels"], pred_probs=data["pred_probs"], batch_size=int(len(data["labels"]) / 2.0), + n_jobs=None, **extra_args, ) f7 = find_label_issues_batched( labels=data["labels"], pred_probs=data["pred_probs"], batch_size=len(data["labels"]) + 100, + n_jobs=4, **extra_args, ) f_single = find_label_issues_batched( From 6eb60198e60c7425c52fe88f0b1c2ea2d1d856bc Mon Sep 17 00:00:00 2001 From: Jonas Mueller <1390638+jwmueller@users.noreply.github.com> Date: Wed, 15 Feb 2023 17:34:11 -0800 Subject: [PATCH 124/258] update tests to be more stringent (#635) --- docs/source/tutorials/faq.ipynb | 4 ++-- tests/test_filter_count.py | 6 ++---- 2 files changed, 4 insertions(+), 6 deletions(-) diff --git a/docs/source/tutorials/faq.ipynb b/docs/source/tutorials/faq.ipynb index 1ecdc4f0f1..a1978e1417 100644 --- a/docs/source/tutorials/faq.ipynb +++ b/docs/source/tutorials/faq.ipynb @@ -262,13 +262,13 @@ "source": [ "# This cell is hidden on docs.cleanlab.ai, and is only for internal testing. You can ignore it.\n", "\n", - "issue_indices = cleanlab.filter.find_label_issues(labels, pred_probs, filter_by = \"confident_learning\", return_indices_ranked_by=\"self_confidence\")\n", + "issue_indices = cleanlab.filter.find_label_issues(labels, pred_probs, filter_by = \"low_self_confidence\", return_indices_ranked_by=\"self_confidence\")\n", "assert np.abs(len(issue_indices) - len(indices_of_examples_with_issues)) < 2, \"num issues differ in batched mode\"\n", "set1 = set(issue_indices)\n", "set2 = set(indices_of_examples_with_issues)\n", "intersection = len(list(set1.intersection(set2)))\n", "union = len(set1) + len(set2) - intersection\n", - "assert float(intersection) / union > 0.9, \"issue indices differ in batched mode\"" + "assert float(intersection) / union > 0.95, \"issue indices differ in batched mode\"" ] }, { diff --git a/tests/test_filter_count.py b/tests/test_filter_count.py index a7b7afd259..26c82c6214 100644 --- a/tests/test_filter_count.py +++ b/tests/test_filter_count.py @@ -902,9 +902,7 @@ def test_batched_label_issues(): labels=data["labels"], pred_probs=data["pred_probs"], return_indices_ranked_by="self_confidence", - filter_by="confident_learning", - # TODO: replace the above line with: - # filter_by="low_self_confidence", + filter_by="low_self_confidence", ) f2 = find_label_issues_batched( labels=data["labels"], @@ -936,7 +934,7 @@ def test_batched_label_issues(): # check jaccard similarity: intersection = len(list(set(f1).intersection(set(f2)))) union = len(set(f1)) + len(set(f2)) - intersection - assert float(intersection) / union > 0.6 + assert float(intersection) / union > 0.95 n1 = count.num_label_issues( labels=data["labels"], pred_probs=data["pred_probs"], From 570ecbdcb81074a31a7b5a61997de7ae37b32c49 Mon Sep 17 00:00:00 2001 From: Anish Athalye Date: Sun, 19 Feb 2023 09:55:41 -0500 Subject: [PATCH 125/258] Switch to typing.Self (#489) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit PEP 673 [1] introduces `typing.Self` as a simple way to annotate methods that return an instance of their class. This patch adopts `typing.Self`. Because this is only included in Python 3.11, for backwards compatibility, this patch adds typing-extensions [2], an officially-supported module that is designed for enabling use of new type system features on older Python versions. We don't want to make typing-extensions a runtime dependency, so we add a guard and only import it when we're `TYPE_CHECKING`. [1]: https://peps.python.org/pep-0673/ [2]: https://pypi.org/project/typing-extensions/ Co-authored-by: Elías Snorrason --- cleanlab/classification.py | 12 ++++++------ requirements-dev.txt | 7 ++++--- 2 files changed, 10 insertions(+), 9 deletions(-) diff --git a/cleanlab/classification.py b/cleanlab/classification.py index 66126de932..c419ef5463 100644 --- a/cleanlab/classification.py +++ b/cleanlab/classification.py @@ -120,7 +120,10 @@ def score(self, X, y, sample_weight=None): import pandas as pd import inspect import warnings -from typing import TypeVar, Optional +from typing import Optional, TYPE_CHECKING + +if TYPE_CHECKING: # pragma: no cover + from typing_extensions import Self from cleanlab.rank import get_label_quality_scores from cleanlab import filter @@ -147,9 +150,6 @@ def score(self, X, y, sample_weight=None): ) -TCleanLearning = TypeVar("TCleanLearning", bound="CleanLearning") # self type for the class - - class CleanLearning(BaseEstimator): # Inherits sklearn classifier """ CleanLearning = Machine Learning with cleaned data (even when training on messy, error-ridden data). @@ -265,7 +265,7 @@ def __init__( self.clf_final_kwargs = None def fit( - self: TCleanLearning, + self, X, labels=None, *, @@ -279,7 +279,7 @@ def fit( clf_final_kwargs={}, validation_func=None, y=None, - ) -> TCleanLearning: + ) -> "Self": """ Train the model `clf` with error-prone, noisy labels as if the model had been instead trained on a dataset with the correct labels. diff --git a/requirements-dev.txt b/requirements-dev.txt index 1dc5dc705c..dd3d55e4fe 100644 --- a/requirements-dev.txt +++ b/requirements-dev.txt @@ -3,14 +3,15 @@ coverage != 6.3, != 6.3.* mypy pandas-stubs pre-commit +psutil pytest pytest-cov pytest-lazy-fixture requests scipy -torch -torchvision skorch tensorflow -psutil +torch +torchvision +typing-extensions>=4.1.1 wget From 1deb349e86f43a132d002108f990462bfd875cf1 Mon Sep 17 00:00:00 2001 From: Jonas Mueller <1390638+jwmueller@users.noreply.github.com> Date: Mon, 27 Feb 2023 15:38:47 -0800 Subject: [PATCH 126/258] list more tasks in quickstart (#640) --- docs/source/index.rst | 28 ++++++++++++++++++++-------- 1 file changed, 20 insertions(+), 8 deletions(-) diff --git a/docs/source/index.rst b/docs/source/index.rst index 76bebb5ace..79050a77e5 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -1,9 +1,9 @@ cleanlab documentation ====================== -`cleanlab `_ **automatically finds and fixes label issues in your ML datasets.** +`cleanlab `_ **automatically detects data and label issues in your ML datasets.** -| This reduces manual work needed to fix data errors and helps train reliable ML models on noisy real-world datasets. cleanlab has already found thousands of `label errors `_ in ImageNet, MNIST, and other popular ML benchmarking datasets, so let's get started with yours! +| This helps you improve your data and train reliable ML models on noisy real-world datasets. cleanlab has already found thousands of `label errors `_ in ImageNet, MNIST, and other popular ML benchmarking datasets. Beyond handling label errors, this is a comprehensive open-source library implementing many data-centric AI capabilities. Start using automation to improve your data in 5 minutes! Quickstart ========== @@ -35,7 +35,7 @@ Quickstart 2. Find label errors in your data --------------------------------- -cleanlab finds issues in *any dataset that a classifier can be trained on*. The cleanlab package *works with any model* by using model outputs (predicted probabilities) as input -- it doesn't depend on which model created those outputs. +cleanlab finds issues in *any dataset that a classifier can be trained on*. The cleanlab package *works with any ML model* by using model outputs (predicted probabilities) as input -- it doesn't depend on which model created those outputs. If you're using a scikit-learn-compatible model (option 1), you don't need to train a model -- you can pass the model, data, and labels into :py:meth:`CleanLearning.find_label_issues ` and cleanlab will handle model training for you. If you want to use any non-sklearn-compatible model (option 2), you can input the trained model's out-of-sample predicted probabilities into :py:meth:`find_label_issues `. Examples for both options are below. @@ -54,15 +54,15 @@ If you're using a scikit-learn-compatible model (option 1), you don't need to tr return_indices_ranked_by='self_confidence', ) -:py:class:`CleanLearning ` (option 1) also works with models from most standard ML frameworks by wrapping the model for scikit-learn compliance, e.g. huggingface/tensorflow/keras (using our KerasWrapperModel), pytorch (using skorch package), etc. +:py:class:`CleanLearning ` (option 1) also works with models from most standard ML frameworks by wrapping the model for scikit-learn compliance, e.g. :ref:`tensorflow/keras ` (using our KerasWrapperModel), :ref:`pytorch ` (using skorch package), etc. By default, :py:meth:`find_label_issues ` returns a boolean mask of label issues. You can instead return the indices of potential mislabeled examples by setting `return_indices_ranked_by` in :py:meth:`find_label_issues `. The indices are ordered by likelihood of a label error (estimated via :py:meth:`rank.get_label_quality_scores `). +Beyond standard classification tasks, cleanlab can also detect mislabeled examples in: :ref:`multi-label data ` (e.g. image/document tagging), :ref:`sequence prediction ` (e.g. entity recognition), and :ref:`data labeled by multiple annotators ` (e.g. crowdsourcing). + .. important:: Cleanlab performs better if the ``pred_probs`` from your model are **out-of-sample**. Details on how to compute out-of-sample predicted probabilities for your entire dataset are :ref:`here `. -.. - TODO - include the url for tf and torch beginner tutorials 3. Train robust models with noisy labels ---------------------------------------- @@ -86,9 +86,9 @@ When the :py:meth:`.fit() ` method is 4. Dataset curation: fix dataset-level issues --------------------------------------------- -cleanlab's :py:mod:`dataset ` module helps you deal with dataset-level issues by :ref:`finding overlapping classes ` (classes to merge), :ref:`rank class-level label quality ` (classes to keep/delete), and :ref:`measure overall dataset health ` (to track dataset quality as you make adjustments). +cleanlab's :ref:`dataset ` module helps you deal with dataset-level issues -- :py:meth:`find overlapping classes ` (classes to merge), :py:meth:`rank class-level label quality ` (classes to keep/delete), and :py:meth:`measure overall dataset health ` (to track dataset quality as you make adjustments). -The example below shows how to view all dataset-level issues in one line of code with :py:meth:`dataset.health_summary() `. Check out the dataset tutorial for more examples. +View all dataset-level issues in one line of code with :py:meth:`dataset.health_summary() `. .. code-block:: python @@ -97,6 +97,18 @@ The example below shows how to view all dataset-level issues in one line of code health_summary(labels, pred_probs, class_names=class_names) +5. Improve your data via many other techniques +---------------------------------------------- + +Beyond handling label errors, cleanlab supports other data-centric AI capabilities including: + +- Detecting outliers and out-of-distribution examples in both training and future test data :ref:`(tutorial) ` +- Analyzing data labeled by multiple annotators to estimate consensus labels and their quality :ref:`(tutorial) ` +- Active learning with multiple annotators to identify which data is most informative to label or re-label next `(tutorial) `_ + + +If you have questions, check out our :ref:`FAQ ` and feel free to ask in `Slack `_! + Contributing ------------ From 497947a867086bdeec80cb139c8c93f3c0b5b39d Mon Sep 17 00:00:00 2001 From: Hui Wen <45724323+huiwengoh@users.noreply.github.com> Date: Tue, 28 Feb 2023 12:15:19 -0500 Subject: [PATCH 127/258] Fix tutorial hyperlinks in docs (#642) --- DEVELOPMENT.md | 3 ++- docs/source/index.rst | 12 ++++++------ 2 files changed, 8 insertions(+), 7 deletions(-) diff --git a/DEVELOPMENT.md b/DEVELOPMENT.md index 6bc352cf3c..8b912a591f 100644 --- a/DEVELOPMENT.md +++ b/DEVELOPMENT.md @@ -213,7 +213,8 @@ Use relative linking to connect information between docs and jupyter notebooks, - Link another function from within a source code docstring: ``:py:func:`function_name ` `` - Link another class from within a source code docstring: ``:py:class:`class_name ` `` -- Link a tutorial notebook from within a source code docstring: ``:ref:`notebook_name ` `` +- Link a tutorial (rst file) from within a source code docstring or rst file: ``:ref:`tutorial_name ` `` +- Link a tutorial notebook (ipynb file) from within a source code docstring or rst file: `` `notebook_name `_ `` . (If the notebook is not the in the same folder as the source code, use a relative path) - Link a function from within a tutorial notebook: `[function_name](../cleanlab/file.rst#cleanlab.file.function_name)` - Link a specific section of a notebook from within the notebook: `[section title](#section-title)` - Link a different tutorial notebook from within a tutorial notebook: `[another notebook](another_notebook.html)`. (Note this only works when the other notebook is in same folder as this notebook, otherwise may need to try relative path) diff --git a/docs/source/index.rst b/docs/source/index.rst index 79050a77e5..a99ef826a8 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -54,11 +54,11 @@ If you're using a scikit-learn-compatible model (option 1), you don't need to tr return_indices_ranked_by='self_confidence', ) -:py:class:`CleanLearning ` (option 1) also works with models from most standard ML frameworks by wrapping the model for scikit-learn compliance, e.g. :ref:`tensorflow/keras ` (using our KerasWrapperModel), :ref:`pytorch ` (using skorch package), etc. +:py:class:`CleanLearning ` (option 1) also works with models from most standard ML frameworks by wrapping the model for scikit-learn compliance, e.g. `tensorflow/keras `_ (using our KerasWrapperModel), `pytorch `_ (using skorch package), etc. By default, :py:meth:`find_label_issues ` returns a boolean mask of label issues. You can instead return the indices of potential mislabeled examples by setting `return_indices_ranked_by` in :py:meth:`find_label_issues `. The indices are ordered by likelihood of a label error (estimated via :py:meth:`rank.get_label_quality_scores `). -Beyond standard classification tasks, cleanlab can also detect mislabeled examples in: :ref:`multi-label data ` (e.g. image/document tagging), :ref:`sequence prediction ` (e.g. entity recognition), and :ref:`data labeled by multiple annotators ` (e.g. crowdsourcing). +Beyond standard classification tasks, cleanlab can also detect mislabeled examples in: `multi-label data `_ (e.g. image/document tagging), `sequence prediction `_ (e.g. entity recognition), and `data labeled by multiple annotators `_ (e.g. crowdsourcing). .. important:: Cleanlab performs better if the ``pred_probs`` from your model are **out-of-sample**. Details on how to compute out-of-sample predicted probabilities for your entire dataset are :ref:`here `. @@ -86,7 +86,7 @@ When the :py:meth:`.fit() ` method is 4. Dataset curation: fix dataset-level issues --------------------------------------------- -cleanlab's :ref:`dataset ` module helps you deal with dataset-level issues -- :py:meth:`find overlapping classes ` (classes to merge), :py:meth:`rank class-level label quality ` (classes to keep/delete), and :py:meth:`measure overall dataset health ` (to track dataset quality as you make adjustments). +cleanlab's `dataset `_ module helps you deal with dataset-level issues -- :py:meth:`find overlapping classes ` (classes to merge), :py:meth:`rank class-level label quality ` (classes to keep/delete), and :py:meth:`measure overall dataset health ` (to track dataset quality as you make adjustments). View all dataset-level issues in one line of code with :py:meth:`dataset.health_summary() `. @@ -102,12 +102,12 @@ View all dataset-level issues in one line of code with :py:meth:`dataset.health_ Beyond handling label errors, cleanlab supports other data-centric AI capabilities including: -- Detecting outliers and out-of-distribution examples in both training and future test data :ref:`(tutorial) ` -- Analyzing data labeled by multiple annotators to estimate consensus labels and their quality :ref:`(tutorial) ` +- Detecting outliers and out-of-distribution examples in both training and future test data `(tutorial) `_ +- Analyzing data labeled by multiple annotators to estimate consensus labels and their quality `(tutorial) `_ - Active learning with multiple annotators to identify which data is most informative to label or re-label next `(tutorial) `_ -If you have questions, check out our :ref:`FAQ ` and feel free to ask in `Slack `_! +If you have questions, check out our `FAQ `_ and feel free to ask in `Slack `_! Contributing ------------ From dbc87116eaa4070a3dd8fa1000405e5e144f6a79 Mon Sep 17 00:00:00 2001 From: Hui Wen <45724323+huiwengoh@users.noreply.github.com> Date: Tue, 28 Feb 2023 19:06:17 -0500 Subject: [PATCH 128/258] Documentation improvements (#643) --- cleanlab/count.py | 30 +++++++++++-------- cleanlab/experimental/README.md | 2 +- cleanlab/experimental/label_issues_batched.py | 16 +++++----- cleanlab/models/fasttext.py | 21 +++++++++++-- cleanlab/models/keras.py | 4 +-- cleanlab/multiannotator.py | 11 ++++--- docs/source/cleanlab/experimental/index.rst | 4 +++ docs/source/cleanlab/models/index.rst | 5 ++++ .../cleanlab/token_classification/index.rst | 2 ++ 9 files changed, 65 insertions(+), 30 deletions(-) diff --git a/cleanlab/count.py b/cleanlab/count.py index de86abd9f6..cbfdb13f2e 100644 --- a/cleanlab/count.py +++ b/cleanlab/count.py @@ -91,19 +91,23 @@ def num_label_issues( estimation_method : Method for estimating the number of label issues in dataset by counting the examples in the off-diagonal of the `confident_joint` ``P(label=i, true_label=j)``. - - ``'off_diagonal'``: Counts the number of examples in the off-diagonal of the `confident_joint`. Returns the same value as ``sum(find_label_issues(filter_by='confident_learning'))`` - - ``'off_diagonal_calibrated'``: Calibrates confident joint estimate ``P(label=i, true_label=j)`` such that - ``np.sum(cj) == len(labels)`` and ``np.sum(cj, axis = 1) == np.bincount(labels)`` before counting the number - of examples in the off-diagonal. Number will always be equal to or greater than - ``estimate_issues='off_diagonal'``. You can use this value as the cutoff threshold used with ranking/scoring - functions from :py:mod:`cleanlab.rank` with `num_label_issues` over ``estimation_method='off_diagonal'`` in - two cases: - 1. As we add more label and data quality scoring functions in :py:mod:`cleanlab.rank`, this approach will always work. - 2. If you have a custom score to rank your data by label quality and you just need to know the cut-off of likely label issues. - - ``'off_diagonal_custom'``: Counts the number of examples in the off-diagonal of a provided `confident_joint` matrix. - - - TL;DR: Use this method to get the most accurate estimate of number of label issues when you don't need the indices of the label issues. + + * ``'off_diagonal'``: Counts the number of examples in the off-diagonal of the `confident_joint`. Returns the same value as ``sum(find_label_issues(filter_by='confident_learning'))`` + + * ``'off_diagonal_calibrated'``: Calibrates confident joint estimate ``P(label=i, true_label=j)`` such that + ``np.sum(cj) == len(labels)`` and ``np.sum(cj, axis = 1) == np.bincount(labels)`` before counting the number + of examples in the off-diagonal. Number will always be equal to or greater than + ``estimate_issues='off_diagonal'``. You can use this value as the cutoff threshold used with ranking/scoring + functions from :py:mod:`cleanlab.rank` with `num_label_issues` over ``estimation_method='off_diagonal'`` in + two cases: + + #. As we add more label and data quality scoring functions in :py:mod:`cleanlab.rank`, this approach will always work. + #. If you have a custom score to rank your data by label quality and you just need to know the cut-off of likely label issues. + + * ``'off_diagonal_custom'``: Counts the number of examples in the off-diagonal of a provided `confident_joint` matrix. + + TL;DR: Use this method to get the most accurate estimate of number of label issues when you don't need the indices of the label issues. + Note: ``'off_diagonal'`` may sometimes underestimate issues for data with few classes, so consider using ``'off_diagonal_calibrated'`` instead if your data has < 4 classes. multi_label : bool, optional diff --git a/cleanlab/experimental/README.md b/cleanlab/experimental/README.md index 91155f9801..3b24007b89 100644 --- a/cleanlab/experimental/README.md +++ b/cleanlab/experimental/README.md @@ -4,7 +4,7 @@ Methods in this `experimental` module are bleeding edge and may have sharp edges Some of these files include various models that can be used with cleanlab to find issues in specific types of data. These require dependencies on deep learning and other machine learning packages that are not official cleanlab dependencies. You must install these dependencies on your own if you wish to use them. -The dependencies are as follows: +The modules and required dependencies are as follows: * mnist_pytorch.py - a cleanlab-compatible simplified AlexNet for MNIST using PyTorch - torch - torchvision diff --git a/cleanlab/experimental/label_issues_batched.py b/cleanlab/experimental/label_issues_batched.py index 8fe52a9be6..d30df370dd 100644 --- a/cleanlab/experimental/label_issues_batched.py +++ b/cleanlab/experimental/label_issues_batched.py @@ -123,7 +123,7 @@ def find_label_issues_batched( Keyword arguments to pass into :py:func:`rank.get_label_quality_scores `. num_issue_kwargs : dict, optional - Keyword arguments to :py:func:`count.num_label_issues()` ` + Keyword arguments to :py:func:`count.num_label_issues ` to control estimation of the number of label issues. The only supported kwarg here for now is: `estimation_method`. @@ -305,7 +305,7 @@ class LabelInspector: Keyword arguments to pass into :py:func:`rank.get_label_quality_scores `. num_issue_kwargs : dict, optional - Keyword arguments to :py:func:`count.num_label_issues()` ` + Keyword arguments to :py:func:`count.num_label_issues ` to control estimation of the number of label issues. The only supported kwarg here for now is: `estimation_method`. """ @@ -407,7 +407,7 @@ def get_num_issues(self, silent: bool = False) -> int: Returns ------- - num_issues : + num_issues : int The estimated number of examples with label issues in the data seen so far. """ if self.examples_processed_quality < 1: @@ -455,7 +455,7 @@ def get_label_issues(self) -> np.ndarray: in the same format as: :py:func:`filter.find_label_issues ` with its `return_indices_ranked_by` argument specified. - Note: this method corresponds to ``filter.find_label_issues(..., filter_by=METHOD1, return_indices_ranked_by=METHOD2) + Note: this method corresponds to ``filter.find_label_issues(..., filter_by=METHOD1, return_indices_ranked_by=METHOD2)`` where by default: ``METHOD1="low_self_confidence"``, ``METHOD2="self_confidence"`` or if this object was instantiated with ``quality_score_kwargs = {"method": "normalized_margin"}`` then we instead have: ``METHOD1="low_normalized_margin"``, ``METHOD2="normalized_margin"``. @@ -522,7 +522,7 @@ def score_label_quality( """ Scores the label quality of each example in the provided batch of data, and also updates the number of label issues stored in this class. - Inputs should be in same format as for: :py:func:`rank.get_label_quality_scores `.. + Inputs should be in same format as for: :py:func:`rank.get_label_quality_scores `. Parameters ---------- @@ -662,14 +662,14 @@ def _update_num_label_issues( def split_arr(arr: np.ndarray, chunksize: int) -> List[np.ndarray]: """ - Helper function to split array into chunks for multiprocessing + Helper function to split array into chunks for multiprocessing. """ return np.split(arr, np.arange(chunksize, arr.shape[0], chunksize), axis=0) def _compute_num_issues(arg: Tuple[np.ndarray, bool]) -> int: """ - Helper function for `_update_num_label_issues` multiprocessing without calibration + Helper function for `_update_num_label_issues` multiprocessing without calibration. """ ind = arg[0] thorough = arg[1] @@ -698,7 +698,7 @@ def _compute_num_issues(arg: Tuple[np.ndarray, bool]) -> int: def _compute_num_issues_calibrated(arg: Tuple[np.ndarray, bool]) -> Tuple[Any, int, int]: """ - Helper function for `_update_num_label_issues` multiprocessing with calibration + Helper function for `_update_num_label_issues` multiprocessing with calibration. """ ind = arg[0] thorough = arg[1] diff --git a/cleanlab/models/fasttext.py b/cleanlab/models/fasttext.py index 1da6d766ad..3b2cd66259 100644 --- a/cleanlab/models/fasttext.py +++ b/cleanlab/models/fasttext.py @@ -15,10 +15,16 @@ # along with cleanlab. If not, see . """ -Text classification with FastText models that are compatible with cleanlab. +Text classification with fastText models that are compatible with cleanlab. This module allows you to easily find label issues in your text datasets. -You must first ``pip install fasttext`` +You must have fastText installed: ``pip install fasttext``. + +Tips: + +* Check out our example using this class: `fasttext_amazon_reviews `_ +* Our `unit tests `_ also provide basic usage examples. + """ import time @@ -96,6 +102,17 @@ def _split_labels_and_text(batch): class FastTextClassifier(BaseEstimator): # Inherits sklearn base classifier + """Instantiate a fastText classifier that is compatible with :py:class:`CleanLearning `. + + Parameters + ---------- + train_data_fn: str + File name of the training data in the format compatible with fastText. + + test_data_fn: str, optional + File name of the test data in the format compatible with fastText. + """ + def __init__( self, train_data_fn, diff --git a/cleanlab/models/keras.py b/cleanlab/models/keras.py index 5935cd5ef9..c297c6efd8 100644 --- a/cleanlab/models/keras.py +++ b/cleanlab/models/keras.py @@ -30,7 +30,7 @@ * If this class lacks certain functionality, you can alternatively try `scikeras `_. * Unlike scikeras, our `KerasWrapper` classes can operate directly on ``tensorflow.data.Dataset`` objects (like regular Keras models). * To call ``fit()`` on a tensorflow ``Dataset`` object with a Keras model, the ``Dataset`` should already be batched. -* Check out our `example `_ using this class: `huggingface_keras_imdb `_ +* Check out our example using this class: `huggingface_keras_imdb `_ * Our `unit tests `_ also provide basic usage examples. """ @@ -51,7 +51,7 @@ class KerasWrapperModel: Parameters ---------- model: Callable - A callable function to construct the Keras Model (using functional API). Pass in the function here, not the constructed model! + A callable function to construct the Keras Model (using functional API). Pass in the function here, not the constructed model! For example:: diff --git a/cleanlab/multiannotator.py b/cleanlab/multiannotator.py index 682142bff7..7b9f984de8 100644 --- a/cleanlab/multiannotator.py +++ b/cleanlab/multiannotator.py @@ -31,8 +31,9 @@ use the :py:func:`get_active_learning_scores ` function, which is intended for active learning. This function estimates an active learning quality score for each example, which can be used to prioritize which examples are most informative to collect additional labels for. -This function is effective for settings where some examples have been labeled by one or more annotators and other examples can have no labels at all so far, -as well as settings where new labels are collected either in batches of examples or one at a time. +This function is effective for settings where some examples have been labeled by one or more annotators and other examples can have no labels at all so far, +as well as settings where new labels are collected either in batches of examples or one at a time. +Here is an `example notebook `_ showcasing the use of this function in multiple active learning rounds. Each of the main functions in this module utilizes any trained classifier model. Variants of these functions are provided for settings where you have trained an ensemble of multiple models. @@ -540,7 +541,7 @@ def get_active_learning_scores( ) -> Tuple[np.ndarray, np.ndarray]: """Returns an active learning quality score for each example in the dataset. - We consider settings where one example can be labeled by multiple annotators and some examples have no labels at all so far. + We consider settings where one example can be labeled by one or more annotators and some examples have no labels at all so far. The score is in between 0 and 1, and can be used to prioritize what data to collect additional labels for. Lower scores indicate examples whose true label we are least confident about based on the current data; @@ -555,7 +556,8 @@ def get_active_learning_scores( ---------- labels_multiannotator : pd.DataFrame of np.ndarray 2D pandas DataFrame or array of multiple given labels for each example with shape ``(N, M)``, - where N is the number of examples and M is the number of annotators. + where N is the number of examples and M is the number of annotators. Note that this function also works with + datasets where there is only one annotator (M=1). For more details, labels in the same format expected by the :py:func:`get_label_quality_multiannotator `. Note that examples that have no annotator labels should not be included in this DataFrame/array. pred_probs : np.ndarray @@ -672,6 +674,7 @@ def get_active_learning_scores_ensemble( Multiannotator labels in the same format expected by :py:func:`get_active_learning_scores `. pred_probs : np.ndarray An array of shape ``(P, N, K)`` where P is the number of models, consisting of predicted class probabilities from the ensemble models. + Note that this function also works with datasets where there is only one annotator (M=1). Each set of predicted probabilities with shape ``(N, K)`` is in the same format expected by the :py:func:`get_label_quality_scores `. pred_probs_unlabeled : np.ndarray, optional An array of shape ``(P, N, K)`` where P is the number of models, consisting of predicted class probabilities from a trained classifier model diff --git a/docs/source/cleanlab/experimental/index.rst b/docs/source/cleanlab/experimental/index.rst index 35af09b504..798be77934 100644 --- a/docs/source/cleanlab/experimental/index.rst +++ b/docs/source/cleanlab/experimental/index.rst @@ -4,6 +4,10 @@ experimental .. warning:: Methods in this ``experimental`` module are bleeding edge and may have sharp edges. They are not guaranteed to be stable between different ``cleanlab`` versions. +Useful methods/models adapted for use with cleanlab. + +Some of these files include various models that can be used with cleanlab to find issues in specific types of data. These require dependencies on deep learning and other machine learning packages that are not official cleanlab dependencies. You must install these dependencies on your own if you wish to use them. + .. automodule:: cleanlab.experimental :autosummary: :members: diff --git a/docs/source/cleanlab/models/index.rst b/docs/source/cleanlab/models/index.rst index d095a7b18f..8c34d0e267 100644 --- a/docs/source/cleanlab/models/index.rst +++ b/docs/source/cleanlab/models/index.rst @@ -4,6 +4,11 @@ models .. warning:: Methods in this ``models`` module are not guaranteed to be stable between different ``cleanlab`` versions. +Useful models adapted for use with cleanlab. + +Some of these files include various models that can be used with cleanlab to find issues in specific types of data. These require dependencies on deep learning and other machine learning packages that are not official cleanlab dependencies. You must install these dependencies on your own if you wish to use them. + + .. automodule:: cleanlab.models :autosummary: :members: diff --git a/docs/source/cleanlab/token_classification/index.rst b/docs/source/cleanlab/token_classification/index.rst index 1681cfa2f6..69ea1dfcde 100644 --- a/docs/source/cleanlab/token_classification/index.rst +++ b/docs/source/cleanlab/token_classification/index.rst @@ -1,6 +1,8 @@ token_classification ==================== +Methods to detect data and label issues in token classification datasets. + .. automodule:: cleanlab.token_classification :autosummary: :members: From 38e1dab34de89757f918d01db513f8bcaa08574e Mon Sep 17 00:00:00 2001 From: Jonas Mueller <1390638+jwmueller@users.noreply.github.com> Date: Wed, 1 Mar 2023 00:39:35 -0800 Subject: [PATCH 129/258] bump version number --- cleanlab/version.py | 21 +++++++++++++-------- 1 file changed, 13 insertions(+), 8 deletions(-) diff --git a/cleanlab/version.py b/cleanlab/version.py index 14c5fc056f..831688b145 100644 --- a/cleanlab/version.py +++ b/cleanlab/version.py @@ -15,9 +15,20 @@ # along with cleanlab. If not, see . -__version__ = "2.2.1" +__version__ = "2.3.0" -# 2.2.1 - Not yet released, you are using developer version. See documentation at: https://docs.cleanlab.ai/master/ +# 2.3.0 - Extending cleanlab beyond label errors into a complete library for data-centric AI +# +# Major new functionalities include: +# - Active learning with data re-labeling (ActiveLab) +# - KerasWrapperModel and KerasSequentialWrapper to make arbitrary Keras models compatible with scikit-learn +# - Computational improvements for detecting label issues (better efficiency and mini-batch estimation that works with lower memory) +# +# See release for a full changelog. + +# ------------------------------------------ +# | PREVIOUS VERSION RELEASE NOTES SUMMARY | +# ------------------------------------------ # 2.2.0 - Re-invented algorithms for multi-label classification and support for datasets with missing classes # @@ -30,12 +41,6 @@ # - cleanlab now works much better for datasets in which some classes happen to not be present. # - Algorithmic improvements to ensure count.num_label_issues() returns more accurate estimates. # - For developers: introduction of flake8 code linter and more comprehensive mypy type annotations. -# -# See release for a full changelog. - -# ------------------------------------------ -# | PREVIOUS VERSION RELEASE NOTES SUMMARY | -# ------------------------------------------ # 2.1.0 - "Multiannotator, Outlier detection, and Token Classification" - Cleanlab supports several new features # From b8c034f34f95fa473ee44fb5c0f52d5e8e262b5c Mon Sep 17 00:00:00 2001 From: Jonas Mueller <1390638+jwmueller@users.noreply.github.com> Date: Wed, 1 Mar 2023 01:02:29 -0800 Subject: [PATCH 130/258] add 2.3.0 to release versions (#644) --- docs/source/conf.py | 1 + 1 file changed, 1 insertion(+) diff --git a/docs/source/conf.py b/docs/source/conf.py index 3dc11aade2..2665fc5a31 100644 --- a/docs/source/conf.py +++ b/docs/source/conf.py @@ -147,6 +147,7 @@ # Add new tags to RELEASE_VERSIONS before release # fmt: off "RELEASE_VERSIONS": [ + "v2.3.0", "v2.2.0", "v2.1.0", "v2.0.0", From 4606fecfd47433b850d30768e20e19bc207c845e Mon Sep 17 00:00:00 2001 From: Jonas Mueller <1390638+jwmueller@users.noreply.github.com> Date: Wed, 1 Mar 2023 15:35:53 -0800 Subject: [PATCH 131/258] update readme links to point to latest docs (#645) --- README.md | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/README.md b/README.md index 1fc52ef554..706c32d1a4 100644 --- a/README.md +++ b/README.md @@ -45,7 +45,7 @@ Get started with: [documentation](https://docs.cleanlab.ai/), [tutorials](https:
  • Sep 2022 📖 cleanlab 2.1.0 released! Added support for: data labeled by multiple annotators in cleanlab.multiannotator, token classification with text data in cleanlab.token_classification, out-of-distribution detection in cleanlab.outlier, and CleanLearning with non-numpy-array data (e.g. pandas dataframes, tensorflow/pytorch datasets, etc) in cleanlab.classification.CleanLearning.
  • April 2022 📖 cleanlab 2.0.0 released! Lays foundations for this library to grow into a general-purpose data-centric AI toolkit.
  • March 2022 📖 Documentation migrated to new website: docs.cleanlab.ai with quickstart tutorials for image/text/audio/tabular data.
    • -
  • Feb 2022 💻 APIs simplified to make cleanlab accessible for everybody, not just ML researchers
    • +
  • Feb 2022 💻 APIs simplified to make cleanlab accessible for everybody, not just ML researchers
  • Long-time cleanlab user? Here's how to migrate to cleanlab versions >= 2.0.0.

    • @@ -65,9 +65,9 @@ Get started with: [documentation](https://docs.cleanlab.ai/), [tutorials](https:

    • Dec 2020 🎉 cleanlab supports NeurIPS workshop paper (Northcutt, Athalye, & Lin, 2020).
      • -
    • Dec 2020 🤖 cleanlab supports PU learning.
      • +
    • Dec 2020 🤖 cleanlab supports Positive-Unlabeled (PU) learning.
    • Feb 2020 🤖 cleanlab now natively supports Mac, Linux, and Windows.
      • -
    • Feb 2020 🤖 cleanlab now supports Co-Teaching (Han et al., 2018).
      • +
    • Feb 2020 🤖 cleanlab now supports Co-Teaching (Han et al., 2018).
    • Jan 2020 🎉 cleanlab achieves state-of-the-art on CIFAR-10 with noisy labels. Code to reproduce: examples/cifar10. This is a great place to see how to use cleanlab on real datasets (with predicted probabilities from trained model already precomputed for you).

    @@ -151,7 +151,7 @@ cl.predict(test_data) More details are provided in documentation of [cleanlab.classification.CleanLearning](https://docs.cleanlab.ai/stable/cleanlab/classification.html). -Note, some libraries exist to give you sklearn-compatibility for free. For PyTorch, check out the [skorch](https://skorch.readthedocs.io/) Python library which will wrap your PyTorch model into a sklearn-compatible model ([example](https://docs.cleanlab.ai/stable/tutorials/image.html)). For TensorFlow/Keras, check out [SciKeras](https://www.adriangb.com/scikeras/) ([example](https://docs.cleanlab.ai/stable/tutorials/text.html)) or [our own Keras wrapper](https://docs.cleanlab.ai/stable/cleanlab/experimental/keras.html). Many libraries also already offer a special scikit-learn API, for example: [XGBoost](https://xgboost.readthedocs.io/en/stable/python/python_api.html#module-xgboost.sklearn) or [LightGBM](https://lightgbm.readthedocs.io/en/latest/pythonapi/lightgbm.LGBMClassifier.html). +Note, some libraries exist to give you sklearn-compatibility for free. For PyTorch, check out the [skorch](https://skorch.readthedocs.io/) Python library which will wrap your PyTorch model into a sklearn-compatible model ([example](https://docs.cleanlab.ai/stable/tutorials/image.html)). For TensorFlow/Keras, check out our [Keras wrapper](https://docs.cleanlab.ai/stable/cleanlab/models/keras.html). Many libraries also already offer a special scikit-learn API, for example: [XGBoost](https://xgboost.readthedocs.io/en/stable/python/python_api.html#module-xgboost.sklearn) or [LightGBM](https://lightgbm.readthedocs.io/en/latest/pythonapi/lightgbm.LGBMClassifier.html).
    @@ -217,7 +217,7 @@ cleanlab is a general tool that can learn with noisy labels regardless of datase ![](https://raw.githubusercontent.com/cleanlab/assets/master/cleanlab/demo_cleanlab_across_datasets_and_classifiers.png) -Each sub-figure above depicts the decision boundary learned using [cleanlab.classification.CleanLearning](https://github.com/cleanlab/cleanlab/blob/master/cleanlab/classification.py#L141) in the presence of extreme (\~35%) label errors (circled in green). Label noise is class-conditional (not uniformly random). Columns are organized by the classifier used, except the left-most column which depicts the ground-truth data distribution. Rows are organized by dataset. +Each sub-figure above depicts the decision boundary learned using [cleanlab.classification.CleanLearning](https://docs.cleanlab.ai/stable/cleanlab/classification.html) in the presence of extreme (\~35%) label errors (circled in green). Label noise is class-conditional (not uniformly random). Columns are organized by the classifier used, except the left-most column which depicts the ground-truth data distribution. Rows are organized by dataset. Each sub-figure depicts accuracy scores on a test set (with correct non-noisy labels) as decimal values: @@ -289,12 +289,12 @@ cleanlab for advanced users
    -Many methods and their default parameters are not covered here. Check out the [documentation for the master branch version](https://docs.cleanlab.ai/master/) for the full suite of features supported by the cleanlab API. +Many methods and their default parameters are not covered here. Check out the [documentation for the developer version (aka master branch)](https://docs.cleanlab.ai/master/) for the full suite of features supported by the cleanlab API. ## Use any custom model's predicted probabilities to find label errors in 1 line of code pred_probs (num_examples x num_classes matrix of predicted probabilities) should already be computed on your own, with any classifier. For best results, pred_probs should be obtained in a holdout/out-of-sample manner (e.g. via cross-validation). -* cleanlab can do this for you via [`cleanlab.count.estimate_cv_predicted_probabilities`](https://docs.cleanlab.ai/master/cleanlab/count.html)] +* cleanlab can do this for you via [`cleanlab.count.estimate_cv_predicted_probabilities`](https://docs.cleanlab.ai/stable/cleanlab/count.html)] * Tutorial with more info: [[here](https://docs.cleanlab.ai/stable/tutorials/pred_probs_cross_val.html)] * Examples how to compute pred_probs with: [[CNN image classifier (PyTorch)](https://docs.cleanlab.ai/stable/tutorials/image.html)], [[NN text classifier (TensorFlow)](https://docs.cleanlab.ai/stable/tutorials/text.html)] @@ -387,11 +387,11 @@ Positive-Unlabeled Learning
    -Positive-Unlabeled (PU) learning (in which your data only contains a few positively labeled examples with the rest unlabeled) is just a special case of [CleanLearning](https://github.com/cleanlab/cleanlab/blob/master/cleanlab/classification.py#L141) when one of the classes has no error. `P` stands for the positive class and **is assumed to have zero label errors** and `U` stands for unlabeled data, but in practice, we just assume the `U` class is a noisy negative class that actually contains some positive examples. Thus, the goal of PU learning is to (1) estimate the proportion of negatively labeled examples that actually belong to the positive class (see`fraction\_noise\_in\_unlabeled\_class` in the last example), (2) find the errors (see last example), and (3) train on clean data (see first example below). cleanlab does all three, taking into account that there are no label errors in whichever class you specify as positive. +Positive-Unlabeled (PU) learning (in which your data only contains a few positively labeled examples with the rest unlabeled) is just a special case of [CleanLearning](https://docs.cleanlab.ai/stable/cleanlab/classification.html) when one of the classes has no error. `P` stands for the positive class and **is assumed to have zero label errors** and `U` stands for unlabeled data, but in practice, we just assume the `U` class is a noisy negative class that actually contains some positive examples. Thus, the goal of PU learning is to (1) estimate the proportion of negatively labeled examples that actually belong to the positive class (see`fraction\_noise\_in\_unlabeled\_class` in the last example), (2) find the errors (see last example), and (3) train on clean data (see first example below). cleanlab does all three, taking into account that there are no label errors in whichever class you specify as positive. There are two ways to use cleanlab for PU learning. We'll look at each here. -Method 1. If you are using the cleanlab classifier [CleanLearning()](https://github.com/cleanlab/cleanlab/blob/master/cleanlab/classification.py#L141), and your dataset has exactly two classes (positive = 1, and negative = 0), PU +Method 1. If you are using the cleanlab classifier [CleanLearning()](https://docs.cleanlab.ai/stable/cleanlab/classification.html), and your dataset has exactly two classes (positive = 1, and negative = 0), PU learning is supported directly in cleanlab. You can perform PU learning like this: ``` python @@ -405,7 +405,7 @@ cl.fit(X=X_train_data, labels=train_noisy_labels) predicted_test_labels = cl.predict(X_test) ``` -Method 2. However, you might be using a more complicated classifier that doesn't work well with [CleanLearning](https://github.com/cleanlab/cleanlab/blob/master/cleanlab/classification.py#L141) (see this example for CIFAR-10). Or you might have 3 or more classes. Here's how to use cleanlab for PU learning in this situation. To let cleanlab know which class has no error (in standard PU learning, this is the P class), you need to set the threshold for that class to 1 (1 means the probability that the labels of that class are correct is 1, i.e. that class has no +Method 2. However, you might be using a more complicated classifier that doesn't work well with [CleanLearning](https://docs.cleanlab.ai/stable/cleanlab/classification.html) (see this example for CIFAR-10). Or you might have 3 or more classes. Here's how to use cleanlab for PU learning in this situation. To let cleanlab know which class has no error (in standard PU learning, this is the P class), you need to set the threshold for that class to 1 (1 means the probability that the labels of that class are correct is 1, i.e. that class has no error). Here's the code: ``` python From b1bfdecf45d9945d8980edbaa94532f4f95a2813 Mon Sep 17 00:00:00 2001 From: Jonas Mueller <1390638+jwmueller@users.noreply.github.com> Date: Thu, 9 Mar 2023 23:33:10 -0800 Subject: [PATCH 132/258] resize readme image (#650) --- README.md | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index 706c32d1a4..169c43dfd5 100644 --- a/README.md +++ b/README.md @@ -1,4 +1,7 @@ -![](https://raw.githubusercontent.com/cleanlab/assets/master/cleanlab/cleanlab_logo_open_source_transparent_optimized_size.png) +

    + +

    + cleanlab automatically detects problems in a ML dataset. This data-centric AI package facilitates **machine learning with messy, real-world data** by providing **clean lab**els for robust training and flagging errors in your data. From 2a16c473fc2d01bbbca565f4f4acdd52312e80a7 Mon Sep 17 00:00:00 2001 From: Jonas Mueller <1390638+jwmueller@users.noreply.github.com> Date: Sun, 12 Mar 2023 20:23:37 -0700 Subject: [PATCH 133/258] post v2.3.0 release version bump (#646) --- cleanlab/version.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/cleanlab/version.py b/cleanlab/version.py index 831688b145..c3ec42f9af 100644 --- a/cleanlab/version.py +++ b/cleanlab/version.py @@ -15,7 +15,9 @@ # along with cleanlab. If not, see . -__version__ = "2.3.0" +__version__ = "2.3.1" + +# 2.3.1 - Not yet released, you are using bleeding-edge developer version. See its documentation at: https://docs.cleanlab.ai/master/ # 2.3.0 - Extending cleanlab beyond label errors into a complete library for data-centric AI # From 44081c6538360f72e8c2acdb3a8fc5c4ba7d6cda Mon Sep 17 00:00:00 2001 From: Jonas Mueller <1390638+jwmueller@users.noreply.github.com> Date: Sun, 12 Mar 2023 20:26:04 -0700 Subject: [PATCH 134/258] add activelab name to docs (#648) Co-authored-by: huiwengoh <45724323+huiwengoh@users.noreply.github.com> --- cleanlab/multiannotator.py | 24 ++++++++++++---------- docs/source/tutorials/multiannotator.ipynb | 2 +- 2 files changed, 14 insertions(+), 12 deletions(-) diff --git a/cleanlab/multiannotator.py b/cleanlab/multiannotator.py index 7b9f984de8..0b0dfb02d1 100644 --- a/cleanlab/multiannotator.py +++ b/cleanlab/multiannotator.py @@ -25,15 +25,17 @@ * An analogous label quality score for each individual label chosen by one annotator for a particular example. * An overall quality score for each annotator which measures our confidence in the overall correctness of labels obtained from this annotator. -The underlying algorithms used to compute the statistics are described in `the CROWDLAB paper `_. +The algorithms to compute these estimates are described in `the CROWDLAB paper `_. If you have some labeled and unlabeled data (with multiple annotators for some labeled examples) and want to decide what data to collect additional labels for, use the :py:func:`get_active_learning_scores ` function, which is intended for active learning. -This function estimates an active learning quality score for each example, +This function estimates an ActiveLab quality score for each example, which can be used to prioritize which examples are most informative to collect additional labels for. This function is effective for settings where some examples have been labeled by one or more annotators and other examples can have no labels at all so far, as well as settings where new labels are collected either in batches of examples or one at a time. -Here is an `example notebook `_ showcasing the use of this function in multiple active learning rounds. +Here is an `example notebook `_ showcasing the use of this ActiveLab method for active learning with data re-labeling. + +The algorithms to compute these active learning scores are described in `the ActiveLab paper `_. Each of the main functions in this module utilizes any trained classifier model. Variants of these functions are provided for settings where you have trained an ensemble of multiple models. @@ -69,7 +71,7 @@ def get_label_quality_multiannotator( verbose: bool = True, label_quality_score_kwargs: dict = {}, ) -> Dict[str, Any]: - """Returns label quality scores for each example and for each annotator. + """Returns label quality scores for each example and for each annotator in a dataset labeled by multiple annotators. This function is for multiclass classification datasets where examples have been labeled by multiple annotators (not necessarily the same number of annotators per example). @@ -77,10 +79,10 @@ def get_label_quality_multiannotator( It computes one consensus label for each example that best accounts for the labels chosen by each annotator (and their quality), as well as a consensus quality score for how confident we are that this consensus label is actually correct. It also computes similar quality scores for each annotator's individual labels, and the quality of each annotator. - Scores are between 0 and 1; lower scores indicate labels/annotators less likely to be correct. + Scores are between 0 and 1 (estimated via methods like CROWDLAB); lower scores indicate labels/annotators less likely to be correct. To decide what data to collect additional labels for, try the :py:func:`get_active_learning_scores ` - function, which is intended for active learning with multiple annotators. + (ActiveLab) function, which is intended for active learning with multiple annotators. Parameters ---------- @@ -539,7 +541,7 @@ def get_active_learning_scores( pred_probs: np.ndarray, pred_probs_unlabeled: Optional[np.ndarray] = None, ) -> Tuple[np.ndarray, np.ndarray]: - """Returns an active learning quality score for each example in the dataset. + """Returns an ActiveLab quality score for each example in the dataset, to estimate which examples are most informative to (re)label next in active learning. We consider settings where one example can be labeled by one or more annotators and some examples have no labels at all so far. @@ -550,7 +552,7 @@ def get_active_learning_scores( and repeat this process after retraining your classifier. To analyze a fixed dataset labeled by multiple annotators rather than collecting additional labels, try the - :py:func:`get_label_quality_multiannotator ` function instead. + :py:func:`get_label_quality_multiannotator ` (CROWDLAB) function instead. Parameters ---------- @@ -570,7 +572,7 @@ def get_active_learning_scores( Returns ------- active_learning_scores : np.ndarray - Array of shape ``(N,)`` indicating the active learning quality scores for each example. + Array of shape ``(N,)`` indicating the ActiveLab quality scores for each example. Examples with the lowest scores are those we should label next in order to maximally improve our classifier model. active_learning_scores_unlabeled : np.ndarray @@ -663,10 +665,10 @@ def get_active_learning_scores_ensemble( pred_probs: np.ndarray, pred_probs_unlabeled: Optional[np.ndarray] = None, ) -> Tuple[np.ndarray, np.ndarray]: - """Returns an active learning quality score for each example in the dataset, based on predictions from an ensemble of models. + """Returns an ActiveLab quality score for each example in the dataset, based on predictions from an ensemble of models. This function is similar to :py:func:`get_active_learning_scores ` but allows for an - ensemble of multiple classifier models to be trained and will aggregate predictions from the models to compute the active learning quality score. + ensemble of multiple classifier models to be trained and will aggregate predictions from the models to compute the ActiveLab quality score. Parameters ---------- diff --git a/docs/source/tutorials/multiannotator.ipynb b/docs/source/tutorials/multiannotator.ipynb index 617551272b..b22a2d97c9 100644 --- a/docs/source/tutorials/multiannotator.ipynb +++ b/docs/source/tutorials/multiannotator.ipynb @@ -710,7 +710,7 @@ "You can also repeatedly iterate this process of getting better consensus labels using the model's out-of-sample predicted probabilities and then retraining the model with the improved labels to get even better predicted probabilities!\n", "For details, see our [examples](https://github.com/cleanlab/examples) notebook on [Iterative use of Cleanlab to Improve Classification Models (and Consensus Labels) from Data Labeled by Multiple Annotators](https://github.com/cleanlab/examples/blob/master/multiannotator_cifar10/multiannotator_cifar10.ipynb).\n", "\n", - "If possible, the best way to improve your model is to collect additional labels for both previously annotated data and extra not-yet-labeled examples. To decide which data is most informative to label next, use `cleanlab.multiannotator.get_active_learning_scores()` rather than the methods shown here. This is demonstrated in our [examples](https://github.com/cleanlab/examples) notebook on [Active Learning with Multiple Data Annotators](https://github.com/cleanlab/examples/blob/master/active_learning_multiannotator/active_learning.ipynb).\n", + "If possible, the best way to improve your model is to collect additional labels for both previously annotated data and extra not-yet-labeled examples (i.e. *active learning*). To decide which data is most informative to label next, use `cleanlab.multiannotator.get_active_learning_scores()` rather than the methods from this tutorial. This is demonstrated in our examples notebook on [Active Learning with Multiple Data Annotators via ActiveLab](https://github.com/cleanlab/examples/blob/master/active_learning_multiannotator/active_learning.ipynb).\n", "\n", "\n", "## How does cleanlab.multiannotator work?\n", From 70a2ed2fa2ac137af8d2522eea8796336d74c17b Mon Sep 17 00:00:00 2001 From: Ulyana Date: Sun, 12 Mar 2023 20:51:03 -0700 Subject: [PATCH 135/258] Add clipping of small probabilities to address issue #639 (#647) Co-authored-by: Jonas Mueller <1390638+jwmueller@users.noreply.github.com> --- cleanlab/benchmarking/noise_generation.py | 13 +++++------ cleanlab/count.py | 8 +++++-- cleanlab/experimental/label_issues_batched.py | 16 +++++++++---- cleanlab/internal/constants.py | 23 +++++++++++++++++++ cleanlab/internal/label_quality_utils.py | 5 +++- cleanlab/internal/latent_algebra.py | 9 ++++---- cleanlab/internal/util.py | 6 ++--- cleanlab/internal/validation.py | 5 +++- cleanlab/multiannotator.py | 22 ++++++++++-------- cleanlab/rank.py | 13 ++++++----- 10 files changed, 80 insertions(+), 40 deletions(-) create mode 100644 cleanlab/internal/constants.py diff --git a/cleanlab/benchmarking/noise_generation.py b/cleanlab/benchmarking/noise_generation.py index 4c71b57264..63c1352bbb 100644 --- a/cleanlab/benchmarking/noise_generation.py +++ b/cleanlab/benchmarking/noise_generation.py @@ -26,6 +26,7 @@ import numpy as np from cleanlab.internal.util import value_counts +from cleanlab.internal.constants import FLOATING_POINT_COMPARISON def noise_matrix_is_valid(noise_matrix, py, *, verbose=False) -> bool: @@ -65,7 +66,7 @@ def noise_matrix_is_valid(noise_matrix, py, *, verbose=False) -> bool: joint_noise = np.multiply(noise_matrix, py) # / float(N) # Check that joint_probs is valid probability matrix - if not (abs(joint_noise.sum() - 1.0) < 1e-6): + if not (abs(joint_noise.sum() - 1.0) < FLOATING_POINT_COMPARISON): return False # Check that noise_matrix is a valid matrix @@ -386,11 +387,9 @@ def generate_n_rand_probabilities_that_sum_to_m( An array of probabilities. """ - epsilon = 1e-6 # Imprecision allowed for inequalities with floats - if n == 0: return np.array([]) - if (max_prob + epsilon) < m / float(n): + if (max_prob + FLOATING_POINT_COMPARISON) < m / float(n): raise ValueError( "max_prob must be greater or equal to m / n, but " + "max_prob = " @@ -402,7 +401,7 @@ def generate_n_rand_probabilities_that_sum_to_m( + ", m / n = " + str(m / float(n)) ) - if min_prob > (m + epsilon) / float(n): + if min_prob > (m + FLOATING_POINT_COMPARISON) / float(n): raise ValueError( "min_prob must be less or equal to m / n, but " + "max_prob = " @@ -422,7 +421,7 @@ def generate_n_rand_probabilities_that_sum_to_m( min_val = min(result) max_val = max(result) - while max_val > (max_prob + epsilon): + while max_val > (max_prob + FLOATING_POINT_COMPARISON): new_min = min_val + (max_val - max_prob) # This adjustment prevents the new max from always being max_prob. adjustment = (max_prob - new_min) * np.random.rand() @@ -433,7 +432,7 @@ def generate_n_rand_probabilities_that_sum_to_m( min_val = min(result) max_val = max(result) - while min_val < (min_prob - epsilon): + while min_val < (min_prob - FLOATING_POINT_COMPARISON): min_val = min(result) max_val = max(result) new_max = max_val - (min_prob - min_val) diff --git a/cleanlab/count.py b/cleanlab/count.py index cbfdb13f2e..c47590773e 100644 --- a/cleanlab/count.py +++ b/cleanlab/count.py @@ -38,6 +38,8 @@ from cleanlab.typing import LabelLike from cleanlab.internal.multilabel_utils import stack_complement, get_onehot_num_classes +from cleanlab.internal.constants import TINY_VALUE, CONFIDENT_THRESHOLDS_LOWER_BOUND + from cleanlab.internal.util import ( value_counts_fill_missing_classes, clip_values, @@ -49,7 +51,6 @@ get_unique_classes, is_torch_dataset, is_tensorflow_dataset, - TINY_VALUE, ) from cleanlab.internal.latent_algebra import ( compute_inv_noise_matrix, @@ -1449,7 +1450,10 @@ def get_confident_thresholds( np.mean(pred_probs[:, k][labels == k]) if k in unique_classes else BIG_VALUE for k in all_classes ] - return np.array(confident_thresholds) + confident_thresholds = np.clip( + confident_thresholds, a_min=CONFIDENT_THRESHOLDS_LOWER_BOUND, a_max=None + ) + return confident_thresholds def _get_confident_thresholds_multilabel( diff --git a/cleanlab/experimental/label_issues_batched.py b/cleanlab/experimental/label_issues_batched.py index d30df370dd..5cd395837f 100644 --- a/cleanlab/experimental/label_issues_batched.py +++ b/cleanlab/experimental/label_issues_batched.py @@ -34,6 +34,11 @@ from cleanlab.rank import find_top_issues, _compute_label_quality_scores from cleanlab.typing import LabelLike from cleanlab.internal.util import value_counts_fill_missing_classes +from cleanlab.internal.constants import ( + CONFIDENT_THRESHOLDS_LOWER_BOUND, + FLOATING_POINT_COMPARISON, + CLIPPING_LOWER_BOUND, +) import platform import multiprocessing as mp @@ -45,8 +50,6 @@ except ImportError: # pragma: no cover PSUTIL_EXISTS = False -EPS = 1e-6 # small number - # global variable for multiproc on linux adj_confident_thresholds_shared: np.ndarray labels_shared: LabelLike @@ -423,7 +426,7 @@ def get_num_issues(self, silent: bool = False) -> int: calibrated_prune_counts = ( self.prune_counts * self.class_counts - / np.clip(self.normalization, a_min=EPS, a_max=None) + / np.clip(self.normalization, a_min=CLIPPING_LOWER_BOUND, a_max=None) ) # avoid division by 0 return np.rint(np.sum(calibrated_prune_counts)).astype("int") else: # not calibrated @@ -509,6 +512,9 @@ def update_confident_thresholds(self, labels: LabelLike, pred_probs: np.ndarray) ) / np.clip( self.examples_per_class + batch_class_counts, a_min=1, a_max=None ) # avoid division by 0 + self.confident_thresholds = np.clip( + self.confident_thresholds, a_min=CONFIDENT_THRESHOLDS_LOWER_BOUND, a_max=None + ) self.examples_per_class += batch_class_counts self.examples_processed_thresh += batch_size @@ -581,7 +587,7 @@ def _update_num_label_issues( ) if self.n_jobs == 1: - adj_confident_thresholds = self.confident_thresholds - EPS + adj_confident_thresholds = self.confident_thresholds - FLOATING_POINT_COMPARISON pred_class = np.argmax(pred_probs, axis=1) batch_size = len(labels) if thorough: @@ -626,7 +632,7 @@ def _update_num_label_issues( ) else: # multiprocessing implementation global adj_confident_thresholds_shared - adj_confident_thresholds_shared = self.confident_thresholds - EPS + adj_confident_thresholds_shared = self.confident_thresholds - FLOATING_POINT_COMPARISON global labels_shared, pred_probs_shared labels_shared = labels diff --git a/cleanlab/internal/constants.py b/cleanlab/internal/constants.py new file mode 100644 index 0000000000..9a6452ae78 --- /dev/null +++ b/cleanlab/internal/constants.py @@ -0,0 +1,23 @@ +# Copyright (C) 2017-2023 Cleanlab Inc. +# This file is part of cleanlab. +# +# cleanlab is free software: you can redistribute it and/or modify +# it under the terms of the GNU Affero General Public License as published +# by the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# cleanlab is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU Affero General Public License for more details. +# +# You should have received a copy of the GNU Affero General Public License +# along with cleanlab. If not, see . + + +FLOATING_POINT_COMPARISON = 1e-6 # floating point comparison for fuzzy equals +CLIPPING_LOWER_BOUND = 1e-6 # lower-bound clipping threshold for expected behavior +CONFIDENT_THRESHOLDS_LOWER_BOUND = ( + 2 * FLOATING_POINT_COMPARISON +) # lower bound imposed to clip confident thresholds from below, has to be larger than floating point comparison +TINY_VALUE = 1e-100 # very tiny value for clipping diff --git a/cleanlab/internal/label_quality_utils.py b/cleanlab/internal/label_quality_utils.py index 7317d134c0..3428144c13 100644 --- a/cleanlab/internal/label_quality_utils.py +++ b/cleanlab/internal/label_quality_utils.py @@ -22,6 +22,7 @@ from typing import Optional from cleanlab.count import get_confident_thresholds +from cleanlab.internal.constants import CLIPPING_LOWER_BOUND def _subtract_confident_thresholds( @@ -83,7 +84,9 @@ def _subtract_confident_thresholds( return pred_probs_adj -def get_normalized_entropy(pred_probs: np.ndarray, min_allowed_prob: float = 1e-6) -> np.ndarray: +def get_normalized_entropy( + pred_probs: np.ndarray, min_allowed_prob: float = CLIPPING_LOWER_BOUND +) -> np.ndarray: """Returns the normalized entropy of pred_probs. Normalized entropy is between 0 and 1. Higher values of entropy indicate higher uncertainty in the model's prediction of the correct label. diff --git a/cleanlab/internal/latent_algebra.py b/cleanlab/internal/latent_algebra.py index af3b0ec177..d42c16c436 100644 --- a/cleanlab/internal/latent_algebra.py +++ b/cleanlab/internal/latent_algebra.py @@ -28,7 +28,8 @@ import numpy as np from typing import Tuple -from cleanlab.internal.util import value_counts, clip_values, clip_noise_rates, TINY_VALUE +from cleanlab.internal.util import value_counts, clip_values, clip_noise_rates +from cleanlab.internal.constants import TINY_VALUE, CLIPPING_LOWER_BOUND def compute_ps_py_inv_noise_matrix( @@ -73,7 +74,7 @@ def compute_py_inv_noise_matrix(ps, noise_matrix) -> Tuple[np.ndarray, np.ndarra # No class should have probability 0, so we use .000001 # Make sure valid probabilities that sum to 1.0 - py = clip_values(py, low=1e-6, high=1.0, new_sum=1.0) + py = clip_values(py, low=CLIPPING_LOWER_BOUND, high=1.0, new_sum=1.0) # All the work is done in this function (below) return py, compute_inv_noise_matrix(py=py, noise_matrix=noise_matrix, ps=ps) @@ -267,8 +268,8 @@ def compute_py( err += " should be in [cnt, eqn, marginal, marginal_ps]" raise ValueError(err) - # Clip py (0,1), s.t. no class should have prob 0, hence 1e-5 - py = clip_values(py, low=1e-5, high=1.0, new_sum=1.0) + # Clip py (0,1), s.t. no class should have prob 0, hence 1e-6 + py = clip_values(py, low=CLIPPING_LOWER_BOUND, high=1.0, new_sum=1.0) return py diff --git a/cleanlab/internal/util.py b/cleanlab/internal/util.py index 79ee8e2337..ee2d53f2b0 100644 --- a/cleanlab/internal/util.py +++ b/cleanlab/internal/util.py @@ -25,9 +25,7 @@ from cleanlab.typing import DatasetLike, LabelLike from cleanlab.internal.validation import labels_to_array - - -TINY_VALUE = 1e-100 +from cleanlab.internal.constants import FLOATING_POINT_COMPARISON, TINY_VALUE def remove_noise_from_class(noise_matrix, class_without_noise) -> np.ndarray: @@ -234,7 +232,7 @@ def round_preserving_sum(iterable) -> np.ndarray: orig_sum = np.sum(floats).round() int_sum = np.sum(ints).round() # Adjust the integers so that they sum to orig_sum - while abs(int_sum - orig_sum) > 1e-6: + while abs(int_sum - orig_sum) > FLOATING_POINT_COMPARISON: diff = np.round(orig_sum - int_sum) increment = -1 if int(diff < 0.0) else 1 changes = min(int(abs(diff)), len(iterable)) diff --git a/cleanlab/internal/validation.py b/cleanlab/internal/validation.py index dce6cc9a6c..f36603515f 100644 --- a/cleanlab/internal/validation.py +++ b/cleanlab/internal/validation.py @@ -19,6 +19,7 @@ """ from cleanlab.typing import LabelLike, DatasetLike +from cleanlab.internal.constants import FLOATING_POINT_COMPARISON from typing import Any, List, Optional, Union import warnings import numpy as np @@ -95,7 +96,9 @@ def assert_valid_inputs( f"pred_probs must have at least {highest_class} columns, based on the largest class index which appears in labels." ) # Check for valid probabilities. - if (np.min(pred_probs) < 0) or (np.max(pred_probs) > 1): + if (np.min(pred_probs) < 0 - FLOATING_POINT_COMPARISON) or ( + np.max(pred_probs) > 1 + FLOATING_POINT_COMPARISON + ): raise ValueError("Values in pred_probs must be between 0 and 1.") if X is not None: warnings.warn("When X and pred_probs are both provided, the former may be ignored.") diff --git a/cleanlab/multiannotator.py b/cleanlab/multiannotator.py index 0b0dfb02d1..d708d05713 100644 --- a/cleanlab/multiannotator.py +++ b/cleanlab/multiannotator.py @@ -49,6 +49,8 @@ from cleanlab.rank import get_label_quality_scores from cleanlab.internal.util import get_num_classes, value_counts +from cleanlab.internal.constants import CLIPPING_LOWER_BOUND + from cleanlab.internal.multiannotator_utils import ( assert_valid_inputs_multiannotator, assert_valid_pred_probs, @@ -1296,7 +1298,7 @@ def _get_post_pred_probs_and_weights( consensus_label_subset != np.argmax(np.bincount(consensus_label_subset, minlength=num_classes)) ), - a_min=1e-6, + a_min=CLIPPING_LOWER_BOUND, a_max=None, ) @@ -1306,14 +1308,14 @@ def _get_post_pred_probs_and_weights( ) annotator_error = 1 - annotator_agreement_with_annotators adjusted_annotator_agreement = np.clip( - 1 - (annotator_error / most_likely_class_error), a_min=1e-6, a_max=None + 1 - (annotator_error / most_likely_class_error), a_min=CLIPPING_LOWER_BOUND, a_max=None ) # compute model weight model_error = np.mean(np.argmax(prior_pred_probs_subset, axis=1) != consensus_label_subset) - model_weight = np.max([(1 - (model_error / most_likely_class_error)), 1e-6]) * np.sqrt( - np.mean(num_annotations) - ) + model_weight = np.max( + [(1 - (model_error / most_likely_class_error)), CLIPPING_LOWER_BOUND] + ) * np.sqrt(np.mean(num_annotations)) # compute weighted average post_pred_probs = np.full(prior_pred_probs.shape, np.nan) @@ -1422,7 +1424,7 @@ def _get_post_pred_probs_and_weights_ensemble( consensus_label_subset != np.argmax(np.bincount(consensus_label_subset, minlength=num_classes)) ), - a_min=1e-6, + a_min=CLIPPING_LOWER_BOUND, a_max=None, ) @@ -1432,7 +1434,7 @@ def _get_post_pred_probs_and_weights_ensemble( ) annotator_error = 1 - annotator_agreement_with_annotators adjusted_annotator_agreement = np.clip( - 1 - (annotator_error / most_likely_class_error), a_min=1e-6, a_max=None + 1 - (annotator_error / most_likely_class_error), a_min=CLIPPING_LOWER_BOUND, a_max=None ) # compute model weight @@ -1441,9 +1443,9 @@ def _get_post_pred_probs_and_weights_ensemble( prior_pred_probs_subset = prior_pred_probs[idx][mask] model_error = np.mean(np.argmax(prior_pred_probs_subset, axis=1) != consensus_label_subset) - model_weight[idx] = np.max([(1 - (model_error / most_likely_class_error)), 1e-6]) * np.sqrt( - np.mean(num_annotations) - ) + model_weight[idx] = np.max( + [(1 - (model_error / most_likely_class_error)), CLIPPING_LOWER_BOUND] + ) * np.sqrt(np.mean(num_annotations)) # compute weighted average post_pred_probs = np.full(prior_pred_probs[0].shape, np.nan) diff --git a/cleanlab/rank.py b/cleanlab/rank.py index 60def50a09..9e51da9fd6 100644 --- a/cleanlab/rank.py +++ b/cleanlab/rank.py @@ -37,6 +37,10 @@ import warnings from cleanlab.internal.validation import assert_valid_inputs +from cleanlab.internal.constants import ( + CLIPPING_LOWER_BOUND, +) # lower-bound clipping threshold to prevents 0 in logs and division + from cleanlab.internal.label_quality_utils import ( _subtract_confident_thresholds, get_normalized_entropy, @@ -236,8 +240,6 @@ def get_label_quality_ensemble_scores( get_label_quality_scores """ - MIN_ALLOWED = 1e-6 # lower-bound clipping threshold to prevents 0 in logs and division - # Check pred_probs_list for errors assert isinstance( pred_probs_list, list @@ -277,7 +279,7 @@ def get_label_quality_ensemble_scores( # pred_probs for each model for pred_probs in pred_probs_list: pred_probs_clipped = np.clip( - pred_probs, a_min=MIN_ALLOWED, a_max=None + pred_probs, a_min=CLIPPING_LOWER_BOUND, a_max=None ) # lower-bound clipping threshold to prevents 0 in logs when calculating log loss pred_probs_clipped /= pred_probs_clipped.sum(axis=1)[:, np.newaxis] # renormalize @@ -574,15 +576,14 @@ def get_confidence_weighted_entropy_for_each_label( Lower scores indicate more likely mislabeled examples. """ - MIN_ALLOWED = 1e-6 # lower-bound clipping threshold to prevents 0 in logs and division self_confidence = get_self_confidence_for_each_label(labels, pred_probs) - self_confidence = np.clip(self_confidence, a_min=MIN_ALLOWED, a_max=None) + self_confidence = np.clip(self_confidence, a_min=CLIPPING_LOWER_BOUND, a_max=None) # Divide entropy by self confidence label_quality_scores = get_normalized_entropy(pred_probs) / self_confidence # Rescale - clipped_scores = np.clip(label_quality_scores, a_min=MIN_ALLOWED, a_max=None) + clipped_scores = np.clip(label_quality_scores, a_min=CLIPPING_LOWER_BOUND, a_max=None) label_quality_scores = np.log(label_quality_scores + 1) / clipped_scores return label_quality_scores From 00776646a7764e07cc4078e8c25e873ee413c5f7 Mon Sep 17 00:00:00 2001 From: Hui Wen <45724323+huiwengoh@users.noreply.github.com> Date: Mon, 13 Mar 2023 11:37:00 -0400 Subject: [PATCH 136/258] Fix bug with call to find_overlapping_issues without specifying labels (#652) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * fix None labels issue * build: ➕ add hypothesis to dev dependencies. Used for property-based testing * test: ✅ test that find_overlapping_classes can run by only providing a confident joint Resolves #651 --------- Co-authored-by: Elías Snorrason --- cleanlab/count.py | 7 ++++++- cleanlab/dataset.py | 15 ++++++++------- requirements-dev.txt | 1 + tests/test_dataset.py | 43 +++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 58 insertions(+), 8 deletions(-) diff --git a/cleanlab/count.py b/cleanlab/count.py index c47590773e..faa2260118 100644 --- a/cleanlab/count.py +++ b/cleanlab/count.py @@ -389,7 +389,12 @@ def estimate_joint( multi_label=multi_label, ) else: - calibrated_cj = calibrate_confident_joint(confident_joint, labels, multi_label=multi_label) + if labels is not None: + calibrated_cj = calibrate_confident_joint( + confident_joint, labels, multi_label=multi_label + ) + else: + calibrated_cj = confident_joint assert isinstance(calibrated_cj, np.ndarray) if multi_label: diff --git a/cleanlab/dataset.py b/cleanlab/dataset.py index 9020b34539..78c9da670f 100644 --- a/cleanlab/dataset.py +++ b/cleanlab/dataset.py @@ -22,6 +22,7 @@ and which classes to merge (see :py:func:`find_overlapping_classes `). """ +from typing import Optional, cast import numpy as np import pandas as pd from cleanlab.count import estimate_joint @@ -248,7 +249,7 @@ def _2d_matrix_to_row_column_value_list(matrix): multi_label=multi_label, ) if num_examples is None: - num_examples = _get_num_examples(labels=labels) + num_examples = _get_num_examples(labels=labels, confident_joint=confident_joint) if asymmetric: rcv_list = _2d_matrix_to_row_column_value_list(joint) # Remove diagonal elements @@ -444,7 +445,7 @@ def health_summary( } -def _get_num_examples(labels=None) -> int: +def _get_num_examples(labels=None, confident_joint: Optional[np.ndarray] = None) -> int: """Helper method that finds the number of examples from the parameters or throws an error if neither parameter is provided. @@ -462,11 +463,11 @@ def _get_num_examples(labels=None) -> int: ValueError If `labels` is None.""" - if labels is not None: - num_examples = len(labels) - else: + if labels is None and confident_joint is None: raise ValueError( - "Error: num_examples is None. You must provide a value for num_examples " - "when calling this method using the joint as an input parameter." + "Error: num_examples is None. You must either provide confident_joint, " + "or provide both num_example and joint as input parameters." ) + _confident_joint = cast(np.ndarray, confident_joint) + num_examples = len(labels) if labels is not None else cast(int, np.sum(_confident_joint)) return num_examples diff --git a/requirements-dev.txt b/requirements-dev.txt index dd3d55e4fe..cab341d45a 100644 --- a/requirements-dev.txt +++ b/requirements-dev.txt @@ -1,5 +1,6 @@ # Python dependencies for development coverage != 6.3, != 6.3.* +hypothesis mypy pandas-stubs pre-commit diff --git a/tests/test_dataset.py b/tests/test_dataset.py index a96d26967a..1331fe5677 100644 --- a/tests/test_dataset.py +++ b/tests/test_dataset.py @@ -16,8 +16,11 @@ import requests import pytest +import hypothesis.extra.numpy as npst +import hypothesis.strategies as st import io import numpy as np +from hypothesis import given from cleanlab.dataset import ( health_summary, find_overlapping_classes, @@ -492,3 +495,43 @@ def test_value_error_missing_num_examples_with_joint(use_num_examples, use_label joint=joint, num_examples=len(labels) if use_num_examples else None, ) + + +confident_joint_strategy = npst.arrays( + np.int32, + shape=npst.array_shapes(min_dims=2, max_dims=2, min_side=2, max_side=10), + elements=st.integers(min_value=0, max_value=int(1e6)), +).filter(lambda arr: arr.shape[0] == arr.shape[1]) + + +@pytest.mark.issue_651 +@given(confident_joint=confident_joint_strategy) +def test_find_overlapping_classes_with_confident_joint(confident_joint): + # Setup + K = confident_joint.shape[0] + overlapping_classes = find_overlapping_classes(confident_joint=confident_joint) + + # Test that the output dataframe has the expected columns + expected_columns = [ + "Class Index A", + "Class Index B", + "Num Overlapping Examples", + "Joint Probability", + ] + assert set(overlapping_classes.columns) == set(expected_columns) + + # Class indices must be valid + assert overlapping_classes["Class Index A"].between(0, K - 1).all() + assert overlapping_classes["Class Index B"].between(0, K - 1).all() + + # Overlapping example count should be non-negative integers + assert (overlapping_classes["Num Overlapping Examples"] >= 0).all() + assert overlapping_classes["Num Overlapping Examples"].dtype == int + + # Joint probabilities should be between 0 and 1 + assert (overlapping_classes["Joint Probability"] >= 0).all() + assert (overlapping_classes["Joint Probability"] <= 1).all() + + # Joint probabilities sorted in descending order + if K > 2: + assert (overlapping_classes["Joint Probability"].diff()[1:] <= 0).all() From fa1db6e1d5013538f7fe3c6570b96cb04e30390b Mon Sep 17 00:00:00 2001 From: Hui Wen <45724323+huiwengoh@users.noreply.github.com> Date: Tue, 21 Mar 2023 02:36:41 -0400 Subject: [PATCH 137/258] Bug fixes + improvements to multiannotator module (#654) Co-authored-by: Jonas Mueller <1390638+jwmueller@users.noreply.github.com> --- cleanlab/internal/multiannotator_utils.py | 35 +-- cleanlab/multiannotator.py | 285 +++++++++++++--------- tests/test_multiannotator.py | 29 ++- 3 files changed, 222 insertions(+), 127 deletions(-) diff --git a/cleanlab/internal/multiannotator_utils.py b/cleanlab/internal/multiannotator_utils.py index 27e73eb079..429321b13e 100644 --- a/cleanlab/internal/multiannotator_utils.py +++ b/cleanlab/internal/multiannotator_utils.py @@ -129,17 +129,23 @@ def assert_valid_inputs_multiannotator( def assert_valid_pred_probs( - pred_probs: np.ndarray, + pred_probs: Optional[np.ndarray] = None, pred_probs_unlabeled: Optional[np.ndarray] = None, ensemble: bool = False, ): - """Validate format of pred_probs for multiannotator functions""" + """Validate format of pred_probs for multiannotator active learning functions""" + if pred_probs is None and pred_probs_unlabeled is None: + raise ValueError( + "pred_probs and pred_probs_unlabeled cannot both be None, specify at least one of the two." + ) + if ensemble: - if pred_probs.ndim != 3: - error_message = "pred_probs must be a 3d array." - if pred_probs.ndim == 2: # pragma: no cover - error_message += " If you have a 2d pred_probs array, use the non-ensemble version of this function." - raise ValueError(error_message) + if pred_probs is not None: + if pred_probs.ndim != 3: + error_message = "pred_probs must be a 3d array." + if pred_probs.ndim == 2: # pragma: no cover + error_message += " If you have a 2d pred_probs array (ie. only one predictor), use the non-ensemble version of this function." + raise ValueError(error_message) if pred_probs_unlabeled is not None: if pred_probs_unlabeled.ndim != 3: @@ -148,19 +154,19 @@ def assert_valid_pred_probs( error_message += " If you have a 2d pred_probs_unlabeled array, use the non-ensemble version of this function." raise ValueError(error_message) + if pred_probs is not None and pred_probs_unlabeled is not None: if pred_probs.shape[2] != pred_probs_unlabeled.shape[2]: raise ValueError( "pred_probs and pred_probs_unlabeled must have the same number of classes" ) else: - if pred_probs.ndim != 2: - error_message = "pred_probs must be a 2d array." - if pred_probs.ndim == 3: # pragma: no cover - error_message += ( - " If you have a 3d pred_probs array, use the ensemble version of this function." - ) - raise ValueError(error_message) + if pred_probs is not None: + if pred_probs.ndim != 2: + error_message = "pred_probs must be a 2d array." + if pred_probs.ndim == 3: # pragma: no cover + error_message += " If you have a 3d pred_probs array, use the ensemble version of this function." + raise ValueError(error_message) if pred_probs_unlabeled is not None: if pred_probs_unlabeled.ndim != 2: @@ -169,6 +175,7 @@ def assert_valid_pred_probs( error_message += " If you have a 3d pred_probs_unlabeled array, use the non-ensemble version of this function." raise ValueError(error_message) + if pred_probs is not None and pred_probs_unlabeled is not None: if pred_probs.shape[1] != pred_probs_unlabeled.shape[1]: raise ValueError( "pred_probs and pred_probs_unlabeled must have the same number of classes" diff --git a/cleanlab/multiannotator.py b/cleanlab/multiannotator.py index d708d05713..c22a91548d 100644 --- a/cleanlab/multiannotator.py +++ b/cleanlab/multiannotator.py @@ -539,8 +539,8 @@ def get_label_quality_multiannotator_ensemble( def get_active_learning_scores( - labels_multiannotator: Union[pd.DataFrame, np.ndarray], - pred_probs: np.ndarray, + labels_multiannotator: Optional[Union[pd.DataFrame, np.ndarray]] = None, + pred_probs: Optional[np.ndarray] = None, pred_probs_unlabeled: Optional[np.ndarray] = None, ) -> Tuple[np.ndarray, np.ndarray]: """Returns an ActiveLab quality score for each example in the dataset, to estimate which examples are most informative to (re)label next in active learning. @@ -553,28 +553,35 @@ def get_active_learning_scores( To use an annotation budget most efficiently, select a batch of examples with the lowest scores and collect one additional label for each example, and repeat this process after retraining your classifier. + You can use this function to get active learning scores for: examples that already have one or more labels (specify ``labels_multiannotator`` and ``pred_probs`` + as arguments), or for unlabeled examples (specify ``pred_probs_unlabeled``), or for both types of examples (specify all of the above arguments). + To analyze a fixed dataset labeled by multiple annotators rather than collecting additional labels, try the :py:func:`get_label_quality_multiannotator ` (CROWDLAB) function instead. Parameters ---------- - labels_multiannotator : pd.DataFrame of np.ndarray + labels_multiannotator : pd.DataFrame of np.ndarray, optional 2D pandas DataFrame or array of multiple given labels for each example with shape ``(N, M)``, where N is the number of examples and M is the number of annotators. Note that this function also works with datasets where there is only one annotator (M=1). For more details, labels in the same format expected by the :py:func:`get_label_quality_multiannotator `. Note that examples that have no annotator labels should not be included in this DataFrame/array. - pred_probs : np.ndarray + This argument is optional if ``pred_probs`` is not provided (you might only provide ``pred_probs_unlabeled`` to only get active learning scores for the unlabeled examples). + pred_probs : np.ndarray, optional An array of shape ``(N, K)`` of predicted class probabilities from a trained classifier model. Predicted probabilities in the same format expected by the :py:func:`get_label_quality_scores `. + This argument is optional if you only want to get active learning scores for unlabeled examples (specify only ``pred_probs_unlabeled`` instead). pred_probs_unlabeled : np.ndarray, optional An array of shape ``(N, K)`` of predicted class probabilities from a trained classifier model for examples that have no annotator labels. Predicted probabilities in the same format expected by the :py:func:`get_label_quality_scores `. + This argument is optional if you only want to get active learning scores for already-labeled examples (specify only ``pred_probs`` instead). Returns ------- active_learning_scores : np.ndarray Array of shape ``(N,)`` indicating the ActiveLab quality scores for each example. + This array is empty if no already-labeled data was provided via ``labels_multiannotator``. Examples with the lowest scores are those we should label next in order to maximally improve our classifier model. active_learning_scores_unlabeled : np.ndarray @@ -584,60 +591,83 @@ def get_active_learning_scores( (scores for unlabeled data are directly comparable with the `active_learning_scores` for labeled data). """ - if isinstance(labels_multiannotator, np.ndarray): - labels_multiannotator = pd.DataFrame(labels_multiannotator) - assert_valid_pred_probs(pred_probs=pred_probs, pred_probs_unlabeled=pred_probs_unlabeled) - num_classes = get_num_classes(pred_probs=pred_probs) + # compute multiannotator stats if labeled data is provided + if pred_probs is not None: + if labels_multiannotator is None: + raise ValueError( + "labels_multiannotator cannot be None when passing in pred_probs. ", + "Either provide labels_multiannotator to obtain active learning scores for the labeled examples, " + "or just pass in pred_probs_unlabeled to get active learning scores for unlabeled examples.", + ) - # if all examples are only labeled by a single annotator - if labels_multiannotator.apply(lambda s: len(s.dropna()) == 1, axis=1).all(): - optimal_temp = 1.0 # do not temp scale for single annotator case, temperature is defined here for later use + if isinstance(labels_multiannotator, np.ndarray): + labels_multiannotator = pd.DataFrame(labels_multiannotator) - assert_valid_inputs_multiannotator( - labels_multiannotator, pred_probs, allow_single_label=True - ) + num_classes = get_num_classes(pred_probs=pred_probs) - consensus_label = get_majority_vote_label( - labels_multiannotator=labels_multiannotator, - pred_probs=pred_probs, - verbose=False, - ) - quality_of_consensus_labeled = get_label_quality_scores(consensus_label, pred_probs) - model_weight = 1 - annotator_weight = np.full(labels_multiannotator.shape[1], 1) - avg_annotator_weight = np.mean(annotator_weight) + # if all examples are only labeled by a single annotator + if labels_multiannotator.apply(lambda s: len(s.dropna()) == 1, axis=1).all(): + optimal_temp = 1.0 # do not temp scale for single annotator case, temperature is defined here for later use - else: - optimal_temp = find_best_temp_scaler(labels_multiannotator, pred_probs) - pred_probs = temp_scale_pred_probs(pred_probs, optimal_temp) + assert_valid_inputs_multiannotator( + labels_multiannotator, pred_probs, allow_single_label=True + ) - multiannotator_info = get_label_quality_multiannotator( - labels_multiannotator, - pred_probs, - return_annotator_stats=False, - return_detailed_quality=False, - return_weights=True, - ) + consensus_label = get_majority_vote_label( + labels_multiannotator=labels_multiannotator, + pred_probs=pred_probs, + verbose=False, + ) + quality_of_consensus_labeled = get_label_quality_scores(consensus_label, pred_probs) + model_weight = 1 + annotator_weight = np.full(labels_multiannotator.shape[1], 1) + avg_annotator_weight = np.mean(annotator_weight) - quality_of_consensus_labeled = multiannotator_info["label_quality"][ - "consensus_quality_score" - ] - model_weight = multiannotator_info["model_weight"] - annotator_weight = multiannotator_info["annotator_weight"] - avg_annotator_weight = np.mean(annotator_weight) - - # compute scores for labeled data - active_learning_scores = np.full(len(labels_multiannotator), np.nan) - for i in range(len(active_learning_scores)): - annotator_labels = labels_multiannotator.iloc[i] - active_learning_scores[i] = np.average( - (quality_of_consensus_labeled[i], 1 / num_classes), - weights=( - np.sum(annotator_weight[annotator_labels.notna()]) + model_weight, - avg_annotator_weight, - ), + # examples are annotated by multiple annotators + else: + optimal_temp = find_best_temp_scaler(labels_multiannotator, pred_probs) + pred_probs = temp_scale_pred_probs(pred_probs, optimal_temp) + + multiannotator_info = get_label_quality_multiannotator( + labels_multiannotator, + pred_probs, + return_annotator_stats=False, + return_detailed_quality=False, + return_weights=True, + ) + + quality_of_consensus_labeled = multiannotator_info["label_quality"][ + "consensus_quality_score" + ] + model_weight = multiannotator_info["model_weight"] + annotator_weight = multiannotator_info["annotator_weight"] + avg_annotator_weight = np.mean(annotator_weight) + + # compute scores for labeled data + active_learning_scores = np.full(len(labels_multiannotator), np.nan) + for i in range(len(active_learning_scores)): + annotator_labels = labels_multiannotator.iloc[i] + active_learning_scores[i] = np.average( + (quality_of_consensus_labeled[i], 1 / num_classes), + weights=( + np.sum(annotator_weight[annotator_labels.notna()]) + model_weight, + avg_annotator_weight, + ), + ) + + # no labeled data provided so do not estimate temperature and model/annotator weights + elif pred_probs_unlabeled is not None: + num_classes = get_num_classes(pred_probs=pred_probs_unlabeled) + optimal_temp = 1 + model_weight = 1 + avg_annotator_weight = 1 + active_learning_scores = np.array([]) + + else: + raise ValueError( + "pred_probs and pred_probs_unlabeled cannot both be None, specify at least one of the two." ) # compute scores for unlabeled data @@ -663,8 +693,8 @@ def get_active_learning_scores( def get_active_learning_scores_ensemble( - labels_multiannotator: Union[pd.DataFrame, np.ndarray], - pred_probs: np.ndarray, + labels_multiannotator: Optional[Union[pd.DataFrame, np.ndarray]] = None, + pred_probs: Optional[np.ndarray] = None, pred_probs_unlabeled: Optional[np.ndarray] = None, ) -> Tuple[np.ndarray, np.ndarray]: """Returns an ActiveLab quality score for each example in the dataset, based on predictions from an ensemble of models. @@ -676,14 +706,17 @@ def get_active_learning_scores_ensemble( ---------- labels_multiannotator : pd.DataFrame or np.ndarray Multiannotator labels in the same format expected by :py:func:`get_active_learning_scores `. + This argument is optional if ``pred_probs`` is not provided (in cases where you only provide ``pred_probs_unlabeled`` to get active learning scores for unlabeled examples). pred_probs : np.ndarray An array of shape ``(P, N, K)`` where P is the number of models, consisting of predicted class probabilities from the ensemble models. Note that this function also works with datasets where there is only one annotator (M=1). Each set of predicted probabilities with shape ``(N, K)`` is in the same format expected by the :py:func:`get_label_quality_scores `. + This argument is optional if you only want to get active learning scores for unlabeled examples (pass in ``pred_probs_unlabeled`` instead). pred_probs_unlabeled : np.ndarray, optional An array of shape ``(P, N, K)`` where P is the number of models, consisting of predicted class probabilities from a trained classifier model for examples that have no annotated labels so far (but which we may want to label in the future, and hence compute active learning quality scores for). Each set of predicted probabilities with shape ``(N, K)`` is in the same format expected by the :py:func:`get_label_quality_scores `. + This argument is optional if you only want to get active learning scores for labeled examples (pass in ``pred_probs`` instead). Returns ------- @@ -697,70 +730,91 @@ def get_active_learning_scores_ensemble( get_active_learning_scores """ - if isinstance(labels_multiannotator, np.ndarray): - labels_multiannotator = pd.DataFrame(labels_multiannotator) - assert_valid_pred_probs( pred_probs=pred_probs, pred_probs_unlabeled=pred_probs_unlabeled, ensemble=True ) - num_classes = get_num_classes(pred_probs=pred_probs[0]) + # compute multiannotator stats if labeled data is provided + if pred_probs is not None: + if labels_multiannotator is None: + raise ValueError( + "labels_multiannotator cannot be None when passing in pred_probs. ", + "You can either provide labels_multiannotator to obtain active learning scores for the labeled examples, " + "or just pass in pred_probs_unlabeled to get active learning scores for unlabeled examples.", + ) - # temp scale pred_probs + if isinstance(labels_multiannotator, np.ndarray): + labels_multiannotator = pd.DataFrame(labels_multiannotator) - # if all examples are only labeled by a single annotator - if labels_multiannotator.apply(lambda s: len(s.dropna()) == 1, axis=1).all(): - # do not temp scale for single annotator case, temperature is defined here for later use - optimal_temp = np.full(len(pred_probs), 1.0) + num_classes = get_num_classes(pred_probs=pred_probs[0]) - assert_valid_inputs_multiannotator( - labels_multiannotator, pred_probs, ensemble=True, allow_single_label=True - ) + # if all examples are only labeled by a single annotator + if labels_multiannotator.apply(lambda s: len(s.dropna()) == 1, axis=1).all(): + # do not temp scale for single annotator case, temperature is defined here for later use + optimal_temp = np.full(len(pred_probs), 1.0) - avg_pred_probs = np.mean(pred_probs, axis=0) - consensus_label = get_majority_vote_label( - labels_multiannotator=labels_multiannotator, - pred_probs=avg_pred_probs, - verbose=False, - ) - quality_of_consensus_labeled = get_label_quality_scores(consensus_label, avg_pred_probs) - model_weight = np.full(len(pred_probs), 1) - annotator_weight = np.full(labels_multiannotator.shape[1], 1) - avg_annotator_weight = np.mean(annotator_weight) + assert_valid_inputs_multiannotator( + labels_multiannotator, pred_probs, ensemble=True, allow_single_label=True + ) - else: - optimal_temp = np.full(len(pred_probs), np.NaN) - for i in range(len(pred_probs)): - curr_pred_probs = pred_probs[i] - curr_optimal_temp = find_best_temp_scaler(labels_multiannotator, curr_pred_probs) - pred_probs[i] = temp_scale_pred_probs(curr_pred_probs, curr_optimal_temp) - optimal_temp[i] = curr_optimal_temp - - multiannotator_info = get_label_quality_multiannotator_ensemble( - labels_multiannotator, - pred_probs, - return_annotator_stats=False, - return_detailed_quality=False, - return_weights=True, - ) + avg_pred_probs = np.mean(pred_probs, axis=0) + consensus_label = get_majority_vote_label( + labels_multiannotator=labels_multiannotator, + pred_probs=avg_pred_probs, + verbose=False, + ) + quality_of_consensus_labeled = get_label_quality_scores(consensus_label, avg_pred_probs) + model_weight = np.full(len(pred_probs), 1) + annotator_weight = np.full(labels_multiannotator.shape[1], 1) + avg_annotator_weight = np.mean(annotator_weight) - quality_of_consensus_labeled = multiannotator_info["label_quality"][ - "consensus_quality_score" - ] - model_weight = multiannotator_info["model_weight"] - annotator_weight = multiannotator_info["annotator_weight"] - avg_annotator_weight = np.mean(annotator_weight) - - # compute scores for labeled data - active_learning_scores = np.full(len(labels_multiannotator), np.nan) - for i in range(len(active_learning_scores)): - annotator_labels = labels_multiannotator.iloc[i] - active_learning_scores[i] = np.average( - (quality_of_consensus_labeled[i], 1 / num_classes), - weights=( - np.sum(annotator_weight[annotator_labels.notna()]) + np.sum(model_weight), - avg_annotator_weight, - ), + # examples are annotated by multiple annotators + else: + optimal_temp = np.full(len(pred_probs), np.NaN) + for i in range(len(pred_probs)): + curr_pred_probs = pred_probs[i] + curr_optimal_temp = find_best_temp_scaler(labels_multiannotator, curr_pred_probs) + pred_probs[i] = temp_scale_pred_probs(curr_pred_probs, curr_optimal_temp) + optimal_temp[i] = curr_optimal_temp + + multiannotator_info = get_label_quality_multiannotator_ensemble( + labels_multiannotator, + pred_probs, + return_annotator_stats=False, + return_detailed_quality=False, + return_weights=True, + ) + + quality_of_consensus_labeled = multiannotator_info["label_quality"][ + "consensus_quality_score" + ] + model_weight = multiannotator_info["model_weight"] + annotator_weight = multiannotator_info["annotator_weight"] + avg_annotator_weight = np.mean(annotator_weight) + + # compute scores for labeled data + active_learning_scores = np.full(len(labels_multiannotator), np.nan) + for i in range(len(active_learning_scores)): + annotator_labels = labels_multiannotator.iloc[i] + active_learning_scores[i] = np.average( + (quality_of_consensus_labeled[i], 1 / num_classes), + weights=( + np.sum(annotator_weight[annotator_labels.notna()]) + np.sum(model_weight), + avg_annotator_weight, + ), + ) + + # no labeled data provided so do not estimate temperature and model/annotator weights + elif pred_probs_unlabeled is not None: + num_classes = get_num_classes(pred_probs=pred_probs_unlabeled[0]) + optimal_temp = np.full(len(pred_probs_unlabeled), 1.0) + model_weight = np.full(len(pred_probs_unlabeled), 1) + avg_annotator_weight = 1 + active_learning_scores = np.array([]) + + else: + raise ValueError( + "pred_probs and pred_probs_unlabeled cannot both be None, specify at least one of the two." ) # compute scores for unlabeled data @@ -861,6 +915,7 @@ def get_majority_vote_label( tied_idx[idx] = label_mode[max_pred_probs] # tiebreak 2: using empirical class frequencies + # current tiebreak will select the minority class (to prevent larger class imbalance) if len(tied_idx) > 0: if pred_probs is not None: num_classes = pred_probs.shape[1] @@ -872,14 +927,14 @@ def get_majority_vote_label( lambda s: pd.Series(np.bincount(s[s.notna()], minlength=num_classes)), axis=1 ).sum() for idx, label_mode in tied_idx.copy().items(): - max_frequency = np.where( - class_frequencies[label_mode] == np.max(class_frequencies[label_mode]) + min_frequency = np.where( + class_frequencies[label_mode] == np.min(class_frequencies[label_mode]) )[0] - if len(max_frequency) == 1: - majority_vote_label[idx] = label_mode[max_frequency[0]] + if len(min_frequency) == 1: + majority_vote_label[idx] = label_mode[min_frequency[0]] del tied_idx[idx] else: - tied_idx[idx] = label_mode[max_frequency] + tied_idx[idx] = label_mode[min_frequency] # tiebreak 3: using initial annotator quality scores if len(tied_idx) > 0: @@ -888,7 +943,13 @@ def get_majority_vote_label( annotator_agreement_with_consensus = nontied_labels_multiannotator.apply( lambda s: np.mean(s[pd.notna(s)] == nontied_majority_vote_label[pd.notna(s)]), axis=0, - ).to_numpy() + ) + + # impute average annotator accuracy for any annotator that do not overlap with consensus + mask = annotator_agreement_with_consensus.isna() + avg_annotator_agreement = np.mean(annotator_agreement_with_consensus[~mask]) + annotator_agreement_with_consensus[mask] = avg_annotator_agreement + for idx, label_mode in tied_idx.copy().items(): label_quality_score = np.array( [ diff --git a/tests/test_multiannotator.py b/tests/test_multiannotator.py index a428897870..74be98796b 100644 --- a/tests/test_multiannotator.py +++ b/tests/test_multiannotator.py @@ -434,6 +434,13 @@ def test_get_active_learning_scores(): assert len(active_learning_scores) == len(pred_probs) assert len(active_learning_scores_unlabeled) == 0 + # test case where only passing unlabeled examples + active_learning_scores, active_learning_scores_unlabeled = get_active_learning_scores( + pred_probs_unlabeled=pred_probs_unlabeled + ) + assert len(active_learning_scores) == 0 + assert len(active_learning_scores_unlabeled) == len(pred_probs_unlabeled) + # test case where number of classes do not match try: active_learning_scores, active_learning_scores_unlabeled = get_active_learning_scores( @@ -485,6 +492,13 @@ def test_get_active_learning_scores_ensemble(): assert len(active_learning_scores) == len(labels) assert len(active_learning_scores_unlabeled) == 0 + # test case where only passing unlabeled examples + active_learning_scores, active_learning_scores_unlabeled = get_active_learning_scores_ensemble( + pred_probs_unlabeled=pred_probs_unlabeled + ) + assert len(active_learning_scores) == 0 + assert len(active_learning_scores_unlabeled) == len(labels_unlabeled) + # test case where number of classes do not match try: ( @@ -640,9 +654,22 @@ def test_get_consensus_label(): [0.2, 0.4, 0.4], ] ) - consensus_label = get_majority_vote_label(labels_tiebreaks, pred_probs_tiebreaks) + # more tiebreak testing (without pred_probs + non-overlapping annotators) + labels_tiebreaks = np.array( + [ + [1, np.NaN, np.NaN, 2, np.NaN], + [np.NaN, 1, 0, np.NaN, np.NaN], + [np.NaN, np.NaN, 0, np.NaN, np.NaN], + [np.NaN, 2, np.NaN, np.NaN, np.NaN], + [2, np.NaN, 0, 2, np.NaN], + [np.NaN, np.NaN, np.NaN, 2, 1], + ] + ) + consensus_label = get_majority_vote_label(labels_tiebreaks) + assert all(consensus_label == np.array([1, 1, 0, 2, 2, 1])) + def test_impute_nonoverlaping_annotators(): labels = np.array( From a5f35f3b7b9bc031aaff4502429ff4e770c41acc Mon Sep 17 00:00:00 2001 From: Jonas Mueller <1390638+jwmueller@users.noreply.github.com> Date: Fri, 24 Mar 2023 01:15:39 -0700 Subject: [PATCH 138/258] additional faq question on handling train vs test data (#655) --- docs/source/tutorials/faq.ipynb | 30 +++++++++++++++++++++++++----- 1 file changed, 25 insertions(+), 5 deletions(-) diff --git a/docs/source/tutorials/faq.ipynb b/docs/source/tutorials/faq.ipynb index a1978e1417..6854a1d0c1 100644 --- a/docs/source/tutorials/faq.ipynb +++ b/docs/source/tutorials/faq.ipynb @@ -7,7 +7,9 @@ "source": [ "# FAQ\n", "\n", - "Answers to frequently asked questions about the [cleanlab](https://github.com/cleanlab/cleanlab) open-source package." + "Answers to frequently asked questions about the [cleanlab](https://github.com/cleanlab/cleanlab) open-source package.\n", + "\n", + "The code snippets in this FAQ come from a fully executable notebook you can run via Colab or locally by downloading it [here](https://github.com/cleanlab/cleanlab/blob/master/docs/source/tutorials/faq.ipynb).\n" ] }, { @@ -150,7 +152,7 @@ "id": "b386dfc8", "metadata": {}, "source": [ - "If you have already found issues via:" + "Otherwise if you have already found issues via:" ] }, { @@ -168,7 +170,7 @@ "id": "ad9ca03e", "metadata": {}, "source": [ - "then you can see your trained classifier's class prediction for each flagged example via: " + "then you can see your trained classifier's class prediction for each flagged example like this: " ] }, { @@ -186,7 +188,7 @@ "id": "a668b74b", "metadata": {}, "source": [ - "where you can see the classifier's class prediction for every example via:" + "Here you can see the classifier's class prediction for every example via:" ] }, { @@ -208,6 +210,24 @@ "You will be able to produce a much better version of your dataset interactively using [Cleanlab Studio](https://cleanlab.ai/studio/?utm_source=github&utm_medium=docs&utm_campaign=clostostudio), which helps you efficiently fix issues like this in large datasets." ] }, + { + "cell_type": "markdown", + "id": "bcc97591", + "metadata": {}, + "source": [ + "### How shoud I handle label errors in train vs test data?\n", + "\n", + "If you do not address label errors in your test data, you may not even know when you have produced a better ML model because the evaluation is too noisy. For the best-trained models and most reliable evaluation of them, you should fix label errors in both your training and testing data.\n", + "\n", + "To do this efficiently, first use cleanlab to automatically find label issues in both sets. You can simply merge these two sets into one larger dataset and run cross-validation training + `find_label_issues()` on the merged datataset. Calling the [`CleanLearning.find_label_issues()`](../cleanlab/classification.html) method on your merged dataset does both these steps for you with any scikit-learn compatible classifier you choose.\n", + "\n", + "After finding the label issues, be **wary** about auto-correcting the labels for test examples (as cautioned against above). Instead make sure you are only manually fixing labels for your test data. You can use [Cleanlab Studio](https://cleanlab.ai/studio/) to fix labels efficiently.\n", + "\n", + "Auto-correcting labels for your training data is fair game, which should improve your ML performance. You can often boost ML performance further by manually fixing the training examples flagged with label issues, as demonstrated in this article:\n", + "\n", + "[**Handling Mislabeled Tabular Data to Improve Your XGBoost Model**](https://cleanlab.ai/blog/label-errors-tabular-datasets/)" + ] + }, { "cell_type": "markdown", "id": "21f42f24", @@ -597,7 +617,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.15" + "version": "3.9.12" } }, "nbformat": 4, From bed94f19e1cce6f672e879cecea51afb2445a202 Mon Sep 17 00:00:00 2001 From: Jonas Mueller <1390638+jwmueller@users.noreply.github.com> Date: Fri, 24 Mar 2023 02:42:10 -0700 Subject: [PATCH 139/258] Update readme to better reflect current package (#656) --- README.md | 86 +++++++++++++++++++++++-------------------------------- 1 file changed, 36 insertions(+), 50 deletions(-) diff --git a/README.md b/README.md index 169c43dfd5..2b75e6dab9 100644 --- a/README.md +++ b/README.md @@ -3,11 +3,11 @@

    -cleanlab automatically detects problems in a ML dataset. This data-centric AI package facilitates **machine learning with messy, real-world data** by providing **clean lab**els for robust training and flagging errors in your data. +cleanlab helps you **clean** data and **lab**els by automatically detecting issues in a ML dataset. To facilitate **machine learning with messy, real-world data**, this data-centric AI package uses your *existing* models to estimate dataset problems that can be fixed to train even *better* models. ```python -# cleanlab works with **any classifier**. Yup, you can use sklearn/PyTorch/TensorFlow/XGBoost/etc. +# cleanlab works with **any classifier**. Yup, you can use PyTorch/TensorFlow/OpenAI/XGBoost/etc. cl = cleanlab.classification.CleanLearning(sklearn.YourFavoriteClassifier()) # cleanlab finds data and label issues in **any dataset**... in ONE line of code! @@ -41,59 +41,20 @@ Get started with: [documentation](https://docs.cleanlab.ai/), [tutorials](https: ----- -
    News! (2022) -- cleanlab made accessible for everybody, not just ML researchers (click to learn more) -

    -

      -
    • Nov 2022 📖 cleanlab 2.2.0 released! Added better algorithms for: label issues in multi-label classification, data with some classes absent, and estimating the number of label errors in a dataset.
      • -
    • Sep 2022 📖 cleanlab 2.1.0 released! Added support for: data labeled by multiple annotators in cleanlab.multiannotator, token classification with text data in cleanlab.token_classification, out-of-distribution detection in cleanlab.outlier, and CleanLearning with non-numpy-array data (e.g. pandas dataframes, tensorflow/pytorch datasets, etc) in cleanlab.classification.CleanLearning.
      • -
    • April 2022 📖 cleanlab 2.0.0 released! Lays foundations for this library to grow into a general-purpose data-centric AI toolkit.
      • -
    • March 2022 📖 Documentation migrated to new website: docs.cleanlab.ai with quickstart tutorials for image/text/audio/tabular data.
      • -
    • Feb 2022 💻 APIs simplified to make cleanlab accessible for everybody, not just ML researchers
      • -
    • Long-time cleanlab user? Here's how to migrate to cleanlab versions >= 2.0.0.
      • -
    -

    -
    - -
    News! (2021) -- cleanlab finds pervasive label errors in the most common ML datasets (click to learn more) -

    -

    -

    -
    - -
    News! (2020) -- cleanlab supports all OS, achieves state-of-the-art performance (click to learn more) -

    -

      -
    • Dec 2020 🎉 cleanlab supports NeurIPS workshop paper (Northcutt, Athalye, & Lin, 2020).
      • -
    • Dec 2020 🤖 cleanlab supports Positive-Unlabeled (PU) learning.
      • -
    • Feb 2020 🤖 cleanlab now natively supports Mac, Linux, and Windows.
      • -
    • Feb 2020 🤖 cleanlab now supports Co-Teaching (Han et al., 2018).
      • -
    • Jan 2020 🎉 cleanlab achieves state-of-the-art on CIFAR-10 with noisy labels. Code to reproduce: examples/cifar10. This is a great place to see how to use cleanlab on real datasets (with predicted probabilities from trained model already precomputed for you).
      • -
    -

    -
    - -Release notes for past versions are [here](https://github.com/cleanlab/cleanlab/releases). -Details behind updates are explained in our [blog](https://cleanlab.ai/blog/) and [research papers](https://cleanlab.ai/research/). - - ## So fresh, so cleanlab -cleanlab **clean**s your data's **lab**els via state-of-the-art *confident learning* algorithms, published in this [paper](https://jair.org/index.php/jair/article/view/12125) and [blog](https://l7.curtisnorthcutt.com/confident-learning). See some of the datasets cleaned with cleanlab at [labelerrors.com](https://labelerrors.com). This package helps you find data and label issues so you can train reliable ML models. +cleanlab **clean**s your data's **lab**els via state-of-the-art *confident learning* algorithms, published in this [paper](https://jair.org/index.php/jair/article/view/12125) and [blog](https://l7.curtisnorthcutt.com/confident-learning). See some of the datasets cleaned with cleanlab at [labelerrors.com](https://labelerrors.com). This package helps you find label issues and other data issues, so you can train reliable ML models. cleanlab is: 1. **backed by theory** - with [provable guarantees](https://arxiv.org/abs/1911.00068) of exact estimation of noise and label errors, even with imperfect models. 2. **fast** - - Code is parallelized (< 1 second to find label issues in ImageNet with pre-computed predictions). + - Code is parallelized and scalable. 4. **easy-to-use** - - Find label issues or train noise-robust models in one line of code (no hyperparameters by default). + - Find mislabeled data, bad annotators, outliers, or train noise-robust models -- all in one line of code. 6. **general** - - Works with **[any dataset](https://labelerrors.com/)** and **any model**, e.g., TensorFlow, PyTorch, sklearn, XGBoost, Huggingface, etc. + - Works with **[any dataset](https://labelerrors.com/)** (text, image, tabular, audio, ...) and **any model** (TensorFlow, PyTorch, JAX, HuggingFace, OpenAI, XGBoost, scikit-learn, ...)
    ![](https://raw.githubusercontent.com/cleanlab/assets/master/cleanlab/label-errors-examples.png) @@ -107,11 +68,11 @@ cleanlab supports Linux, macOS, and Windows and runs on Python 3.7+. - Get started [here](https://docs.cleanlab.ai/)! Install via `pip` or `conda` as described [here](https://docs.cleanlab.ai/). - Developers who install the bleeding-edge from source should refer to [this master branch documentation](https://docs.cleanlab.ai/master/index.html). - +- For help, check out our detailed [FAQ](https://docs.cleanlab.ai/stable/tutorials/faq.html), [Github Issues](https://github.com/cleanlab/cleanlab/issues?q=is%3Aissue), or [Slack](https://cleanlab.ai/slack). We welcome any questions! ## Use cleanlab with any model for most ML tasks -All features of cleanlab work with **any dataset** and **any model**. Yes, any model: scikit-learn, PyTorch, Tensorflow, Keras, JAX, HuggingFace, MXNet, XGBoost, etc. +All features of cleanlab work with **any dataset** and **any model**. Yes, any model: PyTorch, Tensorflow, Keras, JAX, HuggingFace, OpenAI, XGBoost, scikit-learn, etc. If you use a sklearn-compatible classifier, all cleanlab methods work out-of-the-box.
    @@ -121,7 +82,7 @@ It’s also easy to use your favorite non-sklearn-compatible model (click to cleanlab can find label issues from any model's predicted class probabilities if you can produce them yourself. -Some other cleanlab functionality requires your model to be sklearn-compatible. +Some cleanlab functionality may require your model to be sklearn-compatible. There's nothing you need to do if your model already has `.fit()`, `.predict()`, and `.predict_proba()` methods. Otherwise, just wrap your custom model into a Python class that inherits the `sklearn.base.BaseEstimator`: @@ -526,6 +487,28 @@ cleanlab is based on peer-reviewed research. Here are relevant papers to cite if
    +
    ActiveLab: Active learning with data re-labeling (ICLR '23) (click to show bibtex) + + @inproceedings{goh2023activelab, + title={ActiveLab: Active Learning with Re-Labeling by Multiple Annotators}, + author={Goh, Hui Wen and Mueller, Jonas}, + booktitle={ICLR Workshop on Trustworthy ML}, + year={2023} + } + +
    + +
    Incorrect Annotations in Multi-Label Classification (ICLR '23) (click to show bibtex) + + @inproceedings{thyagarajan2023multilabel, + title={Identifying Incorrect Annotations in Multi-Label Classification Data}, + author={Thyagarajan, Aditya and Snorrason, Elías and Northcutt, Curtis and Mueller, Jonas}, + booktitle={ICLR Workshop on Trustworthy ML}, + year={2023} + } + +
    + To understand/cite other cleanlab functionality not described above, check out our [additional publications](https://cleanlab.ai/research/). @@ -538,6 +521,8 @@ To understand/cite other cleanlab functionality not described above, check out o - [NeurIPS 2021 paper: Pervasive Label Errors in Test Sets Destabilize Machine Learning Benchmarks](https://arxiv.org/abs/2103.14749) +- [Release notes for past versions](https://github.com/cleanlab/cleanlab/releases) + - [Cleanlab Studio](https://cleanlab.ai/studio/?utm_source=github&utm_medium=readme&utm_campaign=clostostudio): No-code Data Improvement While this open-source library **finds** data issues, an interface is needed to efficiently **fix** these issues in your dataset. [Cleanlab Studio](https://cleanlab.ai/studio/?utm_source=github&utm_medium=readme&utm_campaign=clostostudio) is a no-code platform to find and fix problems in real-world ML datasets. Studio automatically runs optimized versions of the algorithms from this open-source library on top of AutoML models fit to your data, and presents detected issues in a smart data editing interface. Think of it like a data cleaning assistant that helps you quickly improve the quality of your data (via AI/automation + streamlined UX). @@ -555,14 +540,15 @@ While this open-source library **finds** data issues, an interface is needed to * Have an issue with cleanlab? [Search existing issues](https://github.com/cleanlab/cleanlab/issues?q=is%3Aissue) or [submit a new issue](https://github.com/cleanlab/cleanlab/issues/new). * Need professional help with cleanlab? -Join our [\#help Slack channel](https://cleanlab.ai/slack) and message one of our core developers, Jonas Mueller, or schedule a meeting via email: team@cleanlab.ai +Join our [\#help Slack channel](https://cleanlab.ai/slack) and message us there, or reach out via email: team@cleanlab.ai ## License -Copyright (c) 2017-2023 Cleanlab Inc. +Copyright (c) 2017 Cleanlab Inc. cleanlab is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. cleanlab is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See [GNU Affero General Public LICENSE](https://github.com/cleanlab/cleanlab/blob/master/LICENSE) for details. +You can email us to discuss licensing: team@cleanlab.ai From 229718da367f76c6d12a0910216734fb0a089316 Mon Sep 17 00:00:00 2001 From: Jonas Mueller <1390638+jwmueller@users.noreply.github.com> Date: Fri, 24 Mar 2023 10:25:06 -0700 Subject: [PATCH 140/258] formatting+typos --- docs/source/tutorials/faq.ipynb | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/docs/source/tutorials/faq.ipynb b/docs/source/tutorials/faq.ipynb index 6854a1d0c1..fc8c93fa16 100644 --- a/docs/source/tutorials/faq.ipynb +++ b/docs/source/tutorials/faq.ipynb @@ -215,15 +215,15 @@ "id": "bcc97591", "metadata": {}, "source": [ - "### How shoud I handle label errors in train vs test data?\n", + "### How should I handle label errors in train vs. test data?\n", "\n", - "If you do not address label errors in your test data, you may not even know when you have produced a better ML model because the evaluation is too noisy. For the best-trained models and most reliable evaluation of them, you should fix label errors in both your training and testing data.\n", + "If you do not address label errors in your test data, you may not even know when you have produced a better ML model because the evaluation is too noisy. For the best-trained models and most reliable evaluation of them, you should fix label errors in both training and testing data.\n", "\n", - "To do this efficiently, first use cleanlab to automatically find label issues in both sets. You can simply merge these two sets into one larger dataset and run cross-validation training + `find_label_issues()` on the merged datataset. Calling the [`CleanLearning.find_label_issues()`](../cleanlab/classification.html) method on your merged dataset does both these steps for you with any scikit-learn compatible classifier you choose.\n", + "To do this efficiently, first use cleanlab to automatically find label issues in both sets. You can simply merge these two sets into one larger dataset and run cross-validation training + `find_label_issues()` on the merged datataset. Calling the [CleanLearning.find_label_issues()](../cleanlab/classification.html) method on your merged dataset does both these steps for you with any scikit-learn compatible classifier you choose.\n", "\n", - "After finding the label issues, be **wary** about auto-correcting the labels for test examples (as cautioned against above). Instead make sure you are only manually fixing labels for your test data. You can use [Cleanlab Studio](https://cleanlab.ai/studio/) to fix labels efficiently.\n", + "After finding label issues, be **wary** about auto-correcting the labels for test examples (as cautioned against above). Instead manually fix the labels for your test data via careful review of the flagged issues. You can use [Cleanlab Studio](https://cleanlab.ai/studio/) to fix labels efficiently.\n", "\n", - "Auto-correcting labels for your training data is fair game, which should improve your ML performance. You can often boost ML performance further by manually fixing the training examples flagged with label issues, as demonstrated in this article:\n", + "Auto-correcting labels for your training data is fair game, which should improve ML performance (if properly evaluated with clean test labels). You can boost ML performance further by manually fixing the training examples flagged with label issues, as demonstrated in this article:\n", "\n", "[**Handling Mislabeled Tabular Data to Improve Your XGBoost Model**](https://cleanlab.ai/blog/label-errors-tabular-datasets/)" ] From 7519e5d1f29a7b0f90b1082a0b3333c5877d138e Mon Sep 17 00:00:00 2001 From: Jonas Mueller <1390638+jwmueller@users.noreply.github.com> Date: Mon, 27 Mar 2023 23:25:24 -0700 Subject: [PATCH 141/258] update version for 2.3.1 release (#658) --- cleanlab/version.py | 12 +++++------- docs/source/conf.py | 1 + 2 files changed, 6 insertions(+), 7 deletions(-) diff --git a/cleanlab/version.py b/cleanlab/version.py index c3ec42f9af..2103522c75 100644 --- a/cleanlab/version.py +++ b/cleanlab/version.py @@ -17,7 +17,11 @@ __version__ = "2.3.1" -# 2.3.1 - Not yet released, you are using bleeding-edge developer version. See its documentation at: https://docs.cleanlab.ai/master/ +# 2.3.2 - Not yet released, you are using bleeding-edge developer version. See its documentation at: https://docs.cleanlab.ai/master/ + +# ------------------------------------------------ +# | PREVIOUS MAJOR VERSION RELEASE NOTES SUMMARY | +# ------------------------------------------------ # 2.3.0 - Extending cleanlab beyond label errors into a complete library for data-centric AI # @@ -25,12 +29,6 @@ # - Active learning with data re-labeling (ActiveLab) # - KerasWrapperModel and KerasSequentialWrapper to make arbitrary Keras models compatible with scikit-learn # - Computational improvements for detecting label issues (better efficiency and mini-batch estimation that works with lower memory) -# -# See release for a full changelog. - -# ------------------------------------------ -# | PREVIOUS VERSION RELEASE NOTES SUMMARY | -# ------------------------------------------ # 2.2.0 - Re-invented algorithms for multi-label classification and support for datasets with missing classes # diff --git a/docs/source/conf.py b/docs/source/conf.py index 2665fc5a31..aa0522a279 100644 --- a/docs/source/conf.py +++ b/docs/source/conf.py @@ -147,6 +147,7 @@ # Add new tags to RELEASE_VERSIONS before release # fmt: off "RELEASE_VERSIONS": [ + "v2.3.1", "v2.3.0", "v2.2.0", "v2.1.0", From 29a930df374f2d28957312734809d3c55a2f07eb Mon Sep 17 00:00:00 2001 From: Jonas Mueller <1390638+jwmueller@users.noreply.github.com> Date: Wed, 29 Mar 2023 00:42:47 -0500 Subject: [PATCH 142/258] bump git version past stable version (#659) --- cleanlab/version.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cleanlab/version.py b/cleanlab/version.py index 2103522c75..5ec97902e3 100644 --- a/cleanlab/version.py +++ b/cleanlab/version.py @@ -15,7 +15,7 @@ # along with cleanlab. If not, see . -__version__ = "2.3.1" +__version__ = "2.3.2" # 2.3.2 - Not yet released, you are using bleeding-edge developer version. See its documentation at: https://docs.cleanlab.ai/master/ From 6e247d554349dfbcca4831b090f90556917f9304 Mon Sep 17 00:00:00 2001 From: Jonas Mueller <1390638+jwmueller@users.noreply.github.com> Date: Tue, 4 Apr 2023 02:44:49 -0700 Subject: [PATCH 143/258] link faq again at bottom of readme --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 2b75e6dab9..19dabd8b3b 100644 --- a/README.md +++ b/README.md @@ -537,7 +537,7 @@ While this open-source library **finds** data issues, an interface is needed to * Have code improvements for cleanlab? See the [development guide](DEVELOPMENT.md). -* Have an issue with cleanlab? [Search existing issues](https://github.com/cleanlab/cleanlab/issues?q=is%3Aissue) or [submit a new issue](https://github.com/cleanlab/cleanlab/issues/new). +* Have an issue with cleanlab? Search [our FAQ](https://docs.cleanlab.ai/stable/tutorials/faq.html) and [existing issues](https://github.com/cleanlab/cleanlab/issues?q=is%3Aissue), or [submit a new issue](https://github.com/cleanlab/cleanlab/issues/new). * Need professional help with cleanlab? Join our [\#help Slack channel](https://cleanlab.ai/slack) and message us there, or reach out via email: team@cleanlab.ai From 8cf089e1520c00c0d0a98477d988fb1559ad6f65 Mon Sep 17 00:00:00 2001 From: Jonas Mueller <1390638+jwmueller@users.noreply.github.com> Date: Tue, 4 Apr 2023 03:55:58 -0700 Subject: [PATCH 144/258] add section on practicing data-centric ai to readme (#660) --- README.md | 29 ++++++++++++++++++----------- 1 file changed, 18 insertions(+), 11 deletions(-) diff --git a/README.md b/README.md index 19dabd8b3b..de2b61b004 100644 --- a/README.md +++ b/README.md @@ -26,7 +26,7 @@ cleanlab.dataset.health_summary(labels, confident_joint=cl.confident_joint) Get started with: [documentation](https://docs.cleanlab.ai/), [tutorials](https://docs.cleanlab.ai/stable/tutorials/image.html), [examples](https://github.com/cleanlab/examples), and [blogs](https://cleanlab.ai/blog/). - Learn to run cleanlab on your data in 5 minutes for classification with: [image](https://docs.cleanlab.ai/stable/tutorials/image.html), [text](https://docs.cleanlab.ai/stable/tutorials/text.html), [audio](https://docs.cleanlab.ai/stable/tutorials/audio.html), or [tabular](https://docs.cleanlab.ai/stable/tutorials/tabular.html) data. -- Use cleanlab to automatically: [find mislabeled data + train robust models](https://docs.cleanlab.ai/stable/tutorials/indepth_overview.html), [detect outliers](https://docs.cleanlab.ai/stable/tutorials/outliers.html), [estimate consensus + annotator-quality for multi-annotator datasets](https://docs.cleanlab.ai/stable/tutorials/multiannotator.html), [suggest which data is best to (re)label next](https://github.com/cleanlab/examples/blob/master/active_learning_multiannotator/active_learning.ipynb). +- Use cleanlab to automatically: [find mislabeled data + train robust models](https://docs.cleanlab.ai/stable/tutorials/indepth_overview.html), [detect outliers](https://docs.cleanlab.ai/stable/tutorials/outliers.html), [estimate consensus + annotator-quality for multi-annotator datasets](https://docs.cleanlab.ai/stable/tutorials/multiannotator.html), [suggest which data is best to (re)label next (active learning)](https://github.com/cleanlab/examples/blob/master/active_learning_multiannotator/active_learning.ipynb). [![pypi](https://img.shields.io/pypi/v/cleanlab.svg)](https://pypi.org/pypi/cleanlab/) @@ -47,14 +47,10 @@ cleanlab **clean**s your data's **lab**els via state-of-the-art *confident learn cleanlab is: -1. **backed by theory** - - with [provable guarantees](https://arxiv.org/abs/1911.00068) of exact estimation of noise and label errors, even with imperfect models. -2. **fast** - - Code is parallelized and scalable. -4. **easy-to-use** - - Find mislabeled data, bad annotators, outliers, or train noise-robust models -- all in one line of code. -6. **general** - - Works with **[any dataset](https://labelerrors.com/)** (text, image, tabular, audio, ...) and **any model** (TensorFlow, PyTorch, JAX, HuggingFace, OpenAI, XGBoost, scikit-learn, ...) +1. **backed by theory** -- with [provable guarantees](https://arxiv.org/abs/1911.00068) of exact label noise estimation, even with imperfect models. +2. **fast** -- code is parallelized and scalable. +4. **easy to use** -- one line of code to find mislabeled data, bad annotators, outliers, or train noise-robust models. +6. **general** -- works with **[any dataset](https://labelerrors.com/)** (text, image, tabular, audio,...) + **any model** (PyTorch, OpenAI, XGBoost,...)
    ![](https://raw.githubusercontent.com/cleanlab/assets/master/cleanlab/label-errors-examples.png) @@ -70,6 +66,15 @@ cleanlab supports Linux, macOS, and Windows and runs on Python 3.7+. - Developers who install the bleeding-edge from source should refer to [this master branch documentation](https://docs.cleanlab.ai/master/index.html). - For help, check out our detailed [FAQ](https://docs.cleanlab.ai/stable/tutorials/faq.html), [Github Issues](https://github.com/cleanlab/cleanlab/issues?q=is%3Aissue), or [Slack](https://cleanlab.ai/slack). We welcome any questions! +**Practicing data-centric AI can look like this:** +1. Train initial ML model on original dataset. +2. Utilize this model to diagnose data issues (via cleanlab methods) and improve the dataset. +3. Train the same model on the improved dataset. +4. Try various modeling techniques to further improve performance. + +Most folks jump from Step 1 → 4, but you may achieve big gains without *any* change to your modeling code by using cleanlab! +Continuously boost performance by iterating Steps 2 → 4 (and try to evaluate with *cleaned* data). + ## Use cleanlab with any model for most ML tasks All features of cleanlab work with **any dataset** and **any model**. Yes, any model: PyTorch, Tensorflow, Keras, JAX, HuggingFace, OpenAI, XGBoost, scikit-learn, etc. @@ -126,13 +131,16 @@ cleanlab is useful across a wide variety of Machine Learning tasks. Specific tas 3. [Token classification](https://docs.cleanlab.ai/stable/tutorials/token_classification.html) (e.g. entity recognition in text) 4. [Classification with data labeled by multiple annotators](https://docs.cleanlab.ai/stable/tutorials/multiannotator.html) 5. [Active learning with multiple annotators](https://github.com/cleanlab/examples/blob/master/active_learning_multiannotator/active_learning.ipynb) (suggest which data to label or re-label to improve model most) -6. [Out of distribution detection](https://docs.cleanlab.ai/stable/tutorials/outliers.html) +6. [Outlier and out of distribution detection](https://docs.cleanlab.ai/stable/tutorials/outliers.html) For many other ML tasks, cleanlab can still help you improve your dataset if appropriately applied. ## Cool cleanlab applications +Many practical applications are demonstrated in our [Example Notebooks](https://github.com/cleanlab/examples). \ +After going through those, consider these more unusual use-cases of this package: +
    Reproducing results in Confident Learning paper (click to learn more) @@ -408,7 +416,6 @@ Now that you have `indices_of_label_errors`, you can remove those label issues a
    -Many other practical applications are demonstrated in our [Example Notebooks](https://github.com/cleanlab/examples) ## Citation and related publications From c4648483ca2ba80d61812b7f99f01cd0629ab07d Mon Sep 17 00:00:00 2001 From: Jonas Mueller <1390638+jwmueller@users.noreply.github.com> Date: Wed, 5 Apr 2023 00:59:33 -0700 Subject: [PATCH 145/258] clarify no class is also an option --- docs/source/tutorials/multilabel_classification.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/source/tutorials/multilabel_classification.ipynb b/docs/source/tutorials/multilabel_classification.ipynb index 6c40844957..b1b002975e 100644 --- a/docs/source/tutorials/multilabel_classification.ipynb +++ b/docs/source/tutorials/multilabel_classification.ipynb @@ -395,7 +395,7 @@ "source": [ "## 2. Format data, labels, and model predictions\n", "\n", - "In multi-label classification, each example in the dataset is labeled as belonging to one **or more** of *K* possible classes. To find label issues, cleanlab requires predicted class probabilities from a trained classifier. \n", + "In multi-label classification, each example in the dataset is labeled as belonging to one **or more** of *K* possible classes (or none of the classes at all). To find label issues, cleanlab requires predicted class probabilities from a trained classifier. \n", "Here we produce out-of-sample `pred_probs` by employing cross-validation to fit a multi-label **RandomForestClassifier** model via sklearn's [OneVsRestClassifier](https://scikit-learn.org/stable/modules/generated/sklearn.multiclass.OneVsRestClassifier.html) framework. `OneVsRestClassifier` offers an easy way to apply any multi-class classifier model from sklearn to multi-label classification tasks. It is done for simplicity here, but we advise against this approach as it does not properly model dependencies between classes.\n", "\n", "To instead train a state-of-the-art Pytorch neural network for multi-label classification and produce `pred_probs` on a real image dataset (that properly account for dependencies between classes), see our [example](https://github.com/cleanlab/examples) notebook [\"Train a neural network for multi-label classification on the CelebA dataset\"](https://github.com/cleanlab/examples/blob/master/multilabel_classification/pytorch_network_training.ipynb). " From 64c6cfcdd5f99ee26105e98b444075c650ca567c Mon Sep 17 00:00:00 2001 From: Hui Wen <45724323+huiwengoh@users.noreply.github.com> Date: Thu, 6 Apr 2023 00:21:17 -0400 Subject: [PATCH 146/258] Pass confident joint computed in CleanLearning to filter.find_label_issues (#661) --- cleanlab/classification.py | 7 ++++ tests/test_classification.py | 65 +++++++++++++++++++++++++++++++++++- 2 files changed, 71 insertions(+), 1 deletion(-) diff --git a/cleanlab/classification.py b/cleanlab/classification.py index c419ef5463..7f28042311 100644 --- a/cleanlab/classification.py +++ b/cleanlab/classification.py @@ -839,6 +839,7 @@ def find_label_issues( pred_probs=pred_probs, thresholds=thresholds, ) + # if pulearning == the integer specifying the class without noise. if self.num_classes == 2 and self.pulearning is not None: # pragma: no cover # pulearning = 1 (no error in 1 class) implies p(label=1|true_label=0) = 0 @@ -851,6 +852,12 @@ def find_label_issues( self.confident_joint[self.pulearning][1 - self.pulearning] = 0 self.confident_joint[1 - self.pulearning][1 - self.pulearning] = 1 + # Add confident joint to find label issue args if it is not previously specified + if "confident_joint" not in self.find_label_issues_kwargs.keys(): + # however does not add if users specify filter_by="confident_learning", as it will throw a warning + if not self.find_label_issues_kwargs.get("filter_by") == "confident_learning": + self.find_label_issues_kwargs["confident_joint"] = self.confident_joint + labels = labels_to_array(labels) if self.verbose: print("Using predicted probabilities to identify label issues ...") diff --git a/tests/test_classification.py b/tests/test_classification.py index 41c9a47b69..ca99bccd91 100644 --- a/tests/test_classification.py +++ b/tests/test_classification.py @@ -27,7 +27,11 @@ from cleanlab.benchmarking.noise_generation import generate_noise_matrix_from_trace from cleanlab.benchmarking.noise_generation import generate_noisy_labels from cleanlab.internal.latent_algebra import compute_inv_noise_matrix -from cleanlab.count import compute_confident_joint, estimate_cv_predicted_probabilities +from cleanlab.count import ( + compute_confident_joint, + estimate_cv_predicted_probabilities, + get_confident_thresholds, +) from cleanlab.filter import find_label_issues SEED = 1 @@ -776,6 +780,65 @@ def test_cj_in_find_label_issues_kwargs(filter_by, seed): assert num_issues[0] == num_issues[1] +def test_find_label_issues_uses_thresholds(): + X = DATA["X_train"] + labels = DATA["labels"] + pred_probs = estimate_cv_predicted_probabilities(X=X, labels=labels) + + confident_thresholds = get_confident_thresholds(labels=labels, pred_probs=pred_probs) + confident_joint = compute_confident_joint(labels=labels, pred_probs=pred_probs) + + # regular find label issues with no args + cl = CleanLearning() + label_issues_reg = cl.find_label_issues(labels=labels, pred_probs=pred_probs) + + # find label issues with specified confident thresholds + cl = CleanLearning() + label_issues_thres = cl.find_label_issues( + labels=labels, pred_probs=pred_probs, thresholds=confident_thresholds + ) + + # find label issues with specified confident joint + cl = CleanLearning( + find_label_issues_kwargs={ + "confident_joint": confident_joint, + } + ) + label_issues_cj = cl.find_label_issues(labels=labels, pred_probs=pred_probs) + + # the labels issues in above three calls should be the same + assert np.sum(label_issues_reg["is_label_issue"]) == np.sum( + label_issues_thres["is_label_issue"] + ) + assert np.sum(label_issues_reg["is_label_issue"]) == np.sum(label_issues_cj["is_label_issue"]) + + # find label issues with different specified confident thresholds + confident_thresholds_alt = np.full(pred_probs.shape[1], 0.25) + cl = CleanLearning() + label_issues_thres_alt = cl.find_label_issues( + labels=labels, pred_probs=pred_probs, thresholds=confident_thresholds_alt + ) + + # find label issues with different specified confident joint + confident_joint_alt = compute_confident_joint( + labels=labels, pred_probs=pred_probs, thresholds=confident_thresholds_alt + ) + cl = CleanLearning( + find_label_issues_kwargs={ + "confident_joint": confident_joint_alt, + } + ) + label_issues_cj_alt = cl.find_label_issues(labels=labels, pred_probs=pred_probs) + + # the number of issues for these 2 alt calls should be same as one another, but different from above 3 + assert np.sum(label_issues_thres_alt["is_label_issue"]) == np.sum( + label_issues_cj_alt["is_label_issue"] + ) + assert np.sum(label_issues_thres_alt["is_label_issue"]) != np.sum( + label_issues_reg["is_label_issue"] + ) + + def test_find_issues_missing_classes(): labels = np.array([0, 0, 2, 2]) pred_probs = np.array( From 352d904491425d866f51846fbd6df76831177ce5 Mon Sep 17 00:00:00 2001 From: Yiran Shi <60683228+Steven-Yiran@users.noreply.github.com> Date: Thu, 6 Apr 2023 00:29:22 -0400 Subject: [PATCH 147/258] Add Example codeblock to the docstrings of important functions in the dataset module (#662) Co-authored-by: Jonas Mueller <1390638+jwmueller@users.noreply.github.com> --- cleanlab/dataset.py | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+) diff --git a/cleanlab/dataset.py b/cleanlab/dataset.py index 78c9da670f..40d0222b91 100644 --- a/cleanlab/dataset.py +++ b/cleanlab/dataset.py @@ -139,6 +139,26 @@ def find_overlapping_classes( issues via the approach published in `Northcutt et al., 2021 `_. + Examples + -------- + >>> from cleanlab.dataset import find_overlapping_classes + >>> from sklearn.linear_model import LogisticRegression + >>> from sklearn.model_selection import cross_val_predict + >>> data, labels = get_data_labels_from_dataset(yourFavoriteDataset) + >>> yourFavoriteModel = LogisticRegression() + >>> num_crossval_folds = 3 + >>> pred_probs = cross_val_predict( + yourFavoriteModel, + data, + labels, + cv=num_crossval_folds, + method="predict_proba", + ) + >>> df = find_overlapping_classes( + labels=labels, + pred_probs=pred_probs, + ) # lists pairs of classes that are often mislabeled as one another + Note ---- The joint distribution of noisy and true labels is asymmetric, and therefore the joint From 6d67175e2af8b9a0bbde2c36421e537a8fb2c27c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?El=C3=ADas=20Snorrason?= Date: Fri, 7 Apr 2023 11:33:45 -0700 Subject: [PATCH 148/258] Extract function for computating ood scores from distances (#664) * extract distance-to-score computation to separate function * move function to a new internal.outlier module --- cleanlab/internal/outlier.py | 68 +++++++++++++++++++++++ cleanlab/outlier.py | 9 +-- docs/source/cleanlab/internal/index.rst | 1 + docs/source/cleanlab/internal/outlier.rst | 8 +++ 4 files changed, 80 insertions(+), 6 deletions(-) create mode 100644 cleanlab/internal/outlier.py create mode 100644 docs/source/cleanlab/internal/outlier.rst diff --git a/cleanlab/internal/outlier.py b/cleanlab/internal/outlier.py new file mode 100644 index 0000000000..57004a0a21 --- /dev/null +++ b/cleanlab/internal/outlier.py @@ -0,0 +1,68 @@ +# Copyright (C) 2017-2023 Cleanlab Inc. +# This file is part of cleanlab. +# +# cleanlab is free software: you can redistribute it and/or modify +# it under the terms of the GNU Affero General Public License as published +# by the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# cleanlab is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU Affero General Public License for more details. +# +# You should have received a copy of the GNU Affero General Public License +# along with cleanlab. If not, see . + +""" +Helper functions used internally for outlier detection tasks. +""" + +import numpy as np + + +def transform_distances_to_scores(distances: np.ndarray, k: int, t: int) -> np.ndarray: + """Returns an outlier score for each example based on its average distance to its k nearest neighbors. + + The transformation of a distance, :math:`d` , to a score, :math:`o` , is based on the following formula: + + .. math:: + o = \\exp\\left(-dt\\right) + + where :math:`t` scales the distance to a score in the range [0,1]. + + Parameters + ---------- + distances : np.ndarray + An array of distances of shape ``(N, num_neighbors)``, where N is the number of examples. + Each row contains the distances to each example's `num_neighbors` nearest neighbors. + It is assumed that each row is sorted in ascending order. + + k : int + Number of neighbors used to compute the average distance to each example. + This assumes that the second dimension of distances is k or greater, but it + uses slicing to avoid indexing errors. + + t : int + Controls transformation of distances between examples into similarity scores that lie in [0,1]. + + Returns + ------- + ood_features_scores : np.ndarray + An array of outlier scores of shape ``(N,)`` for N examples. + + Examples + -------- + >>> import numpy as np + >>> from cleanlab.outlier import transform_distances_to_scores + >>> distances = np.array([[0.0, 0.1, 0.25], + ... [0.15, 0.2, 0.3]]) + >>> transform_distances_to_scores(distances, k=2, t=1) + array([0.95122942, 0.83945702]) + """ + # Calculate average distance to k-nearest neighbors + avg_knn_distances = distances[:, :k].mean(axis=1) + + # Map ood_features_scores to range 0-1 with 0 = most concerning + ood_features_scores: np.ndarray = np.exp(-1 * avg_knn_distances * t) + return ood_features_scores diff --git a/cleanlab/outlier.py b/cleanlab/outlier.py index 0ac6ce5d4b..2e7950f34a 100644 --- a/cleanlab/outlier.py +++ b/cleanlab/outlier.py @@ -25,11 +25,12 @@ from cleanlab.count import get_confident_thresholds from sklearn.neighbors import NearestNeighbors from sklearn.exceptions import NotFittedError -from typing import Optional, Union, Tuple, Dict +from typing import Optional, Union, Tuple, Dict, cast from cleanlab.internal.label_quality_utils import ( _subtract_confident_thresholds, get_normalized_entropy, ) +from cleanlab.internal.outlier import transform_distances_to_scores from cleanlab.internal.validation import assert_valid_inputs, labels_to_array from cleanlab.typing import LabelLike @@ -446,11 +447,7 @@ def _get_ood_features_scores( # neighbor of each point is the point itself, at a distance of zero. distances, _ = knn.kneighbors(features) - # Calculate average distance to k-nearest neighbors - avg_knn_distances = distances[:, :k].mean(axis=1) - - # Map ood_features_scores to range 0-1 with 0 = most concerning - ood_features_scores: np.ndarray = np.exp(-1 * avg_knn_distances * t) + ood_features_scores = transform_distances_to_scores(distances, cast(int, k), t) return (ood_features_scores, knn) diff --git a/docs/source/cleanlab/internal/index.rst b/docs/source/cleanlab/internal/index.rst index 0601499cb4..6642479281 100644 --- a/docs/source/cleanlab/internal/index.rst +++ b/docs/source/cleanlab/internal/index.rst @@ -17,5 +17,6 @@ internal label_quality_utils multilabel_utils multilabel_scorer + outlier token_classification_utils validation diff --git a/docs/source/cleanlab/internal/outlier.rst b/docs/source/cleanlab/internal/outlier.rst new file mode 100644 index 0000000000..26c516758b --- /dev/null +++ b/docs/source/cleanlab/internal/outlier.rst @@ -0,0 +1,8 @@ +outlier +======= + +.. automodule:: cleanlab.internal.outlier + :autosummary: + :members: + :undoc-members: + :show-inheritance: From 2435a5a27fc7f7274b6bf388c184cc874fb5c142 Mon Sep 17 00:00:00 2001 From: Yiran Shi <60683228+Steven-Yiran@users.noreply.github.com> Date: Fri, 7 Apr 2023 20:42:13 -0400 Subject: [PATCH 149/258] Added code block examples for remaining methods in the cleanlab.dataset module (#663) Co-authored-by: Jonas Mueller <1390638+jwmueller@users.noreply.github.com> --- cleanlab/dataset.py | 62 ++++++++++++++++++++++++++++++++++++++++++--- 1 file changed, 59 insertions(+), 3 deletions(-) diff --git a/cleanlab/dataset.py b/cleanlab/dataset.py index 40d0222b91..f13a267817 100644 --- a/cleanlab/dataset.py +++ b/cleanlab/dataset.py @@ -54,6 +54,25 @@ def rank_classes_by_label_quality( Only provide **exactly one of the above input options**, do not provide a combination. + Examples + -------- + >>> from cleanlab.dataset import rank_classes_by_label_quality + >>> from sklearn.linear_model import LogisticRegression + >>> from sklearn.model_selection import cross_val_predict + >>> data, labels = get_data_labels_from_dataset(yourFavoriteDataset) + >>> yourFavoriteModel = LogisticRegression() + >>> pred_probs = cross_val_predict( + yourFavoriteModel, + data, + labels, + cv=3, + method="predict_proba", + ) # generate cross-validation estimates for each input data point + >>> df = rank_classes_by_label_quality( + labels=labels, + pred_probs=pred_probs, + ) # report overall label quality scores summarizing the examples annotated as each class + **Parameters**: For parameter info, see the docstring of :py:func:`find_overlapping_classes `. Returns @@ -146,14 +165,13 @@ def find_overlapping_classes( >>> from sklearn.model_selection import cross_val_predict >>> data, labels = get_data_labels_from_dataset(yourFavoriteDataset) >>> yourFavoriteModel = LogisticRegression() - >>> num_crossval_folds = 3 >>> pred_probs = cross_val_predict( yourFavoriteModel, data, labels, - cv=num_crossval_folds, + cv=3, method="predict_proba", - ) + ) # generate cross-validation estimates for each input data point >>> df = find_overlapping_classes( labels=labels, pred_probs=pred_probs, @@ -317,6 +335,25 @@ def overall_label_health_score( Only provide **exactly one of the above input options**, do not provide a combination. + Examples + -------- + >>> from cleanlab.dataset import overall_label_health_score + >>> from sklearn.linear_model import LogisticRegression + >>> from sklearn.model_selection import cross_val_predict + >>> data, labels = get_data_labels_from_dataset(yourFavoriteDataset) + >>> yourFavoriteModel = LogisticRegression() + >>> pred_probs = cross_val_predict( + yourFavoriteModel, + data, + labels, + cv=3, + method="predict_proba", + ) # generate cross-validation estimates for each input data point + >>> score = overall_label_health_score( + labels=labels, + pred_probs=pred_probs, + ) # a score measuring the overall quality of all labels in a dataset. + **Parameters**: For parameter info, see the docstring of :py:func:`find_overlapping_classes `. Returns @@ -372,6 +409,25 @@ def health_summary( Only provide **exactly one of the above input options**, do not provide a combination. + Examples + -------- + >>> from cleanlab.dataset import health_summary + >>> from sklearn.linear_model import LogisticRegression + >>> from sklearn.model_selection import cross_val_predict + >>> data, labels = get_data_labels_from_dataset(yourFavoriteDataset) + >>> yourFavoriteModel = LogisticRegression() + >>> pred_probs = cross_val_predict( + yourFavoriteModel, + data, + labels, + cv=3, + method="predict_proba", + ) # generate cross-validation estimates for each input data point + >>> summary = health_summary( + labels=labels, + pred_probs=pred_probs, + ) # dictionary summarizing the overall label quality of the classes in your dataset + **Parameters**: For parameter info, see the docstring of :py:func:`find_overlapping_classes `. Returns From 1e653def930889ce36f7b154506df62dd02873d4 Mon Sep 17 00:00:00 2001 From: Hui Wen <45724323+huiwengoh@users.noreply.github.com> Date: Tue, 11 Apr 2023 16:05:02 -0400 Subject: [PATCH 150/258] remove min batch size restriction in LabelInspector (#665) --- cleanlab/experimental/label_issues_batched.py | 2 -- tests/test_filter_count.py | 6 ++++++ 2 files changed, 6 insertions(+), 2 deletions(-) diff --git a/cleanlab/experimental/label_issues_batched.py b/cleanlab/experimental/label_issues_batched.py index 5cd395837f..ef11f91b65 100644 --- a/cleanlab/experimental/label_issues_batched.py +++ b/cleanlab/experimental/label_issues_batched.py @@ -744,8 +744,6 @@ def _batch_check(labels: LabelLike, pred_probs: np.ndarray, num_class: int) -> n """ batch_size = pred_probs.shape[0] labels = np.asarray(labels) - if batch_size < 10: - raise ValueError("Please run this with batches containing at least 10 examples.") if len(labels) != batch_size: raise ValueError("labels and pred_probs must have same length") if pred_probs.shape[1] != num_class: diff --git a/tests/test_filter_count.py b/tests/test_filter_count.py index 26c82c6214..e2cbf07bdd 100644 --- a/tests/test_filter_count.py +++ b/tests/test_filter_count.py @@ -921,12 +921,18 @@ def test_batched_label_issues(): batch_size=len(data["labels"]) + 100, n_jobs=4, ) + f5 = find_label_issues_batched( + labels=data["labels"], + pred_probs=data["pred_probs"], + batch_size=1, + ) f_single = find_label_issues_batched( labels=data["labels"], pred_probs=data["pred_probs"], batch_size=len(data["labels"]), n_jobs=1, ) + assert np.all(f4 == f5) assert np.all(f4 == f3) assert np.all(f4 == f2) assert np.all(f_single == f4) From f8c1866c58597d752d57f0b770a485dfc2023ef2 Mon Sep 17 00:00:00 2001 From: Aditya Thyagarajan Date: Fri, 14 Apr 2023 10:20:11 +0530 Subject: [PATCH 151/258] move methods to multilabel_classification module (#657) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit adds new dataset summarization methods for multilabel settings --------- Co-authored-by: Jonas Mueller <1390638+jwmueller@users.noreply.github.com> Co-authored-by: Elías Snorrason --- cleanlab/dataset.py | 47 +-- cleanlab/filter.py | 164 +-------- cleanlab/internal/multilabel_scorer.py | 2 +- cleanlab/multilabel_classification.py | 123 ------- .../multilabel_classification/__init__.py | 4 + cleanlab/multilabel_classification/dataset.py | 317 ++++++++++++++++++ cleanlab/multilabel_classification/filter.py | 258 ++++++++++++++ cleanlab/multilabel_classification/rank.py | 191 +++++++++++ .../tutorials/multilabel_classification.ipynb | 35 +- setup.cfg | 1 + tests/test_dataset.py | 10 + tests/test_filter_count.py | 38 ++- tests/test_multilabel_classification.py | 219 +++++++++++- 13 files changed, 1074 insertions(+), 335 deletions(-) delete mode 100644 cleanlab/multilabel_classification.py create mode 100644 cleanlab/multilabel_classification/__init__.py create mode 100644 cleanlab/multilabel_classification/dataset.py create mode 100644 cleanlab/multilabel_classification/filter.py create mode 100644 cleanlab/multilabel_classification/rank.py diff --git a/cleanlab/dataset.py b/cleanlab/dataset.py index f13a267817..cefe4b33e4 100644 --- a/cleanlab/dataset.py +++ b/cleanlab/dataset.py @@ -54,6 +54,9 @@ def rank_classes_by_label_quality( Only provide **exactly one of the above input options**, do not provide a combination. + **Parameters**: For information about the arguments to this method, see the documentation of + :py:func:`find_overlapping_classes `. + Examples -------- >>> from cleanlab.dataset import rank_classes_by_label_quality @@ -73,7 +76,6 @@ def rank_classes_by_label_quality( pred_probs=pred_probs, ) # report overall label quality scores summarizing the examples annotated as each class - **Parameters**: For parameter info, see the docstring of :py:func:`find_overlapping_classes `. Returns ------- @@ -95,13 +97,16 @@ def rank_classes_by_label_quality( By default, the DataFrame is ordered by "Label Quality Score", ascending. """ + if multi_label: + raise ValueError( + "For multilabel data, please instead call: multilabel_classification.dataset.overall_multilabel_health_score()" + ) if joint is None: joint = estimate_joint( labels=labels, pred_probs=pred_probs, confident_joint=confident_joint, - multi_label=multi_label, ) if num_examples is None: num_examples = _get_num_examples(labels=labels) @@ -242,12 +247,6 @@ class 0, 1, ..., K-1. `pred_probs` should have been computed using 3 (or The `confident_joint` can be computed using :py:func:`count.compute_confident_joint `. If not provided, it is computed from the given (noisy) `labels` and `pred_probs`. - multi_label : bool, optional - If ``True``, labels should be an iterable (e.g. list) of iterables, containing a - list of labels for each example, instead of just a single label. - The multi-label setting supports classification tasks where an example has 1 or more labels. - Example of a multi-labeled `labels` input: ``[[0,1], [1], [0,2], [0,1,2], [0], [1], ...]``. - Returns ------- overlapping_classes : pd.DataFrame @@ -279,12 +278,16 @@ def _2d_matrix_to_row_column_value_list(matrix): return [(*i, v) for i, v in np.ndenumerate(matrix)] + if multi_label: + raise ValueError( + "For multilabel data, please instead call: multilabel_classification.dataset.common_multilabel_issues()" + ) + if joint is None: joint = estimate_joint( labels=labels, pred_probs=pred_probs, confident_joint=confident_joint, - multi_label=multi_label, ) if num_examples is None: num_examples = _get_num_examples(labels=labels, confident_joint=confident_joint) @@ -335,6 +338,9 @@ def overall_label_health_score( Only provide **exactly one of the above input options**, do not provide a combination. + **Parameters**: For information about the arguments to this method, see the documentation of + :py:func:`find_overlapping_classes `. + Examples -------- >>> from cleanlab.dataset import overall_label_health_score @@ -354,21 +360,22 @@ def overall_label_health_score( pred_probs=pred_probs, ) # a score measuring the overall quality of all labels in a dataset. - **Parameters**: For parameter info, see the docstring of :py:func:`find_overlapping_classes `. - Returns ------- health_score : float A score between 0 and 1, where 1 implies all labels in the dataset are estimated to be correct. A score of 0.5 implies that half of the dataset's labels are estimated to have issues. """ + if multi_label: + raise ValueError( + "For multilabel data, please instead call: multilabel_classification.dataset.overall_multilabel_health_score()" + ) if joint is None: joint = estimate_joint( labels=labels, pred_probs=pred_probs, confident_joint=confident_joint, - multi_label=multi_label, ) if num_examples is None: num_examples = _get_num_examples(labels=labels) @@ -409,6 +416,9 @@ def health_summary( Only provide **exactly one of the above input options**, do not provide a combination. + **Parameters**: For information about the arguments to this method, see the documentation of + :py:func:`find_overlapping_classes `. + Examples -------- >>> from cleanlab.dataset import health_summary @@ -428,7 +438,6 @@ def health_summary( pred_probs=pred_probs, ) # dictionary summarizing the overall label quality of the classes in your dataset - **Parameters**: For parameter info, see the docstring of :py:func:`find_overlapping_classes `. Returns ------- @@ -442,12 +451,15 @@ def health_summary( """ from cleanlab.internal.util import smart_display_dataframe + if multi_label: + raise ValueError( + "For multilabel data, please call multilabel_classification.dataset.health_summary" + ) if joint is None: joint = estimate_joint( labels=labels, pred_probs=pred_probs, confident_joint=confident_joint, - multi_label=multi_label, ) if num_examples is None: num_examples = _get_num_examples(labels=labels) @@ -474,7 +486,6 @@ def health_summary( num_examples=num_examples, joint=joint, confident_joint=confident_joint, - multi_label=multi_label, ) if verbose: print("Overall Class Quality and Noise across your dataset (below)") @@ -489,7 +500,6 @@ def health_summary( num_examples=num_examples, joint=joint, confident_joint=confident_joint, - multi_label=multi_label, ) if verbose: print( @@ -508,7 +518,6 @@ def health_summary( num_examples=num_examples, joint=joint, confident_joint=confident_joint, - multi_label=multi_label, verbose=verbose, ) if verbose: @@ -525,9 +534,7 @@ def _get_num_examples(labels=None, confident_joint: Optional[np.ndarray] = None) """Helper method that finds the number of examples from the parameters or throws an error if neither parameter is provided. - Parameters - ---------- - For parameter info, see the docstring of `dataset.find_overlapping_classes` + **Parameters:** For information about the arguments to this method, see the documentation of `dataset.find_overlapping_classes` Returns ------- diff --git a/cleanlab/filter.py b/cleanlab/filter.py index e6f2cc803d..70b2d8d5da 100644 --- a/cleanlab/filter.py +++ b/cleanlab/filter.py @@ -17,10 +17,9 @@ """ Methods to identify which examples have label issues in a classification dataset. The documentation below assumes a dataset with ``N`` examples and ``K`` classes. -This module considers two types of datasets: - -* standard (multi-class) classification where each example is labeled as belonging to exactly one of K classes (e.g. ``labels = np.array([0,0,1,0,2,1])``) -* multi-label classification where each example can be labeled as belonging to multiple classes (e.g. ``labels = [[1,2],[1],[0],[],...]``) +This module is for standard (multi-class) classification where each example is labeled as belonging to exactly one of K classes (e.g. ``labels = np.array([0,0,1,0,2,1])``). +Some methods here also work for multi-label classification data where each example can be labeled as belonging to multiple classes (e.g. ``labels = [[1,2],[1],[0],[],...]``), +but we encourage using the methods in the ``cleanlab.multilabel_classification`` module instead for such data. """ import numpy as np @@ -28,7 +27,7 @@ import multiprocessing import sys import warnings -from typing import Any, Dict, List, Optional, Tuple, Union +from typing import Any, Dict, Optional, Tuple, List from functools import reduce import platform @@ -43,6 +42,7 @@ ) from cleanlab.internal.multilabel_utils import stack_complement, get_onehot_num_classes, int2onehot from cleanlab.typing import LabelLike +from cleanlab.multilabel_classification.filter import find_multilabel_issues_per_class # tqdm is a package to print time-to-complete when multiprocessing is used. # This package is not necessary, but when installed improves user experience for large datasets. @@ -77,13 +77,13 @@ def find_label_issues( return_indices_ranked_by: Optional[str] = None, rank_by_kwargs: Optional[Dict[str, Any]] = None, filter_by: str = "prune_by_noise_rate", - multi_label: bool = False, frac_noise: float = 1.0, - num_to_remove_per_class: Optional[int] = None, + num_to_remove_per_class: Optional[List[int]] = None, min_examples_per_class=1, confident_joint: Optional[np.ndarray] = None, n_jobs: Optional[int] = None, verbose: bool = False, + multi_label: bool = False, ) -> np.ndarray: """ Identifies potentially bad labels in a classification dataset using confident learning. @@ -109,8 +109,6 @@ def find_label_issues( *Format requirements*: for dataset with K classes, each label must be integer in 0, 1, ..., K-1. For a standard (multi-class) classification dataset where each example is labeled with one class, `labels` should be 1D array of shape ``(N,)``, for example: ``labels = [1,0,2,1,1,0...]``. - For a multi-label classification dataset where each example can belong to multiple (or no) classes, - `labels` should be an iterable of iterables (e.g. ``List[List[int]]``) whose i-th element corresponds to list of classes that i-th example belongs to (e.g. ``labels = [[1,2],[1],[0],[],...]``). pred_probs : np.ndarray, optional An array of shape ``(N, K)`` of model-predicted class probabilities, @@ -150,13 +148,6 @@ class 0, 1, ..., K-1. - ``'low_normalized_margin'``: filters the examples with *smallest* normalized margin label quality score. The number of issues returned matches :py:func:`count.num_label_issues `. - ``'low_self_confidence'``: filters the examples with *smallest* self confidence label quality score. The number of issues returned matches :py:func:`count.num_label_issues `. - multi_label : bool, optional - If ``True``, labels should be an iterable (e.g. list) of iterables, containing a - list of class labels for each example, instead of just a single label. - The multi-label setting supports classification tasks where an example can belong to more than 1 class or none of the classes (rather than exactly one class as in standard multi-class classification). - Example of a multi-labeled `labels` input: ``[[0,1], [1], [0,2], [0,1,2], [0], [1], [], ...]``. This says the first example in dataset belongs to both class 0 and class 1, according to its given label. - Each row of `pred_probs` no longer needs to sum to 1 in multi-label settings, since one example can now belong to multiple classes simultaneously. - frac_noise : float, default=1.0 Used to only return the "top" ``frac_noise * num_label_issues``. The choice of which "top" label issues to return is dependent on the `filter_by` method used. It works by reducing the @@ -167,7 +158,6 @@ class 0, 1, ..., K-1. When ``frac_noise=1.0``, return all "confident" estimated noise indices (recommended). frac_noise * number_of_mislabeled_examples_in_class_k. - Note: specifying `frac_noise` is not yet supported if `multi_label` is True. num_to_remove_per_class : array_like An iterable of length K, the number of classes. @@ -195,7 +185,6 @@ class 0, 1, ..., K-1. Entry ``(j, k)`` in the matrix is the number of examples confidently counted into the pair of ``(noisy label=j, true label=k)`` classes. The `confident_joint` can be computed using :py:func:`count.compute_confident_joint `. If not provided, it is computed from the given (noisy) `labels` and `pred_probs`. - If `multi_label` is True, `confident_joint` should instead be a one-vs-rest array with shape ``(K, 2, 2)`` as returned by :py:func:`count.compute_confident_joint ` function. n_jobs : optional Number of processing threads used by multiprocessing. Default ``None`` @@ -312,7 +301,10 @@ class 0, 1, ..., K-1. if multi_label: if not isinstance(labels, list): raise TypeError("`labels` must be list when `multi_label=True`.") - + warnings.warn( + "The multi_label argument to filter.find_label_issues() is deprecated and will be removed in future versions. Please use `multilabel_classification.filter.find_label_issues()` instead.", + DeprecationWarning, + ) return _find_label_issues_multilabel( labels, pred_probs, @@ -482,7 +474,7 @@ def _find_label_issues_multilabel( rank_by_kwargs={}, filter_by: str = "prune_by_noise_rate", frac_noise: float = 1.0, - num_to_remove_per_class: Optional[int] = None, + num_to_remove_per_class: Optional[List[int]] = None, min_examples_per_class=1, confident_joint: Optional[np.ndarray] = None, n_jobs: Optional[int] = None, @@ -493,7 +485,6 @@ def _find_label_issues_multilabel( This is done via a one-vs-rest reduction for each class and the results are subsequently aggregated across all classes. Here `labels` must be formatted as an iterable of iterables, e.g. ``List[List[int]]``. """ - if filter_by in ["low_normalized_margin", "low_self_confidence"]: num_errors = sum( find_label_issues( @@ -529,7 +520,7 @@ def _find_label_issues_multilabel( return label_issues_mask - per_class_issues = _find_multilabel_issues_per_class( + per_class_issues = find_multilabel_issues_per_class( labels, pred_probs, return_indices_ranked_by, @@ -561,132 +552,6 @@ def _find_label_issues_multilabel( return label_issues_idx[np.argsort(label_quality_scores_issues)] -def _find_multilabel_issues_per_class( - labels: list, - pred_probs: np.ndarray, - return_indices_ranked_by: Optional[str] = None, - rank_by_kwargs={}, - filter_by: str = "prune_by_noise_rate", - frac_noise: float = 1.0, - num_to_remove_per_class: Optional[int] = None, - min_examples_per_class=1, - confident_joint: Optional[np.ndarray] = None, - n_jobs: Optional[int] = None, - verbose: bool = False, -) -> Union[np.ndarray, Tuple[List[np.ndarray], List[Any], List[np.ndarray]]]: - """ - Parameters - ---------- - labels : List[List[int]] - List of noisy labels for multi-label classification where each example can belong to multiple classes (e.g. ``labels = [[1,2],[1],[0],[],...]`` indicates the first example in dataset belongs to both class 1 and class 2. - - - pred_probs : np.ndarray - An array of shape ``(N, K)`` of model-predicted probabilities, - ``P(label=k|x)``. Each row of this matrix corresponds - to an example `x` and contains the model-predicted probabilities that - `x` belongs to each possible class, for each of the K classes. The - columns must be ordered such that these probabilities correspond to - class 0, 1, ..., K-1. They need not sum to 1.0 - - - return_indices_ranked_by : {None, 'self_confidence', 'normalized_margin', 'confidence_weighted_entropy'}, default=None - Refer to documentation for this argument in filter.find_label_issues() for details. - - rank_by_kwargs : dict, optional - Refer to documentation for this argument in filter.find_label_issues() for details. - - filter_by : {'prune_by_class', 'prune_by_noise_rate', 'both', 'confident_learning', 'predicted_neq_given', - 'low_normalized_margin', 'low_self_confidence'}, default='prune_by_noise_rate' - Refer to documentation for this argument in filter.find_label_issues() for details. - - frac_noise : float, default=1.0 - Refer to documentation for this argument in filter.find_label_issues() for details. - - num_to_remove_per_class : array_like - Refer to documentation for this argument in filter.find_label_issues() for details. - - min_examples_per_class : int, default=1 - Refer to documentation for this argument in filter.find_label_issues() for details. - - confident_joint : np.ndarray, optional - An array of shape ``(K, 2, 2)`` representing a one-vs-rest formatted confident joint. - Entry ``(c, i, j)`` in this array is the number of examples confidently counted into a ``(class c, noisy label=i, true label=j)`` bin, - where `i, j` are either 0 or 1 to denote whether this example belongs to class `c` or not - (recall examples can belong to multiple classes in multi-label classification). - The `confident_joint` can be computed using :py:func:`count.compute_confident_joint `. - If not provided, it is computed from the given (noisy) `labels` and `pred_probs`. - - n_jobs : optional - Refer to documentation for this argument in filter.find_label_issues() for details. - - verbose : optional - If ``True``, prints when multiprocessing happens. - - Returns - ------- - per_class_label_issues : list(np.ndarray) - If `return_indices_ranked_by` left unspecified, returns a list of boolean **masks** for the entire dataset - where ``True`` represents a label issue and ``False`` represents an example that is - accurately labeled with high confidence. - If `return_indices_ranked_by` is specified, returns a list of shorter arrays of **indices** of examples identified to have - label issues (i.e. those indices where the mask would be ``True``), sorting by likelihood that the corresponding label is correct is not supported yet. - - Note - ---- - Obtain the *indices* of label issues in your dataset by setting - `return_indices_ranked_by`. - - """ - y_one, num_classes = get_onehot_num_classes(labels, pred_probs) - if return_indices_ranked_by is None: - bissues = np.zeros(y_one.shape).astype(bool) - else: - label_issues_list = [] - labels_list = [] - pred_probs_list = [] - if confident_joint is not None: - confident_joint_shape = confident_joint.shape - if confident_joint_shape == (num_classes, num_classes): - warnings.warn( - f"The new recommended format for `confident_joint` in multi_label settings is (num_classes,2,2) as output by compute_confident_joint(...,multi_label=True). Your K x K confident_joint in the old format is being ignored." - ) - confident_joint = None - elif confident_joint_shape != (num_classes, 2, 2): - raise ValueError("confident_joint should be of shape (num_classes, 2, 2)") - for class_num, (label, pred_prob_for_class) in enumerate(zip(y_one.T, pred_probs.T)): - pred_probs_binary = stack_complement(pred_prob_for_class) - if confident_joint is None: - conf = None - else: - conf = confident_joint[class_num] - binary_label_issues = find_label_issues( - labels=label, - pred_probs=pred_probs_binary, - return_indices_ranked_by=return_indices_ranked_by, - frac_noise=frac_noise, - rank_by_kwargs=rank_by_kwargs, - filter_by=filter_by, - multi_label=False, - num_to_remove_per_class=num_to_remove_per_class, - min_examples_per_class=min_examples_per_class, - confident_joint=conf, - n_jobs=n_jobs, - verbose=verbose, - ) - - if return_indices_ranked_by is None: - bissues[:, class_num] = binary_label_issues - else: - label_issues_list.append(binary_label_issues) - labels_list.append(label) - pred_probs_list.append(pred_probs_binary) - if return_indices_ranked_by is None: - return bissues - else: - return label_issues_list, labels_list, pred_probs_list - - def _keep_at_least_n_per_class( prune_count_matrix: np.ndarray, n: int, *, frac_noise: float = 1.0 ) -> np.ndarray: @@ -897,9 +762,6 @@ class 0, 1, ..., K-1. `pred_probs` should have been computed using 3 (or label issue and ``False`` represents an example that is accurately labeled with high confidence. - Note - ---- - Multi-label classification is not supported in this method. """ assert_valid_inputs(X=None, y=labels, pred_probs=pred_probs, multi_label=False) diff --git a/cleanlab/internal/multilabel_scorer.py b/cleanlab/internal/multilabel_scorer.py index dd58312a2f..4ad836d283 100644 --- a/cleanlab/internal/multilabel_scorer.py +++ b/cleanlab/internal/multilabel_scorer.py @@ -488,7 +488,7 @@ def get_class_label_quality_scores( >>> labels = np.array([[0, 1, 0], [1, 0, 1]]) >>> pred_probs = np.array([[0.1, 0.9, 0.7], [0.4, 0.1, 0.6]]) >>> scorer = MultilabelScorer() # Use the default base scorer (SELF_CONFIDENCE) - >>> class_label_quality_scores = scorer.get_class_label_quality_scores(labels, pred_probs) + >>> class_label_quality_scores = scorer.get_label_quality_scores_per_class(labels, pred_probs) >>> class_label_quality_scores array([[0.9, 0.9, 0.3], [0.4, 0.9, 0.6]]) diff --git a/cleanlab/multilabel_classification.py b/cleanlab/multilabel_classification.py deleted file mode 100644 index b49b6203da..0000000000 --- a/cleanlab/multilabel_classification.py +++ /dev/null @@ -1,123 +0,0 @@ -# Copyright (C) 2017-2023 Cleanlab Inc. -# This file is part of cleanlab. -# -# cleanlab is free software: you can redistribute it and/or modify -# it under the terms of the GNU Affero General Public License as published -# by the Free Software Foundation, either version 3 of the License, or -# (at your option) any later version. -# -# cleanlab is distributed in the hope that it will be useful, -# but WITHOUT ANY WARRANTY; without even the implied warranty of -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -# GNU Affero General Public License for more details. -# -# You should have received a copy of the GNU Affero General Public License -# along with cleanlab. If not, see . - -""" -Methods to rank the severity of label issues in multi-label classification datasets. -Here each example can belong to one or more classes, or none of the classes at all. -Unlike in standard multi-class classification, predicted class probabilities from model need not sum to 1 for each row in multi-label classification. -""" - -import numpy as np # noqa: F401: Imported for type annotations -import numpy.typing as npt -from typing import List, TypeVar, Dict, Any - -from cleanlab.internal.validation import assert_valid_inputs -from cleanlab.internal.util import get_num_classes -from cleanlab.internal.multilabel_scorer import MultilabelScorer, ClassLabelScorer, Aggregator -from cleanlab.internal.multilabel_utils import int2onehot - - -T = TypeVar("T", bound=npt.NBitBase) - - -def get_label_quality_scores( - labels: List[List[int]], - pred_probs: npt.NDArray["np.floating[T]"], - *, - method: str = "self_confidence", - adjust_pred_probs: bool = False, - aggregator_kwargs: Dict[str, Any] = {"method": "exponential_moving_average", "alpha": 0.8} -) -> npt.NDArray["np.floating[T]"]: - """Computes a label quality score each example in a multi-label classification dataset. - - Scores are between 0 and 1 with lower scores indicating examples whose label more likely contains an error. - For each example, this method internally computes a separate score for each individual class - and then aggregates these per-class scores into an overall label quality score for the example. - - To estimate exactly which examples are mislabeled in a multi-label classification dataset, - you can also use :py:func:`filter.find_label_issues ` with argument ``multi_label=True``. - - Parameters - ---------- - labels : List[List[int]] - Multi-label classification labels for each example, which is allowed to belong to multiple classes. - The i-th element of `labels` corresponds to list of classes that i-th example belongs to (e.g. ``labels = [[1,2],[1],[0],..]``). - - Important - --------- - *Format requirements*: For dataset with K classes, individual class labels must be integers in 0, 1, ..., K-1. - - pred_probs : np.ndarray - A 2D array of shape ``(N, K)`` of model-predicted class probabilities ``P(label=k|x)``. - Each row of this matrix corresponds to an example `x` and contains the predicted probabilities - that `x` belongs to each possible class, for each of the K classes. - The columns of this array must be ordered such that these probabilities correspond to class 0, 1, ..., K-1. - In multi-label classification (where classes are not mutually exclusive), the rows of `pred_probs` need not sum to 1. - - Note - ---- - Estimated label quality scores are most accurate when they are computed based on out-of-sample ``pred_probs`` from your model. - To obtain out-of-sample predicted probabilities for every example in your dataset, you can use :ref:`cross-validation `. - This is encouraged to get better results. - - method : {"self_confidence", "normalized_margin", "confidence_weighted_entropy"}, default = "self_confidence" - Method to calculate separate per class annotation scores that are subsequently aggregated to form an overall label quality score. - These scores are separately calculated for each class based on the corresponding column of `pred_probs` in a one-vs-rest manner, - and are standard label quality scores for multi-class classification. - - See also - -------- - :py:func:`rank.get_label_quality_scores ` function for details about each option. - - adjust_pred_probs : bool, default = False - Account for class imbalance in the label-quality scoring by adjusting predicted probabilities - via subtraction of class confident thresholds and renormalization. - Set this to ``True`` if you prefer to account for class-imbalance. - See `Northcutt et al., 2021 `_. - - aggregator_kwargs : dict, default = {"method": "exponential_moving_average", "alpha": 0.8} - A dictionary of hyperparameter values for aggregating per class scores into an overall label quality score for each example. - Options for ``"method"`` include: ``"exponential_moving_average"`` or ``"softmin"`` or your own callable function. - See :py:class:`internal.multilabel_scorer.Aggregator ` for details about each option and other possible hyperparameters. - - Returns - ------- - label_quality_scores : np.ndarray - A 1D array of shape ``(N,)`` with a label quality score (between 0 and 1) for each example in the dataset. - Lower scores indicate examples whose label is more likely to contain annotation errors. - - - Examples - -------- - >>> from cleanlab.multilabel_classification import get_label_quality_scores - >>> import numpy as np - >>> labels = [[1], [0,2]] - >>> pred_probs = np.array([[0.1, 0.9, 0.1], [0.4, 0.1, 0.9]]) - >>> scores = get_label_quality_scores(labels, pred_probs) - >>> scores - array([0.9, 0.5]) - """ - - assert_valid_inputs( - X=None, y=labels, pred_probs=pred_probs, multi_label=True, allow_one_class=True - ) - num_classes = get_num_classes(labels=labels, pred_probs=pred_probs, multi_label=True) - binary_labels = int2onehot(labels, K=num_classes) - base_scorer = ClassLabelScorer.from_str(method) - base_scorer_kwargs = {"adjust_pred_probs": adjust_pred_probs} - aggregator = Aggregator(**aggregator_kwargs) - scorer = MultilabelScorer(base_scorer, aggregator) - return scorer(binary_labels, pred_probs, base_scorer_kwargs=base_scorer_kwargs) diff --git a/cleanlab/multilabel_classification/__init__.py b/cleanlab/multilabel_classification/__init__.py new file mode 100644 index 0000000000..fcddecdb5d --- /dev/null +++ b/cleanlab/multilabel_classification/__init__.py @@ -0,0 +1,4 @@ +from .rank import get_label_quality_scores +from . import rank +from . import dataset +from . import filter diff --git a/cleanlab/multilabel_classification/dataset.py b/cleanlab/multilabel_classification/dataset.py new file mode 100644 index 0000000000..e3987a5ece --- /dev/null +++ b/cleanlab/multilabel_classification/dataset.py @@ -0,0 +1,317 @@ +import pandas as pd +import numpy as np +from typing import Optional, cast, Dict, Any # noqa: F401 +from cleanlab.multilabel_classification.filter import ( + find_multilabel_issues_per_class, + find_label_issues, +) +from cleanlab.internal.multilabel_utils import get_onehot_num_classes +from collections import defaultdict + + +def common_multilabel_issues( + labels=list, + pred_probs=None, + *, + class_names=None, + confident_joint=None, +) -> pd.DataFrame: + """Summarizes which classes in a multi-label dataset appear most often mislabeled overall. + + Since classes are not mutually exclusive in multi-label classification, this method summarizes the label issues for each class independently of the others. + + Parameters + ---------- + labels : List[List[int]] + List of noisy labels for multi-label classification where each example can belong to multiple classes. + Refer to documentation for this argument in :py:func:`multilabel_classification.filter.find_label_issues ` for further details. + + pred_probs : np.ndarray + An array of shape ``(N, K)`` of model-predicted class probabilities. + Refer to documentation for this argument in :py:func:`multilabel_classification.filter.find_label_issues ` for further details. + + class_names : Iterable[str], optional + A list or other iterable of the string class names. Its order must match the label indices. + If class 0 is 'dog' and class 1 is 'cat', then ``class_names = ['dog', 'cat']``. + If provided, the returned DataFrame will have an extra *Class Name* column with this info. + + confident_joint : np.ndarray, optional + An array of shape ``(K, 2, 2)`` representing a one-vs-rest formatted confident joint. + Refer to documentation for this argument in :py:func:`multilabel_classification.filter.find_label_issues ` for details. + + Returns + ------- + common_multilabel_issues : pd.DataFrame + DataFrame where each row corresponds to a class summarized by the following columns: + + * *Class Name*: The name of the class if class_names is provided. + * *Class Index*: The index of the class. + * *In Given Label*: Whether the Class is originally annotated True or False in the given label. + * *In Suggested Label*: Whether the Class should be True or False in the suggested label (based on model's prediction). + * *Num Examples*: Number of examples flagged as a label issue where this Class is True/False "In Given Label" but cleanlab estimates the annotation should actually be as specified "In Suggested Label". I.e. the number of examples in your dataset where this Class was labeled as True but likely should have been False (or vice versa). + * *Issue Probability*: The *Num Examples* column divided by the total number of examples in the dataset; i.e. the relative overall frequency of each type of label issue in your dataset. + + By default, the rows in this DataFrame are ordered by "Issue Probability" (descending). + """ + + num_examples = _get_num_examples_multilabel(labels=labels, confident_joint=confident_joint) + summary_issue_counts = defaultdict(list) + y_one, num_classes = get_onehot_num_classes(labels, pred_probs) + label_issues_list, labels_list, pred_probs_list = find_multilabel_issues_per_class( + labels=labels, + pred_probs=pred_probs, + confident_joint=confident_joint, + return_indices_ranked_by="self_confidence", + ) + + for class_num, (label, issues_for_class) in enumerate(zip(y_one.T, label_issues_list)): + binary_label_issues = np.zeros(len(label)).astype(bool) + binary_label_issues[issues_for_class] = True + true_but_false_count = sum(np.logical_and(label == 1, binary_label_issues)) + false_but_true_count = sum(np.logical_and(label == 0, binary_label_issues)) + + if class_names is not None: + summary_issue_counts["Class Name"].append(class_names[class_num]) + summary_issue_counts["Class Index"].append(class_num) + summary_issue_counts["In Given Label"].append(True) + summary_issue_counts["In Suggested Label"].append(False) + summary_issue_counts["Num Examples"].append(true_but_false_count) + summary_issue_counts["Issue Probability"].append(true_but_false_count / num_examples) + + if class_names is not None: + summary_issue_counts["Class Name"].append(class_names[class_num]) + summary_issue_counts["Class Index"].append(class_num) + summary_issue_counts["In Given Label"].append(False) + summary_issue_counts["In Suggested Label"].append(True) + summary_issue_counts["Num Examples"].append(false_but_true_count) + summary_issue_counts["Issue Probability"].append(false_but_true_count / num_examples) + return ( + pd.DataFrame.from_dict(summary_issue_counts) + .sort_values(by=["Issue Probability"], ascending=False) + .reset_index(drop=True) + ) + + +def rank_classes_by_multilabel_quality( + labels=None, + pred_probs=None, + *, + class_names=None, + joint=None, + confident_joint=None, +) -> pd.DataFrame: + """ + Returns a DataFrame with three overall label quality scores per class for a multi-label dataset. + + These numbers summarize all examples annotated with the class (details listed below under the Returns parameter). + By default, classes are ordered by "Label Quality Score", so the most problematic classes are reported first in the DataFrame. + + Score values are unnormalized and may be very small. What matters is their relative ranking across the classes. + + **Parameters**: For information about the arguments to this method, see the documentation of + :py:func:`common_multilabel_issues `. + + Returns + ------- + overall_label_quality : pd.DataFrame + Pandas DataFrame with one row per class and columns: "Class Index", "Label Issues", + "Inverse Label Issues", "Label Issues", "Inverse Label Noise", "Label Quality Score". + Some entries are overall quality scores between 0 and 1, summarizing how good overall the labels + appear to be for that class (lower values indicate more erroneous labels). + Other entries are estimated counts of annotation errors related to this class. + Here is what each column represents: + + * *Class Name*: The name of the class if class_names is provided. + * *Class Index*: The index of the class in 0, 1, ..., K-1. + * *Label Issues*: Estimated number of examples in the dataset that are labeled as belonging to class k but actually should not belong to this class. + * *Inverse Label Issues*: Estimated number of examples in the dataset that should actually be labeled as class k but did not receive this label. + * *Label Noise*: Estimated proportion of examples in the dataset that are labeled as class k but should not be. For each class k: this is computed by dividing the number of examples with "Label Issues" that were labeled as class k by the total number of examples labeled as class k. + * *Inverse Label Noise*: Estimated proportion of examples in the dataset that should actually be labeled as class k but did not receive this label. + * *Label Quality Score*: Estimated proportion of examples labeled as class k that have been labeled correctly, i.e. ``1 - label_noise``. + + By default, the DataFrame is ordered by "Label Quality Score" (in ascending order), so the classes with the most label issues appear first. + """ + + issues_df = common_multilabel_issues( + labels=labels, pred_probs=pred_probs, class_names=class_names, confident_joint=joint + ) + issues_dict = defaultdict(defaultdict) # type: Dict[str, Any] + num_examples = _get_num_examples_multilabel(labels=labels, confident_joint=confident_joint) + return_columns = [ + "Class Name", + "Class Index", + "Label Issues", + "Inverse Label Issues", + "Label Noise", + "Inverse Label Noise", + "Label Quality Score", + ] + if class_names is None: + return_columns = return_columns[1:] + for class_num, row in issues_df.iterrows(): + if row["In Given Label"]: + if class_names is not None: + issues_dict[row["Class Index"]]["Class Name"] = row["Class Name"] + issues_dict[row["Class Index"]]["Label Issues"] = int( + row["Issue Probability"] * num_examples + ) + issues_dict[row["Class Index"]]["Label Noise"] = row["Issue Probability"] + issues_dict[row["Class Index"]]["Label Quality Score"] = ( + 1 - issues_dict[row["Class Index"]]["Label Noise"] + ) + else: + if class_names is not None: + issues_dict[row["Class Index"]]["Class Name"] = row["Class Name"] + issues_dict[row["Class Index"]]["Inverse Label Issues"] = int( + row["Issue Probability"] * num_examples + ) + issues_dict[row["Class Index"]]["Inverse Label Noise"] = row["Issue Probability"] + + issues_df_dict = defaultdict(list) + for i in issues_dict: + issues_df_dict["Class Index"].append(i) + for j in issues_dict[i]: + issues_df_dict[j].append(issues_dict[i][j]) + return ( + pd.DataFrame.from_dict(issues_df_dict) + .sort_values(by="Label Quality Score", ascending=True) + .reset_index(drop=True) + )[return_columns] + + +def _get_num_examples_multilabel(labels=None, confident_joint: Optional[np.ndarray] = None) -> int: + """Helper method that finds the number of examples from the parameters or throws an error + if neither parameter is provided. + + Parameters + ---------- + For parameter info, see the docstring of :py:func:`common_multilabel_issues ` + + Returns + ------- + num_examples : int + The number of examples in the dataset. + + Raises + ------ + ValueError + If `labels` is None.""" + + if labels is None and confident_joint is None: + raise ValueError( + "Error: num_examples is None. You must either provide confident_joint, " + "or provide both num_example and joint as input parameters." + ) + _confident_joint = cast(np.ndarray, confident_joint) + num_examples = len(labels) if labels is not None else cast(int, np.sum(_confident_joint[0])) + return num_examples + + +def overall_multilabel_health_score( + labels=None, + pred_probs=None, + *, + confident_joint=None, +) -> float: + """Returns a single score between 0 and 1 measuring the overall quality of all labels in a multi-label classification dataset. + Intuitively, the score is the average correctness of the given labels across all examples in the + dataset. So a score of 1 suggests your data is perfectly labeled and a score of 0.5 suggests + half of the examples in the dataset may be incorrectly labeled. Thus, a higher + score implies a higher quality dataset. + + **Parameters**: For information about the arguments to this method, see the documentation of + :py:func:`common_multilabel_issues `. + + Returns + ------- + health_score : float + A overall score between 0 and 1, where 1 implies all labels in the dataset are estimated to be correct. + A score of 0.5 implies that half of the dataset's labels are estimated to have issues. + """ + num_examples = _get_num_examples_multilabel(labels=labels) + issues = find_label_issues( + labels=labels, pred_probs=pred_probs, confident_joint=confident_joint + ) + return 1.0 - sum(issues) / num_examples + + +def multilabel_health_summary( + labels=None, + pred_probs=None, + *, + class_names=None, + num_examples=None, + confident_joint=None, + verbose=True, +) -> Dict: + """Prints a health summary of your multi-label datasets including useful statistics like: + + * The classes with the most and least label issues + * Overall data label quality health score statistics for your dataset + + **Parameters**: For information about the arguments to this method, see the documentation of + :py:func:`common_multilabel_issues `. + + Returns + ------- + summary : dict + A dictionary containing keys (see the corresponding functions' documentation to understand the values): + + - ``"overall_label_health_score"``, corresponding to output of :py:func:`overall_multilabel_health_score ` + - ``"classes_by_multilabel_quality"``, corresponding to output of :py:func:`rank_classes_by_multilabel_quality ` + - ``"common_multilabel_issues"``, corresponding to output of :py:func:`common_multilabel_issues ` + """ + from cleanlab.internal.util import smart_display_dataframe + + if num_examples is None: + num_examples = _get_num_examples_multilabel(labels=labels) + + if verbose: + longest_line = f"| for your dataset with {num_examples:,} examples " + print( + "-" * (len(longest_line) - 1) + + "\n" + + f"| Generating a Cleanlab Dataset Health Summary{' ' * (len(longest_line) - 49)}|\n" + + longest_line + + f"| Note, Cleanlab is not a medical doctor... yet.{' ' * (len(longest_line) - 51)}|\n" + + "-" * (len(longest_line) - 1) + + "\n", + ) + + df_class_label_quality = rank_classes_by_multilabel_quality( + labels=labels, + pred_probs=pred_probs, + class_names=class_names, + confident_joint=confident_joint, + ) + if verbose: + print("Overall Class Quality and Noise across your dataset (below)") + print("-" * 60, "\n", flush=True) + smart_display_dataframe(df_class_label_quality) + + df_common_issues = common_multilabel_issues( + labels=labels, + pred_probs=pred_probs, + class_names=class_names, + confident_joint=confident_joint, + ) + if verbose: + print( + "\nCommon multilabel issues are" + "\n" + "-" * 83 + "\n", + flush=True, + ) + smart_display_dataframe(df_common_issues) + print() + + health_score = overall_multilabel_health_score( + labels=labels, + pred_probs=pred_probs, + confident_joint=confident_joint, + ) + if verbose: + print("\nGenerated with <3 from Cleanlab.\n") + return { + "overall_multilabel_health_score": health_score, + "classes_by_multilabel_quality": df_class_label_quality, + "common_multilabel_issues": df_common_issues, + } diff --git a/cleanlab/multilabel_classification/filter.py b/cleanlab/multilabel_classification/filter.py new file mode 100644 index 0000000000..c59ea701da --- /dev/null +++ b/cleanlab/multilabel_classification/filter.py @@ -0,0 +1,258 @@ +import warnings +from typing import Optional, Union, Tuple, List, Any +import numpy as np + + +def find_label_issues( + labels: list, + pred_probs: np.ndarray, + return_indices_ranked_by: Optional[str] = None, + rank_by_kwargs={}, + filter_by: str = "prune_by_noise_rate", + frac_noise: float = 1.0, + num_to_remove_per_class: Optional[List[int]] = None, + min_examples_per_class=1, + confident_joint: Optional[np.ndarray] = None, + n_jobs: Optional[int] = None, + verbose: bool = False, +) -> np.ndarray: + """ + Identifies potentially mislabeled examples in a multi-label classification dataset. + An example is flagged as with a label issue if *any* of the classes appear to be incorrectly annotated for this example. + + Parameters + ---------- + labels : List[List[int]] + List of noisy labels for multi-label classification where each example can belong to multiple classes. + This is an iterable of iterables where the i-th element of `labels` corresponds to a list of classes that the i-th example belongs to, + according to the original data annotation (e.g. ``labels = [[1,2],[1],[0],..]``). + This method will return the indices i where the inner list ``labels[i]`` is estimated to have some error. + For a dataset with K classes, each class must be represented as an integer in 0, 1, ..., K-1 within the labels. + + pred_probs : np.ndarray + An array of shape ``(N, K)`` of model-predicted class probabilities. + Each row of this matrix corresponds to an example `x` + and contains the predicted probability that `x` belongs to each possible class, + for each of the K classes (along its columns). + The columns need not sum to 1 but must be ordered such that + these probabilities correspond to class 0, 1, ..., K-1. + + Note + ---- + Estimated label quality scores are most accurate when they are computed based on out-of-sample ``pred_probs`` from your model. + To obtain out-of-sample predicted probabilities for every example in your dataset, you can use :ref:`cross-validation `. + This is encouraged to get better results. + + return_indices_ranked_by : {None, 'self_confidence', 'normalized_margin', 'confidence_weighted_entropy'}, default=None + This function can return a boolean mask (if None) or an array of the example-indices with issues sorted based on the specified ranking method. + Refer to documentation for this argument in :py:func:`filter.find_label_issues ` for details. + + rank_by_kwargs : dict, optional + Optional keyword arguments to pass into scoring functions for ranking by + label quality score (see :py:func:`rank.get_label_quality_scores + `). + + filter_by : {'prune_by_class', 'prune_by_noise_rate', 'both', 'confident_learning', 'predicted_neq_given', + 'low_normalized_margin', 'low_self_confidence'}, default='prune_by_noise_rate' + The specific Confident Learning method to determine precisely which examples have label issues in a dataset. + Refer to documentation for this argument in :py:func:`filter.find_label_issues ` for details. + + frac_noise : float, default=1.0 + This will return the "top" frac_noise * num_label_issues estimated label errors, dependent on the filtering method used, + Refer to documentation for this argument in :py:func:`filter.find_label_issues ` for details. + + num_to_remove_per_class : array_like + An iterable that specifies the number of mislabeled examples to return from each class. + Refer to documentation for this argument in :py:func:`filter.find_label_issues ` for details. + + min_examples_per_class : int, default=1 + The minimum number of examples required per class below which examples from this class will not be flagged as label issues. + Refer to documentation for this argument in :py:func:`filter.find_label_issues ` for details. + + confident_joint : np.ndarray, optional + An array of shape ``(K, 2, 2)`` representing a one-vs-rest formatted confident joint, as is appropriate for multi-label classification tasks. + Entry ``(c, i, j)`` in this array is the number of examples confidently counted into a ``(class c, noisy label=i, true label=j)`` bin, + where `i, j` are either 0 or 1 to denote whether this example belongs to class `c` or not + (recall examples can belong to multiple classes in multi-label classification). + The `confident_joint` can be computed using :py:func:`count.compute_confident_joint ` with multi_label=True. + If not provided, it is computed from the given (noisy) `labels` and `pred_probs`. + + n_jobs : optional + Number of processing threads used by multiprocessing. + Refer to documentation for this argument in :py:func:`filter.find_label_issues ` for details. + + verbose : optional + If ``True``, prints when multiprocessing happens. + + Returns + ------- + label_issues : np.ndarray + If `return_indices_ranked_by` left unspecified, returns a boolean **mask** for the entire dataset + where ``True`` represents an example suffering from some label issue and + ``False`` represents an example that appears accurately labeled. + + If `return_indices_ranked_by` is specified, this method instead returns a list of **indices** of examples identified with + label issues (i.e. those indices where the mask would be ``True``). + Indices are sorted by the likelihood that *all* classes are correctly annotated for the corresponding example. + + Note + ---- + Obtain the *indices* of examples with label issues in your dataset by setting + `return_indices_ranked_by`. + + """ + from cleanlab.filter import _find_label_issues_multilabel + + return _find_label_issues_multilabel( + labels=labels, + pred_probs=pred_probs, + return_indices_ranked_by=return_indices_ranked_by, + rank_by_kwargs=rank_by_kwargs, + filter_by=filter_by, + frac_noise=frac_noise, + num_to_remove_per_class=num_to_remove_per_class, + min_examples_per_class=min_examples_per_class, + confident_joint=confident_joint, + n_jobs=n_jobs, + verbose=verbose, + ) + + +def find_multilabel_issues_per_class( + labels: list, + pred_probs: np.ndarray, + return_indices_ranked_by: Optional[str] = None, + rank_by_kwargs={}, + filter_by: str = "prune_by_noise_rate", + frac_noise: float = 1.0, + num_to_remove_per_class: Optional[List[int]] = None, + min_examples_per_class=1, + confident_joint: Optional[np.ndarray] = None, + n_jobs: Optional[int] = None, + verbose: bool = False, +) -> Union[np.ndarray, Tuple[List[np.ndarray], List[Any], List[np.ndarray]]]: + """ + Identifies potentially bad labels for each example and each class in a multi-label classification dataset. + Whereas :py:func:`find_label_issues ` + estimates which examples have an erroneous annotation for *any* class, this method estimates which specific classes are incorrectly annotated as well. + This method returns a list of size K, the number of classes in the dataset. + + Parameters + ---------- + labels : List[List[int]] + List of noisy labels for multi-label classification where each example can belong to multiple classes. + Refer to documentation for this argument in :py:func:`find_label_issues ` for further details. + This method will identify whether ``labels[i][k]`` appears correct, for every example ``i`` and class ``k``. + + pred_probs : np.ndarray + An array of shape ``(N, K)`` of model-predicted class probabilities. + Refer to documentation for this argument in :py:func:`find_label_issues ` for further details. + + return_indices_ranked_by : {None, 'self_confidence', 'normalized_margin', 'confidence_weighted_entropy'}, default=None + This function can return a boolean mask (if this argument is ``None``) or a sorted array of indices based on the specified ranking method (if not ``None``). + Refer to documentation for this argument in :py:func:`filter.find_label_issues ` for details. + + rank_by_kwargs : dict, optional + Optional keyword arguments to pass into scoring functions for ranking by. + label quality score (see :py:func:`rank.get_label_quality_scores + `). + + filter_by : {'prune_by_class', 'prune_by_noise_rate', 'both', 'confident_learning', 'predicted_neq_given', + 'low_normalized_margin', 'low_self_confidence'}, default='prune_by_noise_rate' + The specific method that can be used to filter or prune examples with label issues from a dataset. + Refer to documentation for this argument in :py:func:`filter.find_label_issues ` for details. + + frac_noise : float, default=1.0 + This will return the "top" frac_noise * num_label_issues estimated label errors, dependent on the filtering method used, + Refer to documentation for this argument in :py:func:`filter.find_label_issues ` for details. + + num_to_remove_per_class : array_like + This parameter is an iterable that specifies the number of mislabeled examples to return from each class. + Refer to documentation for this argument in :py:func:`filter.find_label_issues ` for details. + + min_examples_per_class : int, default=1 + The minimum number of examples required per class to avoid flagging as label issues. + Refer to documentation for this argument in :py:func:`filter.find_label_issues ` for details. + + confident_joint : np.ndarray, optional + An array of shape ``(K, 2, 2)`` representing a one-vs-rest formatted confident joint. + Refer to documentation for this argument in :py:func:`cleanlab.multilabel_classification.filter.find_label_issues ` for details. + + n_jobs : optional + Number of processing threads used by multiprocessing. + Refer to documentation for this argument in :py:func:`filter.find_label_issues ` for details. + + verbose : optional + If ``True``, prints when multiprocessing happens. + + Returns + ------- + per_class_label_issues : list(np.ndarray) + By default, this is a list of length K containing the examples where each class appears incorrectly annotated. + ``per_class_label_issues[k]`` is a Boolean mask of the same length as the dataset, + where ``True`` values indicate examples where class ``k`` appears incorrectly annotated. + + For more details, refer to :py:func:`cleanlab.multilabel_classification.filter.find_label_issues `. + + Otherwise if `return_indices_ranked_by` is not ``None``, then this method returns 3 objects (each of length K, the number of classes): `label_issues_list`, `labels_list`, `pred_probs_list`. + + * *label_issues_list*: an ordered list of indices of examples where class k appears incorrectly annotated, sorted by the likelihood that class k is correctly annotated. + + * *labels_list*: a binary one-hot representation of the original labels, useful if you want to compute label quality scores. + + * *pred_probs_list*: a one-vs-rest representation of the original predicted probabilities of shape ``(N, 2)``, useful if you want to compute label quality scores. + ``pred_probs_list[k][i][0]`` is the estimated probability that example ``i`` belongs to class ``k``, and is equal to: ``1 - ``pred_probs_list[k][i][1]``. + """ + import cleanlab.filter + from cleanlab.internal.multilabel_utils import get_onehot_num_classes, stack_complement + + y_one, num_classes = get_onehot_num_classes(labels, pred_probs) + if return_indices_ranked_by is None: + bissues = np.zeros(y_one.shape).astype(bool) + else: + label_issues_list = [] + labels_list = [] + pred_probs_list = [] + if confident_joint is not None: + confident_joint_shape = confident_joint.shape + if confident_joint_shape == (num_classes, num_classes): + warnings.warn( + f"The new recommended format for `confident_joint` in multi_label settings is (num_classes,2,2) as output by compute_confident_joint(...,multi_label=True). Your K x K confident_joint in the old format is being ignored." + ) + confident_joint = None + elif confident_joint_shape != (num_classes, 2, 2): + raise ValueError("confident_joint should be of shape (num_classes, 2, 2)") + for class_num, (label, pred_prob_for_class) in enumerate(zip(y_one.T, pred_probs.T)): + pred_probs_binary = stack_complement(pred_prob_for_class) + if confident_joint is None: + conf = None + else: + conf = confident_joint[class_num] + if num_to_remove_per_class is not None: + ml_num_to_remove_per_class = [num_to_remove_per_class[class_num], 0] + else: + ml_num_to_remove_per_class = None + binary_label_issues = cleanlab.filter.find_label_issues( + labels=label, + pred_probs=pred_probs_binary, + return_indices_ranked_by=return_indices_ranked_by, + frac_noise=frac_noise, + rank_by_kwargs=rank_by_kwargs, + filter_by=filter_by, + num_to_remove_per_class=ml_num_to_remove_per_class, + min_examples_per_class=min_examples_per_class, + confident_joint=conf, + n_jobs=n_jobs, + verbose=verbose, + ) + + if return_indices_ranked_by is None: + bissues[:, class_num] = binary_label_issues + else: + label_issues_list.append(binary_label_issues) + labels_list.append(label) + pred_probs_list.append(pred_probs_binary) + if return_indices_ranked_by is None: + return bissues + else: + return label_issues_list, labels_list, pred_probs_list diff --git a/cleanlab/multilabel_classification/rank.py b/cleanlab/multilabel_classification/rank.py new file mode 100644 index 0000000000..57c24bc27e --- /dev/null +++ b/cleanlab/multilabel_classification/rank.py @@ -0,0 +1,191 @@ +# Copyright (C) 2017-2023 Cleanlab Inc. +# This file is part of cleanlab. +# +# cleanlab is free software: you can redistribute it and/or modify +# it under the terms of the GNU Affero General Public License as published +# by the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# cleanlab is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU Affero General Public License for more details. +# +# You should have received a copy of the GNU Affero General Public License +# along with cleanlab. If not, see . + +""" +Methods to rank the severity of label issues in multi-label classification datasets. +Here each example can belong to one or more classes, or none of the classes at all. +Unlike in standard multi-class classification, predicted class probabilities from model need not sum to 1 for each row in multi-label classification. +""" + +import numpy as np # noqa: F401: Imported for type annotations +import numpy.typing as npt +from typing import List, TypeVar, Dict, Any, Optional, Tuple + +from cleanlab.internal.validation import assert_valid_inputs +from cleanlab.internal.util import get_num_classes +from cleanlab.internal.multilabel_utils import int2onehot +from cleanlab.internal.multilabel_scorer import MultilabelScorer, ClassLabelScorer, Aggregator + + +T = TypeVar("T", bound=npt.NBitBase) + + +def _labels_to_binary( + labels: List[List[int]], + pred_probs: npt.NDArray["np.floating[T]"], +) -> np.ndarray: + """Validate the inputs to the multilabel scorer. Also transform the labels to a binary representation.""" + assert_valid_inputs( + X=None, y=labels, pred_probs=pred_probs, multi_label=True, allow_one_class=True + ) + num_classes = get_num_classes(labels=labels, pred_probs=pred_probs, multi_label=True) + binary_labels = int2onehot(labels, K=num_classes) + return binary_labels + + +def _create_multilabel_scorer( + method: str, + adjust_pred_probs: bool, + aggregator_kwargs: Optional[Dict[str, Any]] = None, +) -> Tuple[MultilabelScorer, Dict]: + """This function acts as a factory that creates a MultilabelScorer.""" + base_scorer = ClassLabelScorer.from_str(method) + base_scorer_kwargs = {"adjust_pred_probs": adjust_pred_probs} + if aggregator_kwargs: + aggregator = Aggregator(**aggregator_kwargs) + scorer = MultilabelScorer(base_scorer, aggregator) + else: + scorer = MultilabelScorer(base_scorer) + return scorer, base_scorer_kwargs + + +def get_label_quality_scores( + labels: List[List[int]], + pred_probs: npt.NDArray["np.floating[T]"], + *, + method: str = "self_confidence", + adjust_pred_probs: bool = False, + aggregator_kwargs: Dict[str, Any] = {"method": "exponential_moving_average", "alpha": 0.8}, +) -> npt.NDArray["np.floating[T]"]: + """Computes a label quality score each example in a multi-label classification dataset. + + Scores are between 0 and 1 with lower scores indicating examples whose label more likely contains an error. + For each example, this method internally computes a separate score for each individual class + and then aggregates these per-class scores into an overall label quality score for the example. + + + Parameters + ---------- + labels : List[List[int]] + List of noisy labels for multi-label classification where each example can belong to multiple classes. + Refer to documentation for this argument in :py:func:`multilabel_classification.filter.find_label_issues ` for further details. + + pred_probs : np.ndarray + An array of shape ``(N, K)`` of model-predicted class probabilities. + Refer to documentation for this argument in :py:func:`multilabel_classification.filter.find_label_issues ` for further details. + + method : {"self_confidence", "normalized_margin", "confidence_weighted_entropy"}, default = "self_confidence" + Method to calculate separate per-class annotation scores for an example that are then aggregated into an overall label quality score for the example. + These scores are separately calculated for each class based on the corresponding column of `pred_probs` in a one-vs-rest manner, + and are standard label quality scores for binary classification (based on whether the class should or should not apply to this example). + + See also + -------- + :py:func:`rank.get_label_quality_scores ` function for details about each option. + + adjust_pred_probs : bool, default = False + Account for class imbalance in the label-quality scoring by adjusting predicted probabilities. + Refer to documentation for this argument in :py:func:`rank.get_label_quality_scores ` for details. + + + aggregator_kwargs : dict, default = {"method": "exponential_moving_average", "alpha": 0.8} + A dictionary of hyperparameter values to use when aggregating per-class scores into an overall label quality score for each example. + Options for ``"method"`` include: ``"exponential_moving_average"`` or ``"softmin"`` or your own callable function. + See :py:class:`internal.multilabel_scorer.Aggregator ` for details about each option and other possible hyperparameters. + + To get a score for each class annotation for each example, use the :py:func:`multilabel_classification.classification.rank.get_label_quality_scores_per_class ` method instead. + + Returns + ------- + label_quality_scores : np.ndarray + A 1D array of shape ``(N,)`` with a label quality score (between 0 and 1) for each example in the dataset. + Lower scores indicate examples whose label is more likely to contain some annotation error (for any of the classes). + + Examples + -------- + >>> from cleanlab.multilabel_classification import get_label_quality_scores + >>> import numpy as np + >>> labels = [[1], [0,2]] + >>> pred_probs = np.array([[0.1, 0.9, 0.1], [0.4, 0.1, 0.9]]) + >>> scores = get_label_quality_scores(labels, pred_probs) + >>> scores + array([0.9, 0.5]) + """ + binary_labels = _labels_to_binary(labels, pred_probs) + scorer, base_scorer_kwargs = _create_multilabel_scorer( + method=method, + adjust_pred_probs=adjust_pred_probs, + aggregator_kwargs=aggregator_kwargs, + ) + return scorer(binary_labels, pred_probs, base_scorer_kwargs=base_scorer_kwargs) + + +def get_label_quality_scores_per_class( + labels: List[List[int]], + pred_probs: npt.NDArray["np.floating[T]"], + *, + method: str = "self_confidence", + adjust_pred_probs: bool = False, +) -> np.ndarray: + """ + Computes a quality score quantifying how likely each individual class annotation is correct in a multi-label classification dataset. + This is similar to :py:func:`get_label_quality_scores ` + but instead returns the per-class results without aggregation. + For a dataset with K classes, each example receives K scores from this method. + Refer to documentation in :py:func:`get_label_quality_scores ` for details. + + Parameters + ---------- + labels : List[List[int]] + List of noisy labels for multi-label classification where each example can belong to multiple classes. + Refer to documentation for this argument in :py:func:`find_label_issues ` for further details. + + pred_probs : np.ndarray + An array of shape ``(N, K)`` of model-predicted class probabilities. + Refer to documentation for this argument in :py:func:`find_label_issues ` for further details. + + method : {"self_confidence", "normalized_margin", "confidence_weighted_entropy"}, default = "self_confidence" + Method to calculate separate per-class annotation scores (that quantify how likely a particular class annotation is correct for a particular example). + Refer to documentation for this argument in :py:func:`get_label_quality_scores ` for further details. + + adjust_pred_probs : bool, default = False + Account for class imbalance in the label-quality scoring by adjusting predicted probabilities. + Refer to documentation for this argument in :py:func:`rank.get_label_quality_scores ` for details. + + Returns + ------- + label_quality_scores : list(np.ndarray) + A list containing K arrays, each of shape (N,). Here K is the number of classes in the dataset and N is the number of examples. + ``label_quality_scores[k][i]`` is a score between 0 and 1 quantifying how likely the annotation for class ``k`` is correct for example ``i``. + + Examples + -------- + >>> from cleanlab.multilabel_classification import get_label_quality_scores + >>> import numpy as np + >>> labels = [[1], [0,2]] + >>> pred_probs = np.array([[0.1, 0.9, 0.1], [0.4, 0.1, 0.9]]) + >>> scores = get_label_quality_scores(labels, pred_probs) + >>> scores + array([0.9, 0.5]) + """ + binary_labels = _labels_to_binary(labels, pred_probs) + scorer, base_scorer_kwargs = _create_multilabel_scorer( + method=method, + adjust_pred_probs=adjust_pred_probs, + ) + return scorer.get_class_label_quality_scores( + labels=binary_labels, pred_probs=pred_probs, base_scorer_kwargs=base_scorer_kwargs + ) diff --git a/docs/source/tutorials/multilabel_classification.ipynb b/docs/source/tutorials/multilabel_classification.ipynb index b1b002975e..49a824c031 100644 --- a/docs/source/tutorials/multilabel_classification.ipynb +++ b/docs/source/tutorials/multilabel_classification.ipynb @@ -19,17 +19,16 @@ "Quickstart\n", "
    \n", " \n", - "cleanlab finds label issues based on two inputs: `labels` formatted as a list of lists of integer class indices that apply to each example in your dataset, and `pred_probs` from a trained multi-label classification model (which do not need to sum to 1 since the classes are not mutually exclusive). Once you have these, run the code below to find label issues in your dataset.\n", + "cleanlab finds label issues based on two inputs: `labels` formatted as a list of lists of integer class indices that apply to each example in your dataset, and `pred_probs` from a trained multi-label classification model (which do not need to sum to 1 since the classes are not mutually exclusive). Once you have these, run the code below to find label issues in your multi-label dataset:\n", "\n", "
    \n", " \n", "```ipython3 \n", - "from cleanlab.filter import find_label_issues\n", + "from cleanlab.multilabel_classification.filter import find_label_issues\n", "\n", "ranked_label_issues = find_label_issues(\n", " labels=labels,\n", " pred_probs=pred_probs,\n", - " multi_label=True,\n", " return_indices_ranked_by=\"self_confidence\",\n", ")\n", "```\n", @@ -105,13 +104,8 @@ "from sklearn.model_selection import StratifiedKFold\n", "import matplotlib.pyplot as plt\n", "\n", - "from cleanlab.filter import find_label_issues\n", - "import cleanlab.internal.multilabel_utils as mlutils\n", - "from cleanlab.internal.multilabel_utils import onehot2int, int2onehot\n", - "from cleanlab.benchmarking.noise_generation import (\n", - " generate_noise_matrix_from_trace,\n", - " generate_noisy_labels,\n", - ")" + "from cleanlab.multilabel_classification.filter import find_label_issues\n", + "from cleanlab.multilabel_classification.rank import get_label_quality_scores" ] }, { @@ -132,6 +126,11 @@ "```ipython3\n", "# Note: This pulldown content is for docs.cleanlab.ai, if running on local Jupyter or Colab, please ignore it.\n", " \n", + "from cleanlab.benchmarking.noise_generation import (\n", + " generate_noise_matrix_from_trace,\n", + " generate_noisy_labels,\n", + ")\n", + "\n", "def make_multilabel_data(\n", " means=[[-5, 3.5], [0, 2], [-3, 6]],\n", " covs=[[[3, -1.5], [-1.5, 1]], [[5, -1.5], [-1.5, 1]], [[3, -1.5], [-1.5, 1]]],\n", @@ -255,6 +254,11 @@ }, "outputs": [], "source": [ + "from cleanlab.benchmarking.noise_generation import (\n", + " generate_noise_matrix_from_trace,\n", + " generate_noisy_labels,\n", + ")\n", + "\n", "def make_multilabel_data(\n", " means=[[-5, 3.5], [0, 2], [-3, 6]],\n", " covs=[[[3, -1.5], [-1.5, 1]], [[5, -1.5], [-1.5, 1]], [[3, -1.5], [-1.5, 1]]],\n", @@ -434,7 +438,7 @@ "\n", "`labels` should be a list of lists, whose *i*-th entry is a list of (integer) class indices that apply to the *i*-th example in the dataset. If your classes are represented as string names, you should map these to integer indices. The label for an example that belongs to none of the classes should just be an empty list `[]`.\n", "\n", - "Once you have `pred_probs` and `labels` in the appropriate formats, you can find label issues with cleanlab for any multi-label dataset!\n", + "Once you have `pred_probs` and `labels` appropriately formatted, you can find/analyze label issues in any multi-label dataset via methods from the `cleanlab.multilabel_classification` module!\n", "\n", "Here's what these look like for the first few examples in our synthetic multi-label dataset: " ] @@ -474,7 +478,6 @@ "issues = find_label_issues(\n", " labels=labels,\n", " pred_probs=pred_probs,\n", - " multi_label=True,\n", " return_indices_ranked_by=\"self_confidence\",\n", ")\n", "\n", @@ -486,8 +489,6 @@ "id": "d6af5833", "metadata": {}, "source": [ - "Note we specified the `multi_label` option above to distinguish the task from *multi-class classification* (otherwise assumed as the default task).\n", - "\n", "Let's look at the samples that cleanlab thinks are most likely to be mislabeled. You can see that cleanlab was able to identify most of `true_errors` in our small dataset (despite not having access to this variable, which you won't have in your own applications)." ] }, @@ -518,8 +519,6 @@ "metadata": {}, "outputs": [], "source": [ - "from cleanlab.multilabel_classification import get_label_quality_scores\n", - "\n", "scores = get_label_quality_scores(labels, pred_probs)\n", "\n", "print(f\"Label quality scores of the first 10 examples in dataset:\\n{scores[:10]}\")" @@ -530,6 +529,8 @@ "id": "d65af827-aeda-4b6b-9ae7-b1f0b84700d5", "metadata": {}, "source": [ + "**Note:** For multi-label data, make sure to use the versions of `find_label_issues()` and `get_label_quality_scores()` from the `cleanlab.multilabel_classification` module. There exist other versions of these methods for other types of data.\n", + "\n", "### How to format labels given as a one-hot (multi-hot) binary matrix?\n", "\n", "For multi-label classification, cleanlab expects labels to be formatted as a list of lists, where each entry is an integer corresponding to a particular class. Here are some functions you can use to easily convert labels between this format and a binary matrix format commonly used to train multi-label classification models." @@ -591,7 +592,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.15" + "version": "3.9.12" } }, "nbformat": 4, diff --git a/setup.cfg b/setup.cfg index 8888d3b898..2f044be3d5 100644 --- a/setup.cfg +++ b/setup.cfg @@ -6,3 +6,4 @@ per-file-ignores = cleanlab/token_classification/__init__.py: F401 cleanlab/benchmarking/__init__.py: F401 cleanlab/models/__init__.py: F401 + cleanlab/multilabel_classification/__init__.py: F401 diff --git a/tests/test_dataset.py b/tests/test_dataset.py index 1331fe5677..092e5f3587 100644 --- a/tests/test_dataset.py +++ b/tests/test_dataset.py @@ -448,6 +448,16 @@ def test_real_datasets(dataset_name): ) +@pytest.mark.parametrize("dataset_name", ["mnist"]) +def test_multilabel_error(dataset_name): + print("\n" + dataset_name.capitalize() + "\n") + class_names = eval(dataset_name) + pred_probs, labels = _get_pred_probs_labels_from_labelerrors_datasets(dataset_name) + # if this runs without issue no all four datasets, the test passes + with pytest.raises(ValueError) as e: + _ = find_overlapping_classes(labels=labels, pred_probs=pred_probs, multi_label=True) + + @pytest.mark.parametrize("asymmetric", [True, False]) @pytest.mark.parametrize("dataset_name", ["mnist", "imdb"]) def test_symmetry_df_size(asymmetric, dataset_name): diff --git a/tests/test_filter_count.py b/tests/test_filter_count.py index e2cbf07bdd..1c126a0bf3 100644 --- a/tests/test_filter_count.py +++ b/tests/test_filter_count.py @@ -14,6 +14,7 @@ # You should have received a copy of the GNU Affero General Public License # along with cleanlab. If not, see . +import cleanlab.multilabel_classification.dataset from cleanlab import count, filter from cleanlab.count import ( get_confident_thresholds, @@ -496,6 +497,7 @@ def test_pruning_order_method(): @pytest.mark.parametrize("multi_label", [True, False]) +@pytest.mark.parametrize("use_dataset_function", [True, False]) @pytest.mark.parametrize( "filter_by", ["prune_by_noise_rate", "prune_by_class", "both", "confident_learning"] ) @@ -503,17 +505,37 @@ def test_pruning_order_method(): "return_indices_ranked_by", [None, "self_confidence", "normalized_margin", "confidence_weighted_entropy"], ) -def test_find_label_issues_multi_label(multi_label, filter_by, return_indices_ranked_by): +def test_find_label_issues_multi_label( + multi_label, use_dataset_function, filter_by, return_indices_ranked_by +): """Note: argmax_not_equal method is not compatible with multi_label == True""" dataset = multilabel_data if multi_label else data + if multi_label: + if use_dataset_function: + noise_idx = cleanlab.multilabel_classification.filter.find_label_issues( + labels=dataset["labels"], + pred_probs=dataset["pred_probs"], + filter_by=filter_by, + return_indices_ranked_by=return_indices_ranked_by, + ) + else: + with pytest.warns(DeprecationWarning): + noise_idx = filter.find_label_issues( + labels=dataset["labels"], + pred_probs=dataset["pred_probs"], + filter_by=filter_by, + multi_label=multi_label, + return_indices_ranked_by=return_indices_ranked_by, + ) + else: + noise_idx = filter.find_label_issues( + labels=dataset["labels"], + pred_probs=dataset["pred_probs"], + filter_by=filter_by, + multi_label=multi_label, + return_indices_ranked_by=return_indices_ranked_by, + ) - noise_idx = filter.find_label_issues( - labels=dataset["labels"], - pred_probs=dataset["pred_probs"], - filter_by=filter_by, - multi_label=multi_label, - return_indices_ranked_by=return_indices_ranked_by, - ) if return_indices_ranked_by is not None: noise_bool = np.zeros(len(dataset["labels"])).astype(bool) noise_bool[noise_idx] = True diff --git a/tests/test_multilabel_classification.py b/tests/test_multilabel_classification.py index ac1d3afb57..452dbc379f 100644 --- a/tests/test_multilabel_classification.py +++ b/tests/test_multilabel_classification.py @@ -25,7 +25,15 @@ from cleanlab.internal import multilabel_scorer as ml_scorer from cleanlab.internal.multilabel_utils import stack_complement, get_onehot_num_classes, onehot2int -from cleanlab import multilabel_classification as multilabel_classfication +from cleanlab import multilabel_classification as ml_classification +from cleanlab.multilabel_classification.dataset import ( + common_multilabel_issues, + rank_classes_by_multilabel_quality, + overall_multilabel_health_score, + multilabel_health_summary, +) +from cleanlab.multilabel_classification.rank import get_label_quality_scores_per_class +from cleanlab.multilabel_classification import filter @pytest.fixture @@ -84,6 +92,41 @@ def pred_probs(): ) +@pytest.fixture +def pred_probs_multilabel(): + return np.array( + [ + [0.9, 0.1, 0.0, 0.4, 0.1], + [0.7, 0.8, 0.2, 0.3, 0.1], + [0.9, 0.8, 0.4, 0.2, 0.1], + [0.1, 0.1, 0.8, 0.3, 0.1], + [0.4, 0.5, 0.1, 0.1, 0.1], + [0.1, 0.1, 0.2, 0.1, 0.1], + [0.8, 0.1, 0.2, 0.1, 0.1], + ] + ) + + +@pytest.fixture +def labels_multilabel(): + return [[0], [0, 1], [0, 1], [2], [0, 2, 3], [], []] + + +@pytest.fixture +def data_multilabel(num_classes=5): + labels = [] + pred_probs = [] + for i in range(0, 100): + q = [0.1] * num_classes + pos = i % num_classes + labels.append([pos]) + if i > 90: + pos = (pos + 2) % num_classes + q[pos] = 0.9 + pred_probs.append(q) + return labels, np.array(pred_probs) + + @pytest.fixture def cv(): return sklearn.model_selection.StratifiedKFold( @@ -102,18 +145,18 @@ def dummy_features(labels): def test_public_label_quality_scores(labels, pred_probs): formatted_labels = onehot2int(labels) assert isinstance(formatted_labels, list) - scores1 = multilabel_classfication.get_label_quality_scores(formatted_labels, pred_probs) + scores1 = ml_classification.get_label_quality_scores(formatted_labels, pred_probs) assert len(scores1) == len(labels) assert (scores1 >= 0).all() and (scores1 <= 1).all() - scores2 = multilabel_classfication.get_label_quality_scores( + scores2 = ml_classification.get_label_quality_scores( formatted_labels, pred_probs, method="confidence_weighted_entropy" ) assert not np.isclose(scores1, scores2).all() - scores3 = multilabel_classfication.get_label_quality_scores( + scores3 = ml_classification.get_label_quality_scores( formatted_labels, pred_probs, adjust_pred_probs=True ) assert not np.isclose(scores1, scores3).all() - scores4 = multilabel_classfication.get_label_quality_scores( + scores4 = ml_classification.get_label_quality_scores( formatted_labels, pred_probs, method="normalized_margin", @@ -121,7 +164,7 @@ def test_public_label_quality_scores(labels, pred_probs): aggregator_kwargs={"method": "exponential_moving_average"}, ) assert not np.isclose(scores1, scores4).all() - scores5 = multilabel_classfication.get_label_quality_scores( + scores5 = ml_classification.get_label_quality_scores( formatted_labels, pred_probs, method="normalized_margin", @@ -129,7 +172,7 @@ def test_public_label_quality_scores(labels, pred_probs): aggregator_kwargs={"method": "softmin"}, ) assert not np.isclose(scores4, scores5).all() - scores6 = multilabel_classfication.get_label_quality_scores( + scores6 = ml_classification.get_label_quality_scores( formatted_labels, pred_probs, method="normalized_margin", @@ -137,7 +180,7 @@ def test_public_label_quality_scores(labels, pred_probs): aggregator_kwargs={"method": "softmin", "temperature": 0.002}, ) assert not np.isclose(scores5, scores6).all() - scores7 = multilabel_classfication.get_label_quality_scores( + scores7 = ml_classification.get_label_quality_scores( formatted_labels, pred_probs, method="normalized_margin", @@ -147,13 +190,13 @@ def test_public_label_quality_scores(labels, pred_probs): assert np.isclose(scores6, scores7, rtol=1e-3).all() with pytest.raises(ValueError) as e: - _ = multilabel_classfication.get_label_quality_scores( + _ = ml_classification.get_label_quality_scores( formatted_labels, pred_probs, method="badchoice" ) assert "Invalid method name: badchoice" in str(e.value) with pytest.raises(ValueError) as e: - _ = multilabel_classfication.get_label_quality_scores( + _ = ml_classification.get_label_quality_scores( formatted_labels, pred_probs, aggregator_kwargs={"method": "invalid"} ) assert "Invalid aggregation method specified: 'invalid'" in str(e.value) @@ -172,7 +215,7 @@ def base_scores(self): ids=lambda x: x.__name__ if callable(x) else str(x), ) def test_aggregator_callable(self, method): - aggregator = multilabel_classfication.Aggregator(method=method) + aggregator = ml_scorer.Aggregator(method=method) assert callable(aggregator.method), "Aggregator should store a callable method" assert callable(aggregator), "Aggregator should be callable" @@ -189,24 +232,24 @@ def test_aggregator_callable(self, method): ids=["min", "max", "mean", "median", "exponential_moving_average", "softmin"], ) def test_aggregator_score(self, base_scores, method, expected_score): - aggregator = multilabel_classfication.Aggregator(method=method) + aggregator = ml_scorer.Aggregator(method=method) scores = aggregator(base_scores) assert np.isclose(scores, np.array([expected_score]), rtol=1e-3).all() assert scores.shape == (1,) def test_invalid_method(self): with pytest.raises(ValueError) as e: - _ = multilabel_classfication.Aggregator(method="invalid_method") + _ = ml_scorer.Aggregator(method="invalid_method") assert "Invalid aggregation method specified: 'invalid_method'" in str( e.value ), "String constructor has limited options" with pytest.raises(TypeError) as e: - _ = multilabel_classfication.Aggregator(method=1) + _ = ml_scorer.Aggregator(method=1) assert "Expected callable method" in str(e.value), "Non-callable methods are not valid" def test_invalid_score(self, base_scores): - aggregator = multilabel_classfication.Aggregator(method=np.min) + aggregator = ml_scorer.Aggregator(method=np.min) with pytest.raises(ValueError) as e: _ = aggregator(base_scores[0]) assert "Expected 2D array" in str(e.value), "Aggregator expects 2D array" @@ -304,6 +347,152 @@ def test_is_multilabel(labels): assert not ml_scorer._is_multilabel(labels[:, 0]) +@pytest.mark.parametrize("class_names", [None, ["Apple", "Cat", "Dog", "Peach", "Bird"]]) +def test_common_multilabel_issues(class_names, pred_probs_multilabel, labels_multilabel): + df = common_multilabel_issues( + labels=labels_multilabel, pred_probs=pred_probs_multilabel, class_names=class_names + ) + expected_issue_probabilities = [ + 0.14285714285714285, + 0.14285714285714285, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + ] + assert len(df) == 10 + assert np.isclose(np.array(expected_issue_probabilities), df["Issue Probability"]).all() + if class_names: + expected_res = [ + "Apple", + "Dog", + "Apple", + "Cat", + "Cat", + "Dog", + "Peach", + "Peach", + "Bird", + "Bird", + ] + assert list(df["Class Name"]) == expected_res + else: + assert "Class Name" not in df.columns + + +@pytest.mark.parametrize("min_examples_per_class", [10, 90]) +def test_multilabel_min_examples_per_class(data_multilabel, min_examples_per_class): + labels, pred_probs = data_multilabel + issues = filter.find_label_issues( + labels=labels, pred_probs=pred_probs, min_examples_per_class=min_examples_per_class + ) + if min_examples_per_class == 10: + assert sum(issues) == 9 + else: + assert sum(issues) == 0 + + +@pytest.mark.parametrize("num_to_remove_per_class", [None, [1, 1, 0, 0, 2], [1, 1, 0, 0, 1]]) +def test_multilabel_num_to_remove_per_class(data_multilabel, num_to_remove_per_class): + labels, pred_probs = data_multilabel + + issues = filter.find_label_issues( + labels=labels, pred_probs=pred_probs, num_to_remove_per_class=num_to_remove_per_class + ) + num_issues = sum(issues) + if num_to_remove_per_class is None: + assert num_issues == 9 + else: + assert num_issues == sum(num_to_remove_per_class) + + +@pytest.mark.parametrize("class_names", [None, ["Apple", "Cat", "Dog", "Peach", "Bird"]]) +def test_rank_classes_by_multilabel_quality(pred_probs_multilabel, labels_multilabel, class_names): + df_ranked = rank_classes_by_multilabel_quality( + pred_probs=pred_probs_multilabel, labels=labels_multilabel, class_names=class_names + ) + expected_Label_Issues = [1, 0, 0, 0, 0] + + expected_Label_Noise = [0.14285714285714285, 0.0, 0.0, 0.0, 0.0] + + expected_Label_Quality_Score = [0.8571428571428572, 1.0, 1.0, 1.0, 1.0] + + expected_Inverse_Label_Issues = [0, 1, 0, 0, 0] + + expected_Inverse_Label_Noise = [0.0, 0.14285714285714285, 0.0, 0.0, 0.0] + assert list(df_ranked["Label Issues"]) == expected_Label_Issues + + assert np.isclose(np.array(expected_Label_Noise), df_ranked["Label Noise"]).all() + assert np.isclose( + np.array(expected_Label_Quality_Score), df_ranked["Label Quality Score"] + ).all() + assert list(df_ranked["Inverse Label Issues"]) == expected_Inverse_Label_Issues + assert np.isclose( + np.array(expected_Inverse_Label_Noise), df_ranked["Inverse Label Noise"] + ).all() + if class_names: + expected_res = [ + "Dog", + "Apple", + "Cat", + "Peach", + "Bird", + ] + assert list(df_ranked["Class Name"]) == expected_res + else: + assert "Class Name" not in df_ranked.columns + + +def test_overall_multilabel_health_score(data_multilabel): + labels, pred_probs = data_multilabel + overall_label_health_score = overall_multilabel_health_score( + pred_probs=pred_probs, labels=labels + ) + assert np.isclose(overall_label_health_score, 0.91) + + +def test_get_class_label_quality_scores(): + pred_probs = np.array( + [ + [0.9, 0.1, 0.0, 0.4, 0.1], + [0.7, 0.8, 0.2, 0.3, 0.1], + [0.9, 0.8, 0.4, 0.2, 0.1], + [0.1, 0.1, 0.8, 0.3, 0.1], + [0.4, 0.5, 0.1, 0.1, 0.1], + [0.1, 0.1, 0.2, 0.1, 0.1], + [0.8, 0.1, 0.2, 0.1, 0.1], + ] + ) + labels = [[0], [0, 1], [0, 1], [2], [0, 2, 3], [], []] + scores = get_label_quality_scores_per_class(pred_probs=pred_probs, labels=labels) + expected_res = [ + [0.9, 0.9, 1.0, 0.6, 0.9], + [0.7, 0.8, 0.8, 0.7, 0.9], + [0.9, 0.8, 0.6, 0.8, 0.9], + [0.9, 0.9, 0.8, 0.7, 0.9], + [0.4, 0.5, 0.1, 0.1, 0.9], + [0.9, 0.9, 0.8, 0.9, 0.9], + [0.2, 0.9, 0.8, 0.9, 0.9], + ] + assert np.isclose(scores, np.array(expected_res)).all() + + +def test_health_summary_multilabel(pred_probs_multilabel, labels_multilabel): + health_summary_multilabel = multilabel_health_summary( + pred_probs=pred_probs_multilabel, labels=labels_multilabel + ) + expected_keys = [ + "classes_by_multilabel_quality", + "common_multilabel_issues", + "overall_multilabel_health_score", + ] + assert sorted(health_summary_multilabel.keys()) == expected_keys + + @pytest.mark.parametrize( "input", [ From 0fdf398db2c7be500b3690e4c41869f6468ea44f Mon Sep 17 00:00:00 2001 From: Jonas Mueller <1390638+jwmueller@users.noreply.github.com> Date: Fri, 14 Apr 2023 10:46:09 -0500 Subject: [PATCH 152/258] move int2onehot, onehot2int to top of multilabel tutorial (#666) --- docs/source/tutorials/multilabel_classification.ipynb | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/docs/source/tutorials/multilabel_classification.ipynb b/docs/source/tutorials/multilabel_classification.ipynb index 49a824c031..d37ba8298a 100644 --- a/docs/source/tutorials/multilabel_classification.ipynb +++ b/docs/source/tutorials/multilabel_classification.ipynb @@ -105,7 +105,8 @@ "import matplotlib.pyplot as plt\n", "\n", "from cleanlab.multilabel_classification.filter import find_label_issues\n", - "from cleanlab.multilabel_classification.rank import get_label_quality_scores" + "from cleanlab.multilabel_classification.rank import get_label_quality_scores\n", + "from cleanlab.internal.multilabel_utils import int2onehot, onehot2int" ] }, { @@ -543,8 +544,6 @@ "metadata": {}, "outputs": [], "source": [ - "from cleanlab.internal.multilabel_utils import int2onehot, onehot2int\n", - "\n", "labels_binary_format = int2onehot(labels, K=num_class)\n", "labels_list_format = onehot2int(labels_binary_format)" ] From d45a508ed6a0d96e5984e564b85c7f25965d7b6b Mon Sep 17 00:00:00 2001 From: Ulyana Date: Fri, 14 Apr 2023 20:23:40 -0700 Subject: [PATCH 153/258] Update softmax to be more numerically stable (#667) --- cleanlab/internal/multilabel_scorer.py | 6 ++++-- cleanlab/token_classification/rank.py | 6 ++++-- 2 files changed, 8 insertions(+), 4 deletions(-) diff --git a/cleanlab/internal/multilabel_scorer.py b/cleanlab/internal/multilabel_scorer.py index 4ad836d283..4d1cbd4d3c 100644 --- a/cleanlab/internal/multilabel_scorer.py +++ b/cleanlab/internal/multilabel_scorer.py @@ -243,8 +243,10 @@ def softmin( def softmax(scores: np.ndarray) -> np.ndarray: """Softmax function.""" - exp_scores = np.exp(scores / temperature) - return exp_scores / np.sum(exp_scores, axis=axis, keepdims=True) + scores = scores / temperature + scores_max = np.amax(scores, axis=axis, keepdims=True) + exp_scores_shifted = np.exp(scores - scores_max) + return exp_scores_shifted / np.sum(exp_scores_shifted, axis=axis, keepdims=True) return np.einsum("ij,ij->i", s, softmax(1 - s)) diff --git a/cleanlab/token_classification/rank.py b/cleanlab/token_classification/rank.py index 40d379e0f9..be41568aa2 100644 --- a/cleanlab/token_classification/rank.py +++ b/cleanlab/token_classification/rank.py @@ -281,8 +281,10 @@ def _softmin_sentence_score( return np.array([np.mean(scores) for scores in token_scores]) def softmax(scores: np.ndarray) -> np.ndarray: - exp_scores = np.exp(scores / temperature) - return exp_scores / np.sum(exp_scores) + scores = scores / temperature + scores_max = np.amax(scores, axis=0, keepdims=True) + exp_scores_shifted = np.exp(scores - scores_max) + return exp_scores_shifted / np.sum(exp_scores_shifted, axis=0, keepdims=True) def fun(scores: np.ndarray) -> float: return np.dot(scores, softmax(1 - np.array(scores))) From ee5ed9bdf0b9567b2d9b28c6b1448e2924b9c4c5 Mon Sep 17 00:00:00 2001 From: Jonas Mueller <1390638+jwmueller@users.noreply.github.com> Date: Mon, 17 Apr 2023 17:38:37 -0500 Subject: [PATCH 154/258] Ensure multilabel docs appear in the documentation (#669) --- cleanlab/dataset.py | 10 +++++---- cleanlab/multilabel_classification/dataset.py | 8 ++++--- cleanlab/multilabel_classification/rank.py | 4 ++-- .../cleanlab/multilabel_classification.rst | 8 ------- .../multilabel_classification/dataset.rst | 8 +++++++ .../multilabel_classification/filter.rst | 8 +++++++ .../multilabel_classification/index.rst | 22 +++++++++++++++++++ .../multilabel_classification/rank.rst | 8 +++++++ docs/source/index.rst | 2 +- 9 files changed, 60 insertions(+), 18 deletions(-) delete mode 100644 docs/source/cleanlab/multilabel_classification.rst create mode 100644 docs/source/cleanlab/multilabel_classification/dataset.rst create mode 100644 docs/source/cleanlab/multilabel_classification/filter.rst create mode 100644 docs/source/cleanlab/multilabel_classification/index.rst create mode 100644 docs/source/cleanlab/multilabel_classification/rank.rst diff --git a/cleanlab/dataset.py b/cleanlab/dataset.py index cefe4b33e4..28fbae31e4 100644 --- a/cleanlab/dataset.py +++ b/cleanlab/dataset.py @@ -402,11 +402,13 @@ def health_summary( multi_label=False, verbose=True, ) -> dict: - """Prints a health summary of your datasets including useful statistics like: + """Prints a health summary of your dataset. - * The classes with the most and least label issues - * Classes that overlap and could potentially be merged - * Overall data label quality health score statistics for your dataset + This summary includes useful statistics like: + + * The classes with the most and least label issues. + * Classes that overlap and could potentially be merged. + * Overall label quality scores, summarizing how accurate the labels appear overall. This method works by providing any one (and only one) of the following inputs: diff --git a/cleanlab/multilabel_classification/dataset.py b/cleanlab/multilabel_classification/dataset.py index e3987a5ece..8fa25ac9e8 100644 --- a/cleanlab/multilabel_classification/dataset.py +++ b/cleanlab/multilabel_classification/dataset.py @@ -244,10 +244,12 @@ def multilabel_health_summary( confident_joint=None, verbose=True, ) -> Dict: - """Prints a health summary of your multi-label datasets including useful statistics like: + """Prints a health summary of your multi-label dataset. - * The classes with the most and least label issues - * Overall data label quality health score statistics for your dataset + This summary includes useful statistics like: + + * The classes with the most and least label issues. + * Overall label quality scores, summarizing how accurate the labels appear across the entire dataset. **Parameters**: For information about the arguments to this method, see the documentation of :py:func:`common_multilabel_issues `. diff --git a/cleanlab/multilabel_classification/rank.py b/cleanlab/multilabel_classification/rank.py index 57c24bc27e..39fa07ff2b 100644 --- a/cleanlab/multilabel_classification/rank.py +++ b/cleanlab/multilabel_classification/rank.py @@ -17,7 +17,7 @@ """ Methods to rank the severity of label issues in multi-label classification datasets. Here each example can belong to one or more classes, or none of the classes at all. -Unlike in standard multi-class classification, predicted class probabilities from model need not sum to 1 for each row in multi-label classification. +Unlike in standard multi-class classification, model-predicted class probabilities need not sum to 1 for each row in multi-label classification. """ import numpy as np # noqa: F401: Imported for type annotations @@ -70,7 +70,7 @@ def get_label_quality_scores( adjust_pred_probs: bool = False, aggregator_kwargs: Dict[str, Any] = {"method": "exponential_moving_average", "alpha": 0.8}, ) -> npt.NDArray["np.floating[T]"]: - """Computes a label quality score each example in a multi-label classification dataset. + """Computes a label quality score for each example in a multi-label classification dataset. Scores are between 0 and 1 with lower scores indicating examples whose label more likely contains an error. For each example, this method internally computes a separate score for each individual class diff --git a/docs/source/cleanlab/multilabel_classification.rst b/docs/source/cleanlab/multilabel_classification.rst deleted file mode 100644 index 02c35acebc..0000000000 --- a/docs/source/cleanlab/multilabel_classification.rst +++ /dev/null @@ -1,8 +0,0 @@ -multilabel_classification -========================= - -.. automodule:: cleanlab.multilabel_classification - :autosummary: - :members: - :undoc-members: - :show-inheritance: \ No newline at end of file diff --git a/docs/source/cleanlab/multilabel_classification/dataset.rst b/docs/source/cleanlab/multilabel_classification/dataset.rst new file mode 100644 index 0000000000..b1c2544548 --- /dev/null +++ b/docs/source/cleanlab/multilabel_classification/dataset.rst @@ -0,0 +1,8 @@ +dataset +======= + +.. automodule:: cleanlab.multilabel_classification.dataset + :autosummary: + :members: + :undoc-members: + :show-inheritance: \ No newline at end of file diff --git a/docs/source/cleanlab/multilabel_classification/filter.rst b/docs/source/cleanlab/multilabel_classification/filter.rst new file mode 100644 index 0000000000..2991848414 --- /dev/null +++ b/docs/source/cleanlab/multilabel_classification/filter.rst @@ -0,0 +1,8 @@ +filter +====== + +.. automodule:: cleanlab.multilabel_classification.filter + :autosummary: + :members: + :undoc-members: + :show-inheritance: \ No newline at end of file diff --git a/docs/source/cleanlab/multilabel_classification/index.rst b/docs/source/cleanlab/multilabel_classification/index.rst new file mode 100644 index 0000000000..a73dcd25a1 --- /dev/null +++ b/docs/source/cleanlab/multilabel_classification/index.rst @@ -0,0 +1,22 @@ +multilabel_classification +========================= + +Methods to detect data and label issues in multi-label classification datasets. + +In multi-class classification, each example in the dataset belongs to exactly 1 out of K classes (e.g. if classifying animals as: {dog, cat, rat}). + +In multi-label classification, each example in the dataset can belong to 1 or more classes (out of K possible classes), or none of the classes at all (e.g. if classifying animals as: {predator, pet, reptile}). + + + +.. automodule:: cleanlab.multilabel_classification + :autosummary: + :members: + :undoc-members: + :show-inheritance: + +.. toctree:: + + filter + rank + dataset \ No newline at end of file diff --git a/docs/source/cleanlab/multilabel_classification/rank.rst b/docs/source/cleanlab/multilabel_classification/rank.rst new file mode 100644 index 0000000000..4c7b2c35be --- /dev/null +++ b/docs/source/cleanlab/multilabel_classification/rank.rst @@ -0,0 +1,8 @@ +rank +==== + +.. automodule:: cleanlab.multilabel_classification.rank + :autosummary: + :members: + :undoc-members: + :show-inheritance: \ No newline at end of file diff --git a/docs/source/index.rst b/docs/source/index.rst index a99ef826a8..c7546f9563 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -151,7 +151,7 @@ Please see our `contributing guidelines Date: Mon, 17 Apr 2023 23:38:49 -0500 Subject: [PATCH 155/258] update fasttext installation requirement (#671) --- docs/requirements.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/requirements.txt b/docs/requirements.txt index 070524aa36..f23a4bdec1 100644 --- a/docs/requirements.txt +++ b/docs/requirements.txt @@ -18,7 +18,7 @@ tensorflow==2.9.1 tensorflow-io==0.26.0 speechbrain==0.5.13 huggingface_hub==0.11.1 -fasttext==0.9.2 +fasttext-wheel==0.9.2 torch==1.13.1 skorch==0.12.1 torchvision==0.14.1 From b22b17914c9d39ced1724afc00c927295c70547f Mon Sep 17 00:00:00 2001 From: "Curtis G. Northcutt" Date: Tue, 18 Apr 2023 15:01:53 -0700 Subject: [PATCH 156/258] add dcai course to resources --- README.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/README.md b/README.md index de2b61b004..e928fee33c 100644 --- a/README.md +++ b/README.md @@ -522,6 +522,8 @@ To understand/cite other cleanlab functionality not described above, check out o ## Other resources +- [Introduction to Data-centric AI (MIT IAP Course 2023)](https://dcai.csail.mit.edu/) + - [Cleanlab Blog](https://cleanlab.ai/blog/) - [Blog post: Introduction to Confident Learning](https://l7.curtisnorthcutt.com/confident-learning) From 64edc95630e609da1130fc08cd7c8de61498ecb4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?El=C3=ADas=20Snorrason?= Date: Tue, 25 Apr 2023 11:26:43 -0500 Subject: [PATCH 157/258] Introduce Datalab (#614) Co-authored-by: Jonas Mueller <1390638+jwmueller@users.noreply.github.com> Co-authored-by: Jesse Cummings Co-authored-by: Jesse Cummings Co-authored-by: Hui Wen <45724323+huiwengoh@users.noreply.github.com> --- .gitignore | 1 + .mypy.ini | 9 + DEVELOPMENT.md | 82 ++ cleanlab/__init__.py | 43 + cleanlab/datalab/__init__.py | 0 cleanlab/datalab/data.py | 258 ++++++ cleanlab/datalab/data_issues.py | 279 ++++++ cleanlab/datalab/datalab.py | 519 +++++++++++ cleanlab/datalab/display.py | 61 ++ cleanlab/datalab/examples/__init__.py | 0 cleanlab/datalab/factory.py | 155 ++++ cleanlab/datalab/issue_finder.py | 351 ++++++++ cleanlab/datalab/issue_manager/__init__.py | 5 + cleanlab/datalab/issue_manager/duplicate.py | 222 +++++ .../datalab/issue_manager/issue_manager.py | 342 ++++++++ cleanlab/datalab/issue_manager/label.py | 226 +++++ cleanlab/datalab/issue_manager/noniid.py | 425 +++++++++ cleanlab/datalab/issue_manager/outlier.py | 276 ++++++ cleanlab/datalab/report.py | 110 +++ cleanlab/datalab/serialize.py | 138 +++ docs/requirements.txt | 2 + docs/source/cleanlab/datalab/data.rst | 9 + docs/source/cleanlab/datalab/data_issues.rst | 9 + docs/source/cleanlab/datalab/datalab.rst | 9 + docs/source/cleanlab/datalab/factory.rst | 9 + .../datalab/guide/custom_issue_manager.rst | 227 +++++ docs/source/cleanlab/datalab/guide/index.rst | 19 + docs/source/cleanlab/datalab/index.rst | 39 + docs/source/cleanlab/datalab/issue_finder.rst | 12 + .../datalab/issue_manager/duplicate.rst | 9 + .../cleanlab/datalab/issue_manager/index.rst | 13 + .../datalab/issue_manager/issue_manager.rst | 8 + .../cleanlab/datalab/issue_manager/label.rst | 8 + .../cleanlab/datalab/issue_manager/noniid.rst | 9 + .../datalab/issue_manager/outlier.rst | 9 + .../datalab/optional_dependencies.rst | 11 + docs/source/cleanlab/datalab/report.rst | 12 + docs/source/index.rst | 4 +- docs/source/tutorials/datalab/audio.ipynb | 779 +++++++++++++++++ .../tutorials/datalab/datalab_advanced.ipynb | 817 ++++++++++++++++++ .../datalab/datalab_quickstart.ipynb | 750 ++++++++++++++++ docs/source/tutorials/datalab/image.ipynb | 551 ++++++++++++ docs/source/tutorials/datalab/index.rst | 12 + docs/source/tutorials/datalab/tabular.ipynb | 523 +++++++++++ docs/source/tutorials/datalab/text.ipynb | 567 ++++++++++++ docs/source/tutorials/indepth_overview.ipynb | 108 ++- docs/source/tutorials/index.rst | 1 + requirements-dev.txt | 1 + setup.cfg | 1 + setup.py | 13 + tests/datalab/conftest.py | 81 ++ tests/datalab/issue_manager/test_noniid.py | 47 + tests/datalab/test_data.py | 163 ++++ tests/datalab/test_data_issues.py | 46 + tests/datalab/test_datalab.py | 757 ++++++++++++++++ tests/datalab/test_factory.py | 31 + tests/datalab/test_init.py | 16 + tests/datalab/test_issue_finder.py | 83 ++ tests/datalab/test_issue_manager.py | 509 +++++++++++ tests/datalab/test_report.py | 85 ++ 60 files changed, 9841 insertions(+), 20 deletions(-) create mode 100644 cleanlab/datalab/__init__.py create mode 100644 cleanlab/datalab/data.py create mode 100644 cleanlab/datalab/data_issues.py create mode 100644 cleanlab/datalab/datalab.py create mode 100644 cleanlab/datalab/display.py create mode 100644 cleanlab/datalab/examples/__init__.py create mode 100644 cleanlab/datalab/factory.py create mode 100644 cleanlab/datalab/issue_finder.py create mode 100644 cleanlab/datalab/issue_manager/__init__.py create mode 100644 cleanlab/datalab/issue_manager/duplicate.py create mode 100644 cleanlab/datalab/issue_manager/issue_manager.py create mode 100644 cleanlab/datalab/issue_manager/label.py create mode 100644 cleanlab/datalab/issue_manager/noniid.py create mode 100644 cleanlab/datalab/issue_manager/outlier.py create mode 100644 cleanlab/datalab/report.py create mode 100644 cleanlab/datalab/serialize.py create mode 100644 docs/source/cleanlab/datalab/data.rst create mode 100644 docs/source/cleanlab/datalab/data_issues.rst create mode 100644 docs/source/cleanlab/datalab/datalab.rst create mode 100644 docs/source/cleanlab/datalab/factory.rst create mode 100644 docs/source/cleanlab/datalab/guide/custom_issue_manager.rst create mode 100644 docs/source/cleanlab/datalab/guide/index.rst create mode 100644 docs/source/cleanlab/datalab/index.rst create mode 100644 docs/source/cleanlab/datalab/issue_finder.rst create mode 100644 docs/source/cleanlab/datalab/issue_manager/duplicate.rst create mode 100644 docs/source/cleanlab/datalab/issue_manager/index.rst create mode 100644 docs/source/cleanlab/datalab/issue_manager/issue_manager.rst create mode 100644 docs/source/cleanlab/datalab/issue_manager/label.rst create mode 100644 docs/source/cleanlab/datalab/issue_manager/noniid.rst create mode 100644 docs/source/cleanlab/datalab/issue_manager/outlier.rst create mode 100644 docs/source/cleanlab/datalab/optional_dependencies.rst create mode 100644 docs/source/cleanlab/datalab/report.rst create mode 100644 docs/source/tutorials/datalab/audio.ipynb create mode 100644 docs/source/tutorials/datalab/datalab_advanced.ipynb create mode 100644 docs/source/tutorials/datalab/datalab_quickstart.ipynb create mode 100644 docs/source/tutorials/datalab/image.ipynb create mode 100644 docs/source/tutorials/datalab/index.rst create mode 100644 docs/source/tutorials/datalab/tabular.ipynb create mode 100644 docs/source/tutorials/datalab/text.ipynb create mode 100644 tests/datalab/conftest.py create mode 100644 tests/datalab/issue_manager/test_noniid.py create mode 100644 tests/datalab/test_data.py create mode 100644 tests/datalab/test_data_issues.py create mode 100644 tests/datalab/test_datalab.py create mode 100644 tests/datalab/test_factory.py create mode 100644 tests/datalab/test_init.py create mode 100644 tests/datalab/test_issue_finder.py create mode 100644 tests/datalab/test_issue_manager.py create mode 100644 tests/datalab/test_report.py diff --git a/.gitignore b/.gitignore index 82fd660bf0..e46bc2dfb5 100644 --- a/.gitignore +++ b/.gitignore @@ -118,6 +118,7 @@ venv.bak/ /docs/source/notebooks/*.gz /docs/source/notebooks/spoken_digits /docs/source/notebooks/pretrained_models +/docs/source/tutorials/datalab/datalab-files/ # Editor files .vscode/ diff --git a/.mypy.ini b/.mypy.ini index ab7155b9e2..c119d9c9e1 100644 --- a/.mypy.ini +++ b/.mypy.ini @@ -21,3 +21,12 @@ ignore_missing_imports = True [mypy-tqdm.*] ignore_missing_imports = True + +[mypy-matplotlib.*] +ignore_missing_imports = True + +[mypy-datasets.*] +ignore_missing_imports = True + +[mypy-scipy.*] +ignore_missing_imports = True diff --git a/DEVELOPMENT.md b/DEVELOPMENT.md index 8b912a591f..59501c6c2e 100644 --- a/DEVELOPMENT.md +++ b/DEVELOPMENT.md @@ -39,6 +39,88 @@ pip install -e . For Macs with Apple silicon: replace `tensorflow` in requirements-dev.txt with: `tensorflow-macos==2.9.2` and `tensorflow-metal==0.5.1` +### Handling optional dependencies + +When designing a class that relies on an optional, domain-specific runtime dependency, it is better to use lazy-importing to avoid forcing users to install the dependency if they do not need it. + +Depending on the coupling of your class to the dependency, you may want to consider importing it at the module-level or as an instance variable of the class or a function that uses the dependency. + +If the dependency is used by many methods in the module or other classes, it is better to import it at the module-level. +On the other hand, if the dependency is only used by a handful of methods, then it's better to import it inside the method. If the dependency is not installed, an ImportError should be raised when the method is called, along with instructions on how to install the dependency. + +Here is an example of a class that lazily imports CuPy and has a sum method (element-wise) that can be used on both CPU and GPU devices. + +Unless an alternative implementations of the sum method is available, an `ImportError` should be raised when the method is called with instructions on how to install the dependency. + +
    Example code + +```python +def lazy_import_cupy(): + try: + import cupy + except ImportError as error: + # If the dependency is required for the class to work, + # replace this block with a raised ImportError containing instructions + print("Warning: cupy is not installed. Please install it with `pip install cupy`.") + cupy = None + return cupy + +class Summation: + def __init__(self): + self.cupy = lazy_import_cupy() + def sum(self, x) -> float: + if self.cupy is None: + return sum(x) + return self.cupy.sum(x) +``` +
    + + +For the build system to recognize the optional dependency, you should add it to the `EXTRAS_REQUIRE` constant in **setup.py**: + +
    Example code + +```python +EXTRAS_REQUIRE = { + ... + "gpu": [ + # Explain why the dependency below is needed, + # e.g. "for performing summation on GPU" + "cupy", + ], +} +``` + + +Or assign to a separate variable and add it to `EXTRAS_REQUIRE` + +```python +GPU_REQUIRES = [ + # Explanation ... + "cupy", +] + +EXTAS_REQUIRE = { + ... + "gpu": GPU_REQUIRES, +} +``` +
    + + +The package can be installed with the optional dependency (here called `gpu`) via: + +1. PyPI installation + +```shell +pip install -r cleanlab[gpu] +``` + +2. Editable installation + +```shell +pip install -e .[gpu] +``` ## Testing diff --git a/cleanlab/__init__.py b/cleanlab/__init__.py index 5746a49a21..f0d92a2795 100644 --- a/cleanlab/__init__.py +++ b/cleanlab/__init__.py @@ -9,3 +9,46 @@ from . import outlier from . import token_classification from . import multilabel_classification + + +class DatalabUnavailable: + def __init__(self, message): + self.message = message + + def __getattr__(self, name): + message = self.message + f" (raised when trying to access {name})" + raise ImportError(message) + + def __call__(self, *args, **kwargs): + message = ( + self.message + f" (raised when trying to call with args: {args}, kwargs: {kwargs})" + ) + raise ImportError(message) + + +def _datalab_import_factory(): + try: + from .datalab.datalab import Datalab as _Datalab + + return _Datalab + except ImportError: + return DatalabUnavailable( + "Datalab is not available due to missing dependencies. " + "To install Datalab, run `pip install cleanlab[datalab]`." + ) + + +def _issue_manager_import_factory(): + try: + from .datalab.issue_manager import IssueManager as _IssueManager + + return _IssueManager + except ImportError: + return DatalabUnavailable( + "IssueManager is not available due to missing dependencies for Datalab. " + "To install Datalab, run `pip install cleanlab[datalab]`." + ) + + +Datalab = _datalab_import_factory() +IssueManager = _issue_manager_import_factory() diff --git a/cleanlab/datalab/__init__.py b/cleanlab/datalab/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/cleanlab/datalab/data.py b/cleanlab/datalab/data.py new file mode 100644 index 0000000000..098b9e2438 --- /dev/null +++ b/cleanlab/datalab/data.py @@ -0,0 +1,258 @@ +# Copyright (C) 2017-2023 Cleanlab Inc. +# This file is part of cleanlab. +# +# cleanlab is free software: you can redistribute it and/or modify +# it under the terms of the GNU Affero General Public License as published +# by the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# cleanlab is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU Affero General Public License for more details. +# +# You should have received a copy of the GNU Affero General Public License +# along with cleanlab. If not, see . +"""Classes and methods for datasets that are loaded into Datalab.""" + +import os +from typing import Any, Callable, Dict, List, Mapping, Tuple, Union, cast, TYPE_CHECKING + +try: + import datasets +except ImportError as error: + raise ImportError( + "Cannot import datasets package. " + "Please install it and try again, or just install cleanlab with " + "all optional dependencies via: `pip install cleanlab[all]`" + ) from error +import numpy as np +import pandas as pd +from datasets.arrow_dataset import Dataset +from datasets import ClassLabel + +from cleanlab.internal.validation import labels_to_array + + +if TYPE_CHECKING: # pragma: no cover + DatasetLike = Union[Dataset, pd.DataFrame, Dict[str, Any], List[Dict[str, Any]], str] + + +class DataFormatError(ValueError): + """Exception raised when the data is not in a supported format.""" + + def __init__(self, data: Any): + self.data = data + message = ( + f"Unsupported data type: {type(data)}\n" + "Supported types: " + "datasets.Dataset, pandas.DataFrame, dict, list, str" + ) + super().__init__(message) + + +class DatasetDictError(ValueError): + """Exception raised when a DatasetDict is passed to Datalab. + + Usually, this means that a dataset identifier was passed to Datalab, but + the dataset is a DatasetDict, which contains multiple splits of the dataset. + + """ + + def __init__(self): + message = ( + "Please pass a single dataset, not a DatasetDict. " + "Try specifying a split, e.g. `dataset = load_dataset('dataset', split='train')` " + "then pass `dataset` to Datalab." + ) + super().__init__(message) + + +class DatasetLoadError(ValueError): + """Exception raised when a dataset cannot be loaded. + + Parameters + ---------- + dataset_type: type + The type of dataset that failed to load. + """ + + def __init__(self, dataset_type: type): + message = f"Failed to load dataset from {dataset_type}.\n" + super().__init__(message) + + +class Data: + """ + Class that holds and validates datasets for Datalab. + + Internally, the data is stored as a datasets.Dataset object and the labels + are integers (ranging from 0 to K-1, where K is the number of classes) stored + in a numpy array. + + Parameters + ---------- + data : + Dataset to be audited by Datalab. + Several formats are supported, which will internally be converted to a Dataset object. + + Supported formats: + - datasets.Dataset + - pandas.DataFrame + - dict + - keys are strings + - values are arrays or lists of equal length + - list + - list of dictionaries with the same keys + - str + - path to a local file + - Text (.txt) + - CSV (.csv) + - JSON (.json) + - or a dataset identifier on the Hugging Face Hub + It checks if the string is a path to a file that exists locally, and if not, + it assumes it is a dataset identifier on the Hugging Face Hub. + + label_name : Union[str, List[str]] + Name of the label column in the dataset. + + Warnings + -------- + Optional dependencies: + + - datasets : + Dataset, DatasetDict and load_dataset are imported from datasets. + This is an optional dependency of cleanlab, but is required for + :py:class:`Datalab ` to work. + """ + + def __init__(self, data: "DatasetLike", label_name: str) -> None: + self._validate_data(data) + self._label_name = label_name + self._data = self._load_data(data) + self._validate_data_and_labels(self._data, self._data[label_name]) + self._data_hash = hash(self._data) + self._labels, self._label_map = _extract_labels(self._data, label_name) + + def _load_data(self, data: "DatasetLike") -> Dataset: + """Checks the type of dataset and uses the correct loader method and + assigns the result to the data attribute.""" + dataset_factory_map: Dict[type, Callable[..., Dataset]] = { + Dataset: lambda x: x, + pd.DataFrame: Dataset.from_pandas, + dict: self._load_dataset_from_dict, + list: self._load_dataset_from_list, + str: self._load_dataset_from_string, + } + if not isinstance(data, tuple(dataset_factory_map.keys())): + raise DataFormatError(data) + return dataset_factory_map[type(data)](data) + + def __len__(self) -> int: + return len(self._data) + + def __eq__(self, other) -> bool: + if isinstance(other, Data): + # Equality checks + hashes = self._data_hash == other._data_hash + labels = np.array_equal(self._labels, other._labels) + label_names = self._label_name == other._label_name + label_maps = self._label_map == other._label_map + return all([hashes, labels, label_names, label_maps]) + return False + + def __hash__(self) -> int: + return self._data_hash + + @property + def class_names(self) -> list: + return list(self._label_map.values()) + + @staticmethod + def _validate_data(data) -> None: + if isinstance(data, datasets.DatasetDict): + raise DatasetDictError() + if not isinstance(data, (Dataset, pd.DataFrame, dict, list, str)): + raise DataFormatError(data) + + @staticmethod + def _validate_data_and_labels(data, labels) -> None: + assert isinstance(labels, (np.ndarray, list)) + assert len(labels) == len(data) + + @staticmethod + def _load_dataset_from_dict(data_dict: Dict[str, Any]) -> Dataset: + try: + return Dataset.from_dict(data_dict) + except Exception as error: + raise DatasetLoadError(dict) from error + + @staticmethod + def _load_dataset_from_list(data_list: List[Dict[str, Any]]) -> Dataset: + try: + return Dataset.from_list(data_list) + except Exception as error: + raise DatasetLoadError(list) from error + + @staticmethod + def _load_dataset_from_string(data_string: str) -> Dataset: + if not os.path.exists(data_string): + try: + dataset = datasets.load_dataset(data_string) + return cast(Dataset, dataset) + except Exception as error: + raise DatasetLoadError(str) from error + + factory: Dict[str, Callable[[str], Any]] = { + ".txt": Dataset.from_text, + ".csv": Dataset.from_csv, + ".json": Dataset.from_json, + } + + extension = os.path.splitext(data_string)[1] + if extension not in factory: + raise DatasetLoadError(type(data_string)) + + dataset = factory[extension](data_string) + dataset_cast = cast(Dataset, dataset) + return dataset_cast + + +def _extract_labels(data: Dataset, label_name: str) -> Tuple[np.ndarray, Mapping]: + """ + Picks out labels from the dataset and formats them to be [0, 1, ..., K-1] + where K is the number of classes. Also returns a mapping from the formatted + labels to the original labels in the dataset. + + Note: This function is not meant to be used directly. It is used by + ``cleanlab.data.Data`` to extract the formatted labels from the dataset + and stores them as attributes. + + Parameters + ---------- + label_name : str + Name of the column in the dataset that contains the labels. + + Returns + ------- + formatted_labels : np.ndarray + Labels in the format [0, 1, ..., K-1] where K is the number of classes. + + inverse_map : dict + Mapping from the formatted labels to the original labels in the dataset. + """ + + labels = labels_to_array(data[label_name]) # type: ignore[assignment] + if labels.ndim != 1: + raise ValueError("labels must be 1D numpy array.") + + label_name_feature = data.features[label_name] + if isinstance(label_name_feature, ClassLabel): + label_map = {label: label_name_feature.str2int(label) for label in label_name_feature.names} + formatted_labels = labels + else: + label_map = {label: i for i, label in enumerate(np.unique(labels))} + formatted_labels = np.vectorize(label_map.get)(labels) + inverse_map = {i: label for label, i in label_map.items()} + + return formatted_labels, inverse_map diff --git a/cleanlab/datalab/data_issues.py b/cleanlab/datalab/data_issues.py new file mode 100644 index 0000000000..5ed773a84a --- /dev/null +++ b/cleanlab/datalab/data_issues.py @@ -0,0 +1,279 @@ +# Copyright (C) 2017-2023 Cleanlab Inc. +# This file is part of cleanlab. +# +# cleanlab is free software: you can redistribute it and/or modify +# it under the terms of the GNU Affero General Public License as published +# by the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# cleanlab is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU Affero General Public License for more details. +# +# You should have received a copy of the GNU Affero General Public License +# along with cleanlab. If not, see . +""" +Module for the :py:class:`DataIssues` class, which serves as a central repository for storing +information and statistics about issues found in a dataset. + +It collects information from various +:py:class:`IssueManager ` +instances and keeps track of each issue, a summary for each type of issue, +related information and statistics about the issues. + +The collected information can be accessed using the +:py:meth:`get_info ` method. +""" +from __future__ import annotations + +import warnings +from typing import TYPE_CHECKING, Any, Dict, Optional +import numpy as np + +import pandas as pd + +if TYPE_CHECKING: # pragma: no cover + from cleanlab.datalab.data import Data + from cleanlab.datalab.issue_manager import IssueManager + + +class DataIssues: + """ + Class that collects and stores information and statistics on issues found in a dataset. + + Parameters + ---------- + data : + The data object for which the issues are being collected. + + Parameters + ---------- + issues : pd.DataFrame + Stores information about each individual issue found in the data, + on a per-example basis. + issue_summary : pd.DataFrame + Summarizes the overall statistics for each issue type. + info : dict + A dictionary that contains information and statistics about the data and each issue type. + """ + + def __init__(self, data: Data) -> None: + self.issues: pd.DataFrame = pd.DataFrame(index=range(len(data))) + self.issue_summary: pd.DataFrame = pd.DataFrame( + columns=["issue_type", "score", "num_issues"] + ).astype({"score": np.float64, "num_issues": np.int64}) + class_names = data.class_names + self.info: Dict[str, Dict[str, Any]] = { + "statistics": { + "num_examples": len(data), + "class_names": class_names, + "num_classes": len(class_names), + "multi_label": False, + "health_score": None, + }, + } + self._label_map = data._label_map + + @property + def statistics(self) -> Dict[str, Any]: + """Returns the statistics dictionary. + + Shorthand for self.info["statistics"]. + """ + return self.info["statistics"] + + def get_issues(self, issue_name: Optional[str] = None) -> pd.DataFrame: + """ + Use this after finding issues to see which examples suffer from which types of issues. + + Parameters + ---------- + issue_name : str or None + The type of issue to focus on. If `None`, returns full DataFrame summarizing all of the types of issues detected in each example from the dataset. + + Raises + ------ + ValueError + If `issue_name` is not a type of issue previously considered in the audit. + + Returns + ------- + specific_issues : + A DataFrame where each row corresponds to an example from the dataset and columns specify: + whether this example exhibits a particular type of issue and how severely (via a numeric quality score where lower values indicate more severe instances of the issue). + + Additional columns may be present in the DataFrame depending on the type of issue specified. + """ + if issue_name is None: + return self.issues + + columns = [col for col in self.issues.columns if issue_name in col] + if not columns: + raise ValueError(f"No columns found for issue type '{issue_name}'.") + specific_issues = self.issues[columns] + info = self.get_info(issue_name=issue_name) + if issue_name == "label": + specific_issues = specific_issues.assign( + given_label=info["given_label"], predicted_label=info["predicted_label"] + ) + + if issue_name == "outlier": + column_dict = { + k: info.get(k) + for k in ["nearest_neighbor", "distance_to_nearest_neighbor"] + if info.get(k) is not None + } + specific_issues = specific_issues.assign(**column_dict) + + if issue_name == "near_duplicate": + column_dict = { + k: info.get(k) + for k in ["near_duplicate_sets", "distance_to_nearest_neighbor"] + if info.get(k) is not None + } + specific_issues = specific_issues.assign(**column_dict) + return specific_issues + + def get_summary(self, issue_name: Optional[str] = None) -> pd.DataFrame: + """Summarize the issues found in dataset of a particular type, + including how severe this type of issue is overall across the dataset. + + Parameters + ---------- + issue_name : + Name of the issue type to summarize. If `None`, summarizes each of the different issue types previously considered in the audit. + + Returns + ------- + summary : + DataFrame where each row corresponds to a type of issue, and columns quantify: + the number of examples in the dataset estimated to exhibit this type of issue, + and the overall severity of the issue across the dataset (via a numeric quality score where lower values indicate that the issue is overall more severe). + """ + if self.issue_summary.empty: + raise ValueError( + "No issues found in the dataset. " + "Call `find_issues` before calling `get_summary`." + ) + + if issue_name is None: + return self.issue_summary + + row_mask = self.issue_summary["issue_type"] == issue_name + if not any(row_mask): + raise ValueError(f"Issue type {issue_name} not found in the summary.") + return self.issue_summary[row_mask].reset_index(drop=True) + + def get_info(self, issue_name: Optional[str] = None) -> Dict[str, Any]: + """Get the info for the issue_name key. + + This function is used to get the info for a specific issue_name. If the info is not computed yet, it will raise an error. + + Parameters + ---------- + issue_name : + The issue name for which the info is required. + + Returns + ------- + info: + The info for the issue_name. + """ + info = self.info.get(issue_name, None) if issue_name else self.info + if info is None: + raise ValueError( + f"issue_name {issue_name} not found in self.info. These have not been computed yet." + ) + info = info.copy() + if issue_name == "label": + # Labels that are stored as integers may need to be converted to strings. + for key in ["given_label", "predicted_label"]: + labels = info.get(key, None) + if labels is not None: + info[key] = np.vectorize(self._label_map.get)(labels) + + info["class_names"] = self.statistics["class_names"] + return info + + def collect_statistics_from_issue_manager(self, issue_manager: IssueManager) -> None: + """Update the statistics in the info dictionary. + + Parameters + ---------- + statistics : + A dictionary of statistics to add/update in the info dictionary. + + Examples + -------- + + A common use case is to reuse the KNN-graph across multiple issue managers. + To avoid recomputing the KNN-graph for each issue manager, + we can pass it as a statistic to the issue managers. + + >>> from scipy.sparse import csr_matrix + >>> weighted_knn_graph = csr_matrix(...) + >>> issue_manager_that_computes_knn_graph = ... + + """ + key = "statistics" + statistics: Dict[str, Any] = issue_manager.info.pop(key, {}) + if statistics: + self.info[key].update(statistics) + + def collect_results_from_issue_manager(self, issue_manager: IssueManager) -> None: + """ + Collects results from an IssueManager and update the corresponding + attributes of the Datalab object. + + This includes: + - self.issues + - self.issue_summary + - self.info + + Parameters + ---------- + issue_manager : + IssueManager object to collect results from. + """ + overlapping_columns = list(set(self.issues.columns) & set(issue_manager.issues.columns)) + if overlapping_columns: + warnings.warn( + f"Overwriting columns {overlapping_columns} in self.issues with " + f"columns from issue manager {issue_manager}." + ) + self.issues.drop(columns=overlapping_columns, inplace=True) + self.issues = self.issues.join(issue_manager.issues, how="outer") + + if issue_manager.issue_name in self.issue_summary["issue_type"].values: + warnings.warn( + f"Overwriting row in self.issue_summary with " + f"row from issue manager {issue_manager}." + ) + self.issue_summary = self.issue_summary[ + self.issue_summary["issue_type"] != issue_manager.issue_name + ] + issue_column_name: str = f"is_{issue_manager.issue_name}_issue" + num_issues: int = int(issue_manager.issues[issue_column_name].sum()) + self.issue_summary = pd.concat( + [ + self.issue_summary, + issue_manager.summary.assign(num_issues=num_issues), + ], + axis=0, + ignore_index=True, + ) + + if issue_manager.issue_name in self.info: + warnings.warn( + f"Overwriting key {issue_manager.issue_name} in self.info with " + f"key from issue manager {issue_manager}." + ) + self.info[issue_manager.issue_name] = issue_manager.info + + def set_health_score(self) -> None: + """Set the health score for the dataset based on the issue summary. + + Currently, the health score is the mean of the scores for each issue type. + """ + self.info["statistics"]["health_score"] = self.issue_summary["score"].mean() diff --git a/cleanlab/datalab/datalab.py b/cleanlab/datalab/datalab.py new file mode 100644 index 0000000000..7be464ae73 --- /dev/null +++ b/cleanlab/datalab/datalab.py @@ -0,0 +1,519 @@ +# Copyright (C) 2017-2023 Cleanlab Inc. +# This file is part of cleanlab. +# +# cleanlab is free software: you can redistribute it and/or modify +# it under the terms of the GNU Affero General Public License as published +# by the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# cleanlab is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU Affero General Public License for more details. +# +# You should have received a copy of the GNU Affero General Public License +# along with cleanlab. If not, see . +""" +Datalab offers a unified audit to detect all kinds of issues in data and labels. + +.. note:: + .. include:: optional_dependencies.rst +""" +from __future__ import annotations + +from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union + +import numpy as np +import numpy.typing as npt +import pandas as pd + +import cleanlab +from cleanlab.datalab.data import Data +from cleanlab.datalab.data_issues import DataIssues +from cleanlab.datalab.display import _Displayer +from cleanlab.datalab.issue_finder import IssueFinder +from cleanlab.datalab.serialize import _Serializer +from cleanlab.datalab.report import Reporter + +if TYPE_CHECKING: # pragma: no cover + from datasets.arrow_dataset import Dataset + from scipy.sparse import csr_matrix + + DatasetLike = Union[Dataset, pd.DataFrame, Dict[str, Any], List[Dict[str, Any]], str] + +__all__ = ["Datalab"] + + +class Datalab: + """ + A single object to automatically detect all kinds of issues in datasets. + This is how we recommend you interface with the cleanlab library if you want to audit the quality of your data. If you have other specific goals, then consider using the other methods across this library. Even then, Datalab may be the easiest way to run specific analyses of your data. Datalab tracks intermediate state (e.g. data statistics) from certain cleanlab functions that can be re-used across other cleanlab functions for better efficiency. + + Parameters + ---------- + data : Union[Dataset, pd.DataFrame, dict, list, str] + Dataset-like object that can be converted to a Hugging Face Dataset object. + + It should contain the labels for all examples, identified by a + `label_name` column in the Dataset object. + + Supported formats: + - datasets.Dataset + - pandas.DataFrame + - dict (keys are strings, values are arrays/lists of length ``N``) + - list (list of dictionaries that each have the same keys) + - str + + - path to a local file: Text (.txt), CSV (.csv), JSON (.json) + - or a dataset identifier on the Hugging Face Hub + + label_name : str + The name of the label column in the dataset. + + verbosity : int, optional + The higher the verbosity level, the more information + Datalab prints when auditing a dataset. + Valid values are 0 through 4. Default is 1. + + Examples + -------- + >>> import datasets + >>> from cleanlab import Datalab + >>> data = datasets.load_dataset("glue", "sst2", split="train") + >>> datalab = Datalab(data, label_name="label") + """ + + def __init__( + self, + data: "DatasetLike", + label_name: str, + verbosity: int = 1, + ) -> None: + self._data = Data(data, label_name) + self.data = self._data._data + self._labels, self._label_map = self._data._labels, self._data._label_map + self._data_hash = self._data._data_hash + self.label_name = self._data._label_name + self.data_issues = DataIssues(self._data) + self.cleanlab_version = cleanlab.version.__version__ + self.verbosity = verbosity + + def __repr__(self) -> str: + return _Displayer(data_issues=self.data_issues).__repr__() + + def __str__(self) -> str: + return _Displayer(data_issues=self.data_issues).__str__() + + @property + def labels(self) -> np.ndarray: + """Labels of the dataset, in a [0, 1, ..., K-1] format.""" + return self._labels + + @property + def class_names(self) -> List[str]: + """Names of the classes in the dataset.""" + return self._data.class_names + + def find_issues( + self, + *, + pred_probs: Optional[np.ndarray] = None, + features: Optional[npt.NDArray] = None, + knn_graph: Optional[csr_matrix] = None, + issue_types: Optional[Dict[str, Any]] = None, + ) -> None: + """ + Checks the dataset for all sorts of common issues in real-world data (in both labels and feature values). + + You can use Datalab to find issues in your data, utilizing *any* model you have already trained. + This method only interacts with your model via its predictions or embeddings (and other functions thereof). + The more of these inputs you provide, the more types of issues Datalab can detect in your dataset/labels. + If you provide a subset of these inputs, Datalab will output what insights it can based on the limited information from your model. + + Note + ---- + This method acts as a wrapper around the :py:meth:`IssueFinder.find_issues ` method, + where the core logic for issue detection is implemented. + + Note + ---- + The issues are saved in the ``self.issues`` attribute, but are not returned. + + Parameters + ---------- + pred_probs : + Out-of-sample predicted class probabilities made by the model for every example in the dataset. + To best detect label issues, provide this input obtained from the most accurate model you can produce. + + If provided, this must be a 2D array with shape (num_examples, K) where K is the number of classes in the dataset. + + features : Optional[np.ndarray] + Feature embeddings (vector representations) of every example in the dataset. + + If provided, this must be a 2D array with shape (num_examples, num_features). + + knn_graph : + Sparse matrix representing distances between examples in the dataset in a k nearest neighbor graph. + + If provided, this must be a square CSR matrix with shape (num_examples, num_examples) and (k*num_examples) non-zero entries (k is the number of nearest neighbors considered for each example) + evenly distributed across the rows. + The non-zero entries must be the distances between the corresponding examples. Self-distances must be omitted + (i.e. the diagonal must be all zeros and the k nearest neighbors of each example must not include itself). + + For any duplicated examples i,j whose distance is 0, there should be an *explicit* zero stored in the matrix, i.e. ``knn_graph[i,j] = 0``. + + If both `knn_graph` and `features` are provided, the `knn_graph` will take precendence. + If `knn_graph` is not provided, it is constructed based on the provided `features`. + If neither `knn_graph` nor `features` are provided, certain issue types like (near) duplicates will not be considered. + + issue_types : + Collection specifying which types of issues to consider in audit and any non-default parameter settings to use. + If unspecified, a default set of issue types and recommended parameter settings is considered. + + This is a dictionary of dictionaries, where the keys are the issue types of interest + and the values are dictionaries of parameter values that control how each type of issue is detected (only for advanced users). + More specifically, the values are constructor keyword arguments passed to the corresponding ``IssueManager``, + which is responsible for detecting the particular issue type. + + .. seealso:: + :py:class:`IssueManager ` + + Examples + -------- + + Here are some ways to provide inputs to :py:meth:`find_issues`: + + - Passing ``pred_probs``: + + .. code-block:: python + + >>> from sklearn.linear_model import LogisticRegression + >>> import numpy as np + >>> from cleanlab import Datalab + >>> X = np.array([[0, 1], [1, 1], [2, 2], [2, 0]]) + >>> y = np.array([0, 1, 1, 0]) + >>> clf = LogisticRegression(random_state=0).fit(X, y) + >>> pred_probs = clf.predict_proba(X) + >>> lab = Datalab(data={"X": X, "y": y}, label_name="y") + >>> lab.find_issues(pred_probs=pred_probs) + + + - Passing ``features``: + + .. code-block:: python + + >>> from sklearn.linear_model import LogisticRegression + >>> from sklearn.neighbors import NearestNeighbors + >>> import numpy as np + >>> from cleanlab import Datalab + >>> X = np.array([[0, 1], [1, 1], [2, 2], [2, 0]]) + >>> y = np.array([0, 1, 1, 0]) + >>> lab = Datalab(data={"X": X, "y": y}, label_name="y") + >>> lab.find_issues(features=X) + + .. note:: + + You can pass both ``pred_probs`` and ``features`` to :py:meth:`find_issues` for a more comprehensive audit. + + - Passing a ``knn_graph``: + + .. code-block:: python + + >>> from sklearn.neighbors import NearestNeighbors + >>> import numpy as np + >>> from cleanlab import Datalab + >>> X = np.array([[0, 1], [1, 1], [2, 2], [2, 0]]) + >>> y = np.array([0, 1, 1, 0]) + >>> nbrs = NearestNeighbors(n_neighbors=2, metric="euclidean").fit(X) + >>> knn_graph = nbrs.kneighbors_graph(mode="distance") + >>> knn_graph # Pass this to Datalab + <4x4 sparse matrix of type '' + with 8 stored elements in Compressed Sparse Row format> + >>> knn_graph.toarray() # DO NOT PASS knn_graph.toarray() to Datalab, only pass the sparse matrix itself + array([[0. , 1. , 2.23606798, 0. ], + [1. , 0. , 1.41421356, 0. ], + [0. , 1.41421356, 0. , 2. ], + [0. , 1.41421356, 2. , 0. ]]) + >>> lab = Datalab(data={"X": X, "y": y}, label_name="y") + >>> lab.find_issues(knn_graph=knn_graph) + + - Configuring issue types: + + Suppose you want to only consider label issues. Just pass a dictionary with the key "label" and an empty dictionary as the value (to use default label issue parameters). + + .. code-block:: python + + >>> issue_types = {"label": {}} + >>> # lab.find_issues(pred_probs=pred_probs, issue_types=issue_types) + + If you are advanced user who wants greater control, you can pass keyword arguments to the issue manager that handles the label issues. + For example, if you want to pass the keyword argument "clean_learning_kwargs" + to the constructor of the :py:class:`LabelIssueManager `, you would pass: + + + .. code-block:: python + + >>> issue_types = { + ... "label": { + ... "clean_learning_kwargs": { + ... "prune_method": "prune_by_noise_rate", + ... }, + ... }, + ... } + >>> # lab.find_issues(pred_probs=pred_probs, issue_types=issue_types) + + """ + issue_finder = IssueFinder(datalab=self, verbosity=self.verbosity) + issue_finder.find_issues( + pred_probs=pred_probs, + features=features, + knn_graph=knn_graph, + issue_types=issue_types, + ) + + def report( + self, + *, + num_examples: int = 5, + verbosity: Optional[int] = None, + include_description: bool = True, + ) -> None: + """Prints informative summary of all issues. + + Parameters + ---------- + num_examples : + Number of examples to show for each type of issue. + The report shows the top `num_examples` instances in the dataset that suffer the most from each type of issue. + + verbosity : + Higher verbosity levels add more information to the report. + + include_description : + Whether or not to include a description of each issue type in the report. + Consider setting this to ``False`` once you're familiar with how each issue type is defined. + + See Also + -------- + For advanced usage, see documentation for the :py:class:`Reporter ` class. + """ + if verbosity is None: + verbosity = self.verbosity + reporter = Reporter( + data_issues=self.data_issues, + verbosity=verbosity, + include_description=include_description, + ) + print(reporter.get_report(num_examples=num_examples)) + + @property + def issues(self) -> pd.DataFrame: + """Issues found in each example from the dataset.""" + return self.data_issues.issues + + @issues.setter + def issues(self, issues: pd.DataFrame) -> None: + self.data_issues.issues = issues + + @property + def issue_summary(self) -> pd.DataFrame: + """Summary of issues found in the dataset and the overall severity of each type of issue. + + This is a wrapper around the ``DataIssues.issue_summary`` attribute. + + Examples + ------- + + If checks for "label" and "outlier" issues were run, + then the issue summary will look something like this: + + >>> datalab.issue_summary + issue_type score + outlier 0.123 + label 0.456 + """ + return self.data_issues.issue_summary + + @issue_summary.setter + def issue_summary(self, issue_summary: pd.DataFrame) -> None: + self.data_issues.issue_summary = issue_summary + + @property + def info(self) -> Dict[str, Dict[str, Any]]: + """Information and statistics about the dataset issues found. + + This is a wrapper around the ``DataIssues.info`` attribute. + + Examples + ------- + + If checks for "label" and "outlier" issues were run, + then the info will look something like this: + + >>> datalab.info + { + "label": { + "given_labels": [0, 1, 0, 1, 1, 1, 1, 1, 0, 1, ...], + "predicted_label": [0, 0, 0, 1, 0, 1, 0, 1, 0, 1, ...], + ..., + }, + "outlier": { + "nearest_neighbor": [3, 7, 1, 2, 8, 4, 5, 9, 6, 0, ...], + "distance_to_nearest_neighbor": [0.123, 0.789, 0.456, ...], + ..., + }, + } + """ + return self.data_issues.info + + @info.setter + def info(self, info: Dict[str, Dict[str, Any]]) -> None: + self.data_issues.info = info + + def get_issues(self, issue_name: Optional[str] = None) -> pd.DataFrame: + """ + Use this after finding issues to see which examples suffer from which types of issues. + + NOTE + ---- + This is a wrapper around the :py:meth:`DataIssues.get_issues ` method. + + Parameters + ---------- + issue_name : str or None + The type of issue to focus on. If `None`, returns full DataFrame summarizing all of the types of issues detected in each example from the dataset. + + Raises + ------ + ValueError + If `issue_name` is not a type of issue previously considered in the audit. + + Returns + ------- + specific_issues : + A DataFrame where each row corresponds to an example from the dataset and columns specify: + whether this example exhibits a particular type of issue and how severely (via a numeric quality score where lower values indicate more severe instances of the issue). + + Additional columns may be present in the DataFrame depending on the type of issue specified. + """ + return self.data_issues.get_issues(issue_name=issue_name) + + def get_summary(self, issue_name: Optional[str] = None) -> pd.DataFrame: + """Summarize the issues found in dataset of a particular type, + including how severe this type of issue is overall across the dataset. + + NOTE + ---- + This is a wrapper around the + :py:meth:`DataIssues.get_summary ` method. + + Parameters + ---------- + issue_name : + Name of the issue type to summarize. If `None`, summarizes each of the different issue types previously considered in the audit. + + Returns + ------- + summary : + DataFrame where each row corresponds to a type of issue, and columns quantify: + the number of examples in the dataset estimated to exhibit this type of issue, + and the overall severity of the issue across the dataset (via a numeric quality score where lower values indicate that the issue is overall more severe). + """ + return self.data_issues.get_summary(issue_name=issue_name) + + def get_info(self, issue_name: Optional[str] = None) -> Dict[str, Any]: + """Get the info for the issue_name key. + + This function is used to get the info for a specific issue_name. If the info is not computed yet, it will raise an error. + + NOTE + ---- + This is a wrapper around the + :py:meth:`DataIssues.get_info ` method. + + Parameters + ---------- + issue_name : + The issue name for which the info is required. + + Returns + ------- + info: + The info for the issue_name. + """ + return self.data_issues.get_info(issue_name) + + @staticmethod + def list_possible_issue_types() -> List[str]: + """Returns a list of all registered issue types. + + Any issue type that is not in this list cannot be used in the :py:meth:`find_issues` method. + + Note + ---- + This method is a wrapper around :py:meth:`IssueFinder.list_possible_issue_types `. + + See Also + -------- + :py:class:`REGISTRY ` : All available issue types and their corresponding issue managers can be found here. + """ + return IssueFinder.list_possible_issue_types() + + @staticmethod + def list_default_issue_types() -> List[str]: + """Returns a list of the issue types that are run by default + when :py:meth:`find_issues` is called without specifying `issue_types`. + + Note + ---- + This method is a wrapper around :py:meth:`IssueFinder.list_default_issue_types `. + + See Also + -------- + :py:class:`REGISTRY ` : All available issue types and their corresponding issue managers can be found here. + """ + return IssueFinder.list_default_issue_types() + + def save(self, path: str, force: bool = False) -> None: + """Saves this Datalab object to file (all files are in folder at `path/`). + We do not guarantee saved Datalab can be loaded from future versions of cleanlab. + + Parameters + ---------- + path : + Folder in which all information about this Datalab should be saved. + + force : + If ``True``, overwrites any existing files in the folder at `path`. Use this with caution! + + Note + ---- + You have to save the Dataset yourself separately if you want it saved to file. + """ + _Serializer.serialize(path=path, datalab=self, force=force) + save_message = f"Saved Datalab to folder: {path}" + print(save_message) + + @staticmethod + def load(path: str, data: Optional[Dataset] = None) -> "Datalab": + """Loads Datalab object from a previously saved folder. + + Parameters + ---------- + `path` : + Path to the folder previously specified in ``Datalab.save()``. + + `data` : + The dataset used to originally construct the Datalab. + Remember the dataset is not saved as part of the Datalab, + you must save/load the data separately. + + Returns + ------- + `datalab` : + A Datalab object that is identical to the one originally saved. + """ + datalab = _Serializer.deserialize(path=path, data=data) + load_message = f"Datalab loaded from folder: {path}" + print(load_message) + return datalab diff --git a/cleanlab/datalab/display.py b/cleanlab/datalab/display.py new file mode 100644 index 0000000000..520b261516 --- /dev/null +++ b/cleanlab/datalab/display.py @@ -0,0 +1,61 @@ +# Copyright (C) 2017-2023 Cleanlab Inc. +# This file is part of cleanlab. +# +# cleanlab is free software: you can redistribute it and/or modify +# it under the terms of the GNU Affero General Public License as published +# by the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# cleanlab is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU Affero General Public License for more details. +# +# You should have received a copy of the GNU Affero General Public License +# along with cleanlab. If not, see . +""" +Module that handles the string representation of Datalab objects. +""" + +from typing import TYPE_CHECKING + +if TYPE_CHECKING: # pragma: no cover + from cleanlab.datalab.data_issues import DataIssues + + +class _Displayer: + def __init__(self, data_issues: "DataIssues") -> None: + self.data_issues = data_issues + + def __repr__(self) -> str: + """What is displayed in console if user executes: >>> datalab""" + checks_run = not self.data_issues.issues.empty + display_str = f"checks_run={checks_run}" + num_examples = self.data_issues.get_info("statistics")["num_examples"] + if num_examples is not None: + display_str += f", num_examples={num_examples}" + num_classes = self.data_issues.get_info("statistics")["num_classes"] + if num_classes is not None: + display_str += f", num_classes={num_classes}" + if checks_run: + issues_identified = self.data_issues.issue_summary["num_issues"].sum() + display_str += f", issues_identified={issues_identified}" + return f"Datalab({display_str})" + + def __str__(self) -> str: + """What is displayed if user executes: print(datalab)""" + checks_run = not self.data_issues.issues.empty + num_examples = self.data_issues.get_info("statistics").get("num_examples") + num_classes = self.data_issues.get_info("statistics").get("num_classes") + + issues_identified = ( + self.data_issues.issue_summary["num_issues"].sum() if checks_run else "Not checked" + ) + info_list = [ + f"Checks run: {'Yes' if checks_run else 'No'}", + f"Number of examples: {num_examples if num_examples is not None else 'Unknown'}", + f"Number of classes: {num_classes if num_classes is not None else 'Unknown'}", + f"Issues identified: {issues_identified}", + ] + + return "Datalab:\n" + "\n".join(info_list) diff --git a/cleanlab/datalab/examples/__init__.py b/cleanlab/datalab/examples/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/cleanlab/datalab/factory.py b/cleanlab/datalab/factory.py new file mode 100644 index 0000000000..0cbe8f5262 --- /dev/null +++ b/cleanlab/datalab/factory.py @@ -0,0 +1,155 @@ +# Copyright (C) 2017-2023 Cleanlab Inc. +# This file is part of cleanlab. +# +# cleanlab is free software: you can redistribute it and/or modify +# it under the terms of the GNU Affero General Public License as published +# by the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# cleanlab is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU Affero General Public License for more details. +# +# You should have received a copy of the GNU Affero General Public License +# along with cleanlab. If not, see . +"""The factory module provides a factory class for constructing concrete issue managers +and a decorator for registering new issue managers. + +This module provides the :py:meth:`register` decorator for users to register new subclasses of +:py:class:`IssueManager ` +in the registry. Each IssueManager detects some particular type of issue in a dataset. + + +Note +---- + +The :class:`REGISTRY` variable is used by the factory class to keep track +of registered issue managers. +The factory class is used as an implementation detail by +:py:class:`Datalab `, +which provides a simplified API for constructing concrete issue managers. +:py:class:`Datalab ` is intended to be used by users +and provides detailed documentation on how to use the API. + +Warning +------- +Neither the :class:`REGISTRY` variable nor the factory class should be used directly by users. +""" +from __future__ import annotations + +from typing import Dict, List, Type + +from cleanlab.datalab.issue_manager import ( + IssueManager, + LabelIssueManager, + NearDuplicateIssueManager, + OutlierIssueManager, + NonIIDIssueManager, +) + + +REGISTRY: Dict[str, Type[IssueManager]] = { + "outlier": OutlierIssueManager, + "label": LabelIssueManager, + "near_duplicate": NearDuplicateIssueManager, + "non_iid": NonIIDIssueManager, +} +"""Registry of issue managers that can be constructed from a string +and used in the Datalab class. + +:meta hide-value: + +Currently, the following issue managers are registered by default: + +- ``"outlier"``: :py:class:`OutlierIssueManager ` +- ``"label"``: :py:class:`LabelIssueManager ` +- ``"near_duplicate"``: :py:class:`NearDuplicateIssueManager ` +- ``"non_iid"``: :py:class:`NonIIDIssueManager ` + +Warning +------- +This variable should not be used directly by users. +""" + + +# Construct concrete issue manager with a from_str method +class _IssueManagerFactory: + """Factory class for constructing concrete issue managers.""" + + @classmethod + def from_str(cls, issue_type: str) -> Type[IssueManager]: + """Constructs a concrete issue manager class from a string.""" + if isinstance(issue_type, list): + raise ValueError( + "issue_type must be a string, not a list. Try using from_list instead." + ) + if issue_type not in REGISTRY: + raise ValueError(f"Invalid issue type: {issue_type}") + return REGISTRY[issue_type] + + @classmethod + def from_list(cls, issue_types: List[str]) -> List[Type[IssueManager]]: + """Constructs a list of concrete issue manager classes from a list of strings.""" + return [cls.from_str(issue_type) for issue_type in issue_types] + + +def register(cls: Type[IssueManager]) -> Type[IssueManager]: + """Registers the issue manager factory. + + Parameters + ---------- + cls : + A subclass of + :py:class:`IssueManager `. + + Returns + ------- + cls : + The same class that was passed in. + + Example + ------- + + When defining a new subclass of + :py:class:`IssueManager `, + you can register it like so: + + .. code-block:: python + + from cleanlab import IssueManager + from cleanlab.datalab.factory import register + + @register + class MyIssueManager(IssueManager): + issue_name: str = "my_issue" + def find_issues(self, **kwargs): + # Some logic to find issues + pass + + or in a function call: + + .. code-block:: python + + from cleanlab import IssueManager + from cleanlab.datalab.factory import register + + class MyIssueManager(IssueManager): + issue_name: str = "my_issue" + def find_issues(self, **kwargs): + # Some logic to find issues + pass + + register(MyIssueManager) + """ + name: str = str(cls.issue_name) + if name in REGISTRY: + # Warn user that they are overwriting an existing issue manager + print( + f"Warning: Overwriting existing issue manager {name} with {cls}. " + "This may cause unexpected behavior." + ) + if not issubclass(cls, IssueManager): + raise ValueError(f"Class {cls} must be a subclass of IssueManager") + REGISTRY[name] = cls + return cls diff --git a/cleanlab/datalab/issue_finder.py b/cleanlab/datalab/issue_finder.py new file mode 100644 index 0000000000..c3de568ecd --- /dev/null +++ b/cleanlab/datalab/issue_finder.py @@ -0,0 +1,351 @@ +# Copyright (C) 2017-2023 Cleanlab Inc. +# This file is part of cleanlab. +# +# cleanlab is free software: you can redistribute it and/or modify +# it under the terms of the GNU Affero General Public License as published +# by the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# cleanlab is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU Affero General Public License for more details. +# +# You should have received a copy of the GNU Affero General Public License +# along with cleanlab. If not, see . +""" +Module for the :class:`IssueFinder` class, which is responsible for configuring, +creating and running issue managers. + +It determines which types of issues to look for, instatiates the IssueManagers +via a factory, run the issue managers +(:py:meth:`IssueManager.find_issues `), +and collects the results to :py:class:`DataIssues `. + +.. note:: + + This module is not intended to be used directly. Instead, use the public-facing + :py:meth:`Datalab.find_issues ` method. +""" + +from typing import Any, List, Optional, Dict, TYPE_CHECKING +import warnings + +import numpy as np +import numpy.typing as npt +from scipy.sparse import csr_matrix + +from cleanlab.datalab.factory import _IssueManagerFactory, REGISTRY + +if TYPE_CHECKING: # pragma: no cover + from cleanlab.datalab.datalab import Datalab + + +class IssueFinder: + """ + The IssueFinder class is responsible for managing the process of identifying + issues in the dataset by handling the creation and execution of relevant + IssueManagers. It serves as a coordinator or helper class for the Datalab class + to encapsulate the specific behavior of the issue finding process. + + At a high level, the IssueFinder is responsible for: + + - Determining which types of issues to look for. + - Instantiating the appropriate IssueManagers using a factory. + - Running the IssueManagers' `find_issues` methods. + - Collecting the results into a DataIssues instance. + + Parameters + ---------- + datalab : Datalab + The Datalab instance associated with this IssueFinder. + + verbosity : int + Controls the verbosity of the output during the issue finding process. + + Note + ---- + This class is not intended to be used directly. Instead, use the + `Datalab.find_issues` method which internally utilizes an IssueFinder instance. + """ + + def __init__(self, datalab: "Datalab", verbosity=1): + self.datalab = datalab + self.verbosity = verbosity + + def find_issues( + self, + *, + pred_probs: Optional[np.ndarray] = None, + features: Optional[npt.NDArray] = None, + knn_graph: Optional[csr_matrix] = None, + issue_types: Optional[Dict[str, Any]] = None, + ) -> None: + """ + Checks the dataset for all sorts of common issues in real-world data (in both labels and feature values). + + You can use Datalab to find issues in your data, utilizing *any* model you have already trained. + This method only interacts with your model via its predictions or embeddings (and other functions thereof). + The more of these inputs you provide, the more types of issues Datalab can detect in your dataset/labels. + If you provide a subset of these inputs, Datalab will output what insights it can based on the limited information from your model. + + Note + ---- + This method is not intended to be used directly. Instead, use the + :py:meth:`Datalab.find_issues ` method. + + Note + ---- + The issues are saved in the ``self.datalab.data_issues.issues`` attribute, but are not returned. + + Parameters + ---------- + pred_probs : + Out-of-sample predicted class probabilities made by the model for every example in the dataset. + To best detect label issues, provide this input obtained from the most accurate model you can produce. + + If provided, this must be a 2D array with shape (num_examples, K) where K is the number of classes in the dataset. + + features : Optional[np.ndarray] + Feature embeddings (vector representations) of every example in the dataset. + + If provided, this must be a 2D array with shape (num_examples, num_features). + + knn_graph : + Sparse matrix representing distances between examples in the dataset in a k nearest neighbor graph. + + If provided, this must be a square CSR matrix with shape (num_examples, num_examples) and (k*num_examples) non-zero entries (k is the number of nearest neighbors considered for each example) + evenly distributed across the rows. + The non-zero entries must be the distances between the corresponding examples. Self-distances must be omitted + (i.e. the diagonal must be all zeros and the k nearest neighbors of each example must not include itself). + + For any duplicated examples i,j whose distance is 0, there should be an *explicit* zero stored in the matrix, i.e. ``knn_graph[i,j] = 0``. + + If both `knn_graph` and `features` are provided, the `knn_graph` will take precendence. + If `knn_graph` is not provided, it is constructed based on the provided `features`. + If neither `knn_graph` nor `features` are provided, certain issue types like (near) duplicates will not be considered. + + issue_types : + Collection specifying which types of issues to consider in audit and any non-default parameter settings to use. + If unspecified, a default set of issue types and recommended parameter settings is considered. + + This is a dictionary of dictionaries, where the keys are the issue types of interest + and the values are dictionaries of parameter values that control how each type of issue is detected (only for advanced users). + More specifically, the values are constructor keyword arguments passed to the corresponding ``IssueManager``, + which is responsible for detecting the particular issue type. + + .. seealso:: + :py:class:`IssueManager ` + """ + + if issue_types is not None and not issue_types: + warnings.warn( + "No issue types were specified. " "No issues will be found in the dataset." + ) + return None + + if issue_types is not None and not issue_types: + warnings.warn( + "No issue types were specified. " "No issues will be found in the dataset." + ) + return None + + issue_types_copy = self.get_available_issue_types( + pred_probs=pred_probs, + features=features, + knn_graph=knn_graph, + issue_types=issue_types, + ) + + new_issue_managers = [ + factory(datalab=self.datalab, **issue_types_copy.get(factory.issue_name, {})) + for factory in _IssueManagerFactory.from_list(list(issue_types_copy.keys())) + ] + + if not new_issue_managers: + no_args_passed = all(arg is None for arg in [pred_probs, features, knn_graph]) + if no_args_passed: + warnings.warn("No arguments were passed to find_issues.") + warnings.warn("No issue check performed.") + return None + + failed_managers = [] + data_issues = self.datalab.data_issues + for issue_manager, arg_dict in zip(new_issue_managers, issue_types_copy.values()): + try: + if self.verbosity: + print(f"Finding {issue_manager.issue_name} issues ...") + issue_manager.find_issues(**arg_dict) + data_issues.collect_statistics_from_issue_manager(issue_manager) + data_issues.collect_results_from_issue_manager(issue_manager) + except Exception as e: + print(f"Error in {issue_manager.issue_name}: {e}") + failed_managers.append(issue_manager) + + if self.verbosity: + print( + f"Audit complete. {data_issues.issue_summary['num_issues'].sum()} issues found in the dataset." + ) + if failed_managers: + print(f"Failed to check for these issue types: {failed_managers}") + + data_issues.set_health_score() + + def _resolve_required_args(self, pred_probs, features, knn_graph): + """Resolves the required arguments for each issue type. + + This is a helper function that filters out any issue manager + that does not have the required arguments. + + This does not consider custom hyperparameters for each issue type. + + + Parameters + ---------- + pred_probs : + Out-of-sample predicted probabilities made on the data. + + features : + Name of column containing precomputed embeddings. + + Returns + ------- + args_dict : + Dictionary of required arguments for each issue type, if available. + """ + args_dict = { + "label": {"pred_probs": pred_probs}, + "outlier": {"pred_probs": pred_probs, "features": features, "knn_graph": knn_graph}, + "near_duplicate": {"features": features, "knn_graph": knn_graph}, + "non_iid": {"features": features, "knn_graph": knn_graph}, + } + + args_dict = { + k: {k2: v2 for k2, v2 in v.items() if v2 is not None} for k, v in args_dict.items() if v + } + + # Prefer `knn_graph` over `features` if both are provided. + for v in args_dict.values(): + if "knn_graph" in v and "features" in v: + warnings.warn( + "Both `features` and `knn_graph` were provided. " + "Most issue managers will likely prefer using `knn_graph` " + "instead of `features` for efficiency." + ) + + args_dict = {k: v for k, v in args_dict.items() if v} + + return args_dict + + def _set_issue_types( + self, + issue_types: Optional[Dict[str, Any]], + required_defaults_dict: Dict[str, Any], + ) -> Dict[str, Any]: + """Set necessary configuration for each IssueManager in a dictionary. + + While each IssueManager defines default values for its arguments, + the Datalab class needs to organize the calls to each IssueManager + with different arguments, some of which may be user-provided. + + Parameters + ---------- + issue_types : + Dictionary of issue types and argument configuration for their respective IssueManagers. + If None, then the `required_defaults_dict` is used. + + required_defaults_dict : + Dictionary of default parameter configuration for each issue type. + + Returns + ------- + issue_types_copy : + Dictionary of issue types and their parameter configuration. + The input `issue_types` is copied and updated with the necessary default values. + """ + if issue_types is not None: + issue_types_copy = issue_types.copy() + self._check_missing_args(required_defaults_dict, issue_types_copy) + else: + issue_types_copy = required_defaults_dict.copy() + # Check that all required arguments are provided. + self._validate_issue_types_dict(issue_types_copy, required_defaults_dict) + + # Remove None values from argument list, rely on default values in IssueManager + for key, value in issue_types_copy.items(): + issue_types_copy[key] = {k: v for k, v in value.items() if v is not None} + return issue_types_copy + + @staticmethod + def _check_missing_args(required_defaults_dict, issue_types): + for key, issue_type_value in issue_types.items(): + missing_args = set(required_defaults_dict.get(key, {})) - set(issue_type_value.keys()) + # Impute missing arguments with default values. + missing_dict = { + missing_arg: required_defaults_dict[key][missing_arg] + for missing_arg in missing_args + } + issue_types[key].update(missing_dict) + + @staticmethod + def _validate_issue_types_dict( + issue_types: Dict[str, Any], required_defaults_dict: Dict[str, Any] + ) -> None: + missing_required_args_dict = {} + for issue_name, required_args in required_defaults_dict.items(): + if issue_name in issue_types: + missing_args = set(required_args.keys()) - set(issue_types[issue_name].keys()) + if missing_args: + missing_required_args_dict[issue_name] = missing_args + if any(missing_required_args_dict.values()): + error_message = "" + for issue_name, missing_required_args in missing_required_args_dict.items(): + error_message += f"Required argument {missing_required_args} for issue type {issue_name} was not provided.\n" + raise ValueError(error_message) + + @staticmethod + def list_possible_issue_types() -> List[str]: + """Returns a list of all registered issue types. + + Any issue type that is not in this list cannot be used in the :py:meth:`find_issues` method. + + See Also + -------- + :py:class:`REGISTRY ` : All available issue types and their corresponding issue managers can be found here. + """ + return list(REGISTRY.keys()) + + @staticmethod + def list_default_issue_types() -> List[str]: + """Returns a list of the issue types that are run by default + when :py:meth:`find_issues` is called without specifying `issue_types`. + + See Also + -------- + :py:class:`REGISTRY ` : All available issue types and their corresponding issue managers can be found here. + """ + return ["label", "outlier", "near_duplicate"] + + def get_available_issue_types(self, **kwargs): + """Returns a dictionary of issue types that can be used in :py:meth:`Datalab.find_issues + ` method.""" + + pred_probs = kwargs.get("pred_probs", None) + features = kwargs.get("features", None) + knn_graph = kwargs.get("knn_graph", None) + issue_types = kwargs.get("issue_types", None) + + # Determine which parameters are required for each issue type + required_args_per_issue_type = self._resolve_required_args(pred_probs, features, knn_graph) + + issue_types_copy = self._set_issue_types(issue_types, required_args_per_issue_type) + + if issue_types is None: + # Only run default issue types if no issue types are specified + issue_types_copy = { + issue: issue_types_copy[issue] + for issue in self.list_default_issue_types() + if issue in issue_types_copy + } + + return issue_types_copy diff --git a/cleanlab/datalab/issue_manager/__init__.py b/cleanlab/datalab/issue_manager/__init__.py new file mode 100644 index 0000000000..0352a6a03a --- /dev/null +++ b/cleanlab/datalab/issue_manager/__init__.py @@ -0,0 +1,5 @@ +from .issue_manager import IssueManager # isort:skip +from .duplicate import NearDuplicateIssueManager +from .label import LabelIssueManager +from .outlier import OutlierIssueManager +from .noniid import NonIIDIssueManager diff --git a/cleanlab/datalab/issue_manager/duplicate.py b/cleanlab/datalab/issue_manager/duplicate.py new file mode 100644 index 0000000000..dcfdbde2a6 --- /dev/null +++ b/cleanlab/datalab/issue_manager/duplicate.py @@ -0,0 +1,222 @@ +# Copyright (C) 2017-2023 Cleanlab Inc. +# This file is part of cleanlab. +# +# cleanlab is free software: you can redistribute it and/or modify +# it under the terms of the GNU Affero General Public License as published +# by the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# cleanlab is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU Affero General Public License for more details. +# +# You should have received a copy of the GNU Affero General Public License +# along with cleanlab. If not, see . +from __future__ import annotations + +from typing import TYPE_CHECKING, Any, ClassVar, Dict, List, Optional, Union +import warnings + +import numpy as np +import numpy.typing as npt +import pandas as pd +from scipy.sparse import csr_matrix +from sklearn.neighbors import NearestNeighbors +from sklearn.utils.validation import check_is_fitted + +from cleanlab.datalab.issue_manager import IssueManager + +if TYPE_CHECKING: # pragma: no cover + from cleanlab.datalab.datalab import Datalab + + +class NearDuplicateIssueManager(IssueManager): + """Manages issues related to near-duplicate examples.""" + + description: ClassVar[ + str + ] = """A (near) duplicate issue refers to two or more examples in + a dataset that are extremely similar to each other, relative + to the rest of the dataset. The examples flagged with this issue + may be exactly duplicated, or lie atypically close together when + represented as vectors (i.e. feature embeddings). + """ + issue_name: ClassVar[str] = "near_duplicate" + verbosity_levels = { + 0: [], + 1: ["threshold"], + 2: [], + } + + def __init__( + self, + datalab: Datalab, + metric: Optional[str] = None, + threshold: float = 0.13, + k: int = 10, + **_, + ): + super().__init__(datalab) + self.metric = metric + self.threshold = self._set_threshold(threshold) + self.k = k + self.near_duplicate_sets: List[List[int]] = [] + + def find_issues( + self, + features: Optional[npt.NDArray] = None, + **kwargs, + ) -> None: + knn_graph = self._process_knn_graph_from_inputs(kwargs) + old_knn_metric = self.datalab.get_info("statistics").get("knn_metric") + metric_changes = self.metric and self.metric != old_knn_metric + + if knn_graph is None or metric_changes: + if features is None: + raise ValueError( + "If a knn_graph is not provided, features must be provided to fit a new knn." + ) + if self.metric is None: + self.metric = "cosine" if features.shape[1] > 3 else "euclidean" + knn = NearestNeighbors(n_neighbors=self.k, metric=self.metric) + + if self.metric and self.metric != knn.metric: + warnings.warn( + f"Metric {self.metric} does not match metric {knn.metric} used to fit knn. " + "Most likely an existing NearestNeighbors object was passed in, but a different " + "metric was specified." + ) + self.metric = knn.metric + + try: + check_is_fitted(knn) + except: + knn.fit(features) + + knn_graph = knn.kneighbors_graph(mode="distance") + N = knn_graph.shape[0] + nn_distances = knn_graph.data.reshape(N, -1)[:, 0] + scores = np.tanh(nn_distances) + is_issue_column = nn_distances < self.threshold * np.median(nn_distances) + + self.issues = pd.DataFrame( + { + f"is_{self.issue_name}_issue": is_issue_column, + self.issue_score_key: scores, + }, + ) + + self.near_duplicate_sets = self._neighbors_within_radius(knn_graph, self.threshold) + + self.summary = self.make_summary(score=scores.mean()) + self.info = self.collect_info(knn_graph=knn_graph) + + @staticmethod + def _neighbors_within_radius(knn_graph: csr_matrix, radius: float): + """Returns a list of lists of indices of near-duplicate examples. + + Each list of indices represents a set of near-duplicate examples. + + If the list is empty for a given example, then that example is not + a near-duplicate of any other example. + """ + + N = knn_graph.shape[0] + distances = knn_graph.data.reshape(N, -1) + # Create a mask for the threshold + mask = distances < radius + + # Update the indptr to reflect the new number of neighbors + indptr = np.zeros(knn_graph.indptr.shape, dtype=knn_graph.indptr.dtype) + indptr[1:] = np.cumsum(mask.sum(axis=1)) + + # Filter the knn_graph based on the threshold + indices = knn_graph.indices[mask.ravel()] + near_duplicate_sets = [indices[indptr[i] : indptr[i + 1]] for i in range(N)] + + return near_duplicate_sets + + def _process_knn_graph_from_inputs(self, kwargs: Dict[str, Any]) -> Union[csr_matrix, None]: + """Determine if a knn_graph is provided in the kwargs or if one is already stored in the associated Datalab instance.""" + knn_graph_kwargs: Optional[csr_matrix] = kwargs.get("knn_graph", None) + knn_graph_stats = self.datalab.get_info("statistics").get("weighted_knn_graph", None) + + knn_graph: Optional[csr_matrix] = None + if knn_graph_kwargs is not None: + knn_graph = knn_graph_kwargs + elif knn_graph_stats is not None: + knn_graph = knn_graph_stats + + if isinstance(knn_graph, csr_matrix) and kwargs.get("k", 0) > ( + knn_graph.nnz // knn_graph.shape[0] + ): + # If the provided knn graph is insufficient, then we need to recompute the knn graph + # with the provided features + knn_graph = None + return knn_graph + + def collect_info(self, knn_graph: csr_matrix) -> dict: + issues_dict = { + "average_near_duplicate_score": self.issues[self.issue_score_key].mean(), + "near_duplicate_sets": self.near_duplicate_sets, + } + + params_dict = { + "metric": self.metric, + "k": self.k, + "threshold": self.threshold, + } + + N = knn_graph.shape[0] + dists = knn_graph.data.reshape(N, -1)[:, 0] + nn_ids = knn_graph.indices.reshape(N, -1)[:, 0] + + knn_info_dict = { + "nearest_neighbor": nn_ids.tolist(), + "distance_to_nearest_neighbor": dists.tolist(), + } + + statistics_dict = self._build_statistics_dictionary(knn_graph=knn_graph) + + info_dict = { + **issues_dict, + **params_dict, + **knn_info_dict, + **statistics_dict, + } + return info_dict + + def _build_statistics_dictionary(self, knn_graph: csr_matrix) -> Dict[str, Dict[str, Any]]: + statistics_dict: Dict[str, Dict[str, Any]] = {"statistics": {}} + + # Add the knn graph as a statistic if necessary + graph_key = "weighted_knn_graph" + old_knn_graph = self.datalab.get_info("statistics").get(graph_key, None) + old_graph_exists = old_knn_graph is not None + prefer_new_graph = ( + not old_graph_exists + or knn_graph.nnz > old_knn_graph.nnz + or self.metric != self.datalab.get_info("statistics").get("knn_metric", None) + ) + if prefer_new_graph: + statistics_dict["statistics"][graph_key] = knn_graph + if self.metric is not None: + statistics_dict["statistics"]["knn_metric"] = self.metric + + return statistics_dict + + def _set_threshold( + self, + threshold: float, + ) -> float: + """Computes nearest-neighbors thresholding for near-duplicate detection.""" + if threshold < 0: + warnings.warn( + f"Computed threshold {threshold} is less than 0. " + "Setting threshold to 0." + "This may indicate that either the only a few examples are in the dataset, " + "or the data is heavily skewed." + ) + threshold = 0 + return threshold diff --git a/cleanlab/datalab/issue_manager/issue_manager.py b/cleanlab/datalab/issue_manager/issue_manager.py new file mode 100644 index 0000000000..4048090f21 --- /dev/null +++ b/cleanlab/datalab/issue_manager/issue_manager.py @@ -0,0 +1,342 @@ +# Copyright (C) 2017-2023 Cleanlab Inc. +# This file is part of cleanlab. +# +# cleanlab is free software: you can redistribute it and/or modify +# it under the terms of the GNU Affero General Public License as published +# by the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# cleanlab is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU Affero General Public License for more details. +# +# You should have received a copy of the GNU Affero General Public License +# along with cleanlab. If not, see . +from __future__ import annotations + +from abc import ABC, ABCMeta, abstractmethod +from itertools import chain +from typing import TYPE_CHECKING, Any, ClassVar, Dict, List, Optional, Set, Tuple, Type, TypeVar +import json + +import numpy as np +import pandas as pd + +if TYPE_CHECKING: # pragma: no cover + from cleanlab.datalab.datalab import Datalab + + +T = TypeVar("T", bound="IssueManager") +TM = TypeVar("TM", bound="IssueManagerMeta") + + +class IssueManagerMeta(ABCMeta): + """Metaclass for IssueManager that adds issue_score_key to the class. + + :meta private: + """ + + issue_name: ClassVar[str] + issue_score_key: ClassVar[str] + verbosity_levels: ClassVar[Dict[int, List[str]]] = { + 0: [], + 1: [], + 2: [], + 3: [], + } + + def __new__( + meta: Type[TM], + name: str, + bases: Tuple[Type[Any], ...], + class_dict: Dict[str, Any], + ) -> TM: # Classes that inherit from ABC don't need to be modified + if ABC in bases: + return super().__new__(meta, name, bases, class_dict) + + # Ensure that the verbosity levels don't have keys other than those in ["issue", "info"] + verbosity_levels = class_dict.get("verbosity_levels", meta.verbosity_levels) + for level, level_list in verbosity_levels.items(): + if not isinstance(level_list, list): + raise ValueError( + f"Verbosity levels must be lists. " + f"Got {level_list} in {name}.verbosity_levels" + ) + prohibited_keys = [key for key in level_list if not isinstance(key, str)] + if prohibited_keys: + raise ValueError( + f"Verbosity levels must be lists of strings. " + f"Got {prohibited_keys} in {name}.verbosity_levels[{level}]" + ) + + # Concrete classes need to have an issue_name attribute + if "issue_name" not in class_dict: + raise TypeError("IssueManagers need an issue_name class variable") + + # Add issue_score_key to class + class_dict["issue_score_key"] = f"{class_dict['issue_name']}_score" + return super().__new__(meta, name, bases, class_dict) + + +class IssueManager(ABC, metaclass=IssueManagerMeta): + """Base class for managing data issues of a particular type in a Datalab. + + For each example in a dataset, the IssueManager for a particular type of issue should compute: + - A numeric severity score between 0 and 1, + with values near 0 indicating severe instances of the issue. + - A boolean `is_issue` value, which is True + if we believe this example suffers from the issue in question. + `is_issue` may be determined by thresholding the severity score + (with an a priori determined reasonable threshold value), + or via some other means (e.g. Confident Learning for flagging label issues). + + The IssueManager should also report: + - A global value between 0 and 1 summarizing how severe this issue is in the dataset overall + (e.g. the average severity across all examples in dataset + or count of examples where `is_issue=True`). + - Other interesting `info` about the issue and examples in the dataset, + and statistics estimated from current dataset that may be reused + to score this issue in future data. + For example, `info` for label issues could contain the: + confident_thresholds, confident_joint, predicted label for each example, etc. + Another example is for (near)-duplicate detection issue, where `info` could contain: + which set of examples in the dataset are all (nearly) identical. + + Implementing a new IssueManager: + - Define the `issue_name` class attribute, e.g. "label", "duplicate", "outlier", etc. + - Implement the abstract methods `find_issues` and `collect_info`. + - `find_issues` is responsible for computing computing the `issues` and `summary` dataframes. + - `collect_info` is responsible for computing the `info` dict. It is called by `find_issues`, + once the manager has set the `issues` and `summary` dataframes as instance attributes. + """ + + description: ClassVar[str] = "" + """Short text that summarizes the type of issues handled by this IssueManager. + + :meta hide-value: + """ + issue_name: ClassVar[str] + """Returns a key that is used to store issue summary results about the assigned Lab.""" + issue_score_key: ClassVar[str] + """Returns a key that is used to store issue score results about the assigned Lab.""" + verbosity_levels: ClassVar[Dict[int, List[str]]] = { + 0: [], + 1: [], + 2: [], + 3: [], + } + """A dictionary of verbosity levels and their corresponding dictionaries of + report items to print. + + :meta hide-value: + + Example + ------- + + >>> verbosity_levels = { + ... 0: [], + ... 1: ["some_info_key"], + ... 2: ["additional_info_key"], + ... } + """ + + def __init__(self, datalab: Datalab, **_): + self.datalab = datalab + self.info: Dict[str, Any] = {} + self.issues: pd.DataFrame = pd.DataFrame() + self.summary: pd.DataFrame = pd.DataFrame() + + def __repr__(self): + class_name = self.__class__.__name__ + return class_name + + @classmethod + def __init_subclass__(cls): + required_class_variables = [ + "issue_name", + ] + for var in required_class_variables: + if not hasattr(cls, var): + raise NotImplementedError(f"Class {cls.__name__} must define class variable {var}") + + @abstractmethod + def find_issues(self, *args, **kwargs) -> None: + """Finds occurrences of this particular issue in the dataset. + + Computes the `issues` and `summary` dataframes. Calls `collect_info` to compute the `info` dict. + """ + raise NotImplementedError + + def collect_info(self, *args, **kwargs) -> dict: + """Collects data for the info attribute of the Datalab. + + NOTE + ---- + This method is called by :py:meth:`find_issues` after :py:meth:`find_issues` has set the `issues` and `summary` dataframes + as instance attributes. + """ + raise NotImplementedError + + @classmethod + def make_summary(cls, score: float) -> pd.DataFrame: + """Construct a summary dataframe. + + Parameters + ---------- + score : + The overall score for this issue. + + Returns + ------- + summary : + A summary dataframe. + """ + return pd.DataFrame( + { + "issue_type": [cls.issue_name], + "score": [score], + }, + ) + + @classmethod + def report( + cls, + issues: pd.DataFrame, + summary: pd.DataFrame, + info: Dict[str, Any], + num_examples: int = 5, + verbosity: int = 0, + include_description: bool = False, + info_to_omit: Optional[List[str]] = None, + ) -> str: + """Compose a report of the issues found by this IssueManager. + + Parameters + ---------- + issues : + An issues dataframe. + + Example + ------- + >>> import pandas as pd + >>> issues = pd.DataFrame( + ... { + ... "is_X_issue": [True, False, True], + ... "X_score": [0.2, 0.9, 0.4], + ... }, + ... ) + + summary : + The summary dataframe. + + Example + ------- + >>> summary = pd.DataFrame( + ... { + ... "issue_type": ["X"], + ... "score": [0.5], + ... }, + ... ) + + info : + The info dict. + + Example + ------- + >>> info = { + ... "A": "val_A", + ... "B": ["val_B1", "val_B2"], + ... } + + num_examples : + The number of examples to print. + + verbosity : + The verbosity level of the report. + + include_description : + Whether to include a description of the issue in the report. + + Returns + ------- + report_str : + A string containing the report. + """ + + max_verbosity = max(cls.verbosity_levels.keys()) + top_level = max_verbosity + 1 + if verbosity not in list(cls.verbosity_levels.keys()) + [top_level]: + raise ValueError( + f"Verbosity level {verbosity} not supported. " + f"Supported levels: {cls.verbosity_levels.keys()}" + f"Use verbosity={top_level} to print all info." + ) + if issues.empty: + print(f"No issues found") + + topk_ids = issues.sort_values(by=cls.issue_score_key, ascending=True).index[:num_examples] + + score = summary["score"].loc[0] + report_str = f"{' ' + cls.issue_name + ' issues ':-^60}\n\n" + + if include_description and cls.description: + description = cls.description + if verbosity == 0: + description = description.split("\n\n", maxsplit=1)[0] + report_str += "About this issue:\n\t" + description + "\n\n" + report_str += ( + f"Number of examples with this issue: {issues[f'is_{cls.issue_name}_issue'].sum()}\n" + f"Overall dataset quality in terms of this issue: : {score:.4f}\n\n" + ) + + info_to_print: Set[str] = set() + _info_to_omit = set(issues.columns).union(info_to_omit or []) + verbosity_levels_values = chain.from_iterable( + list(cls.verbosity_levels.values())[: verbosity + 1] + ) + info_to_print.update(set(verbosity_levels_values) - _info_to_omit) + if verbosity == top_level: + info_to_print.update(set(info.keys()) - _info_to_omit) + + report_str += "Examples representing most severe instances of this issue:\n" + report_str += issues.loc[topk_ids].to_string() + + def truncate(s, max_len=4) -> str: + if hasattr(s, "shape") or hasattr(s, "ndim"): + s = np.array(s) + if s.ndim > 1: + description = f"array of shape {s.shape}\n" + with np.printoptions(threshold=max_len): + if s.ndim == 2: + description += f"{s}" + if s.ndim > 2: + description += f"{s}" + return description + s = s.tolist() + + if isinstance(s, list): + if all([isinstance(s_, list) for s_ in s]): + return truncate(np.array(s, dtype=object), max_len=max_len) + if len(s) > max_len: + s = s[:max_len] + ["..."] + return str(s) + + if info_to_print: + info_to_print_dict = {key: info[key] for key in info_to_print} + # Print the info dict, truncating arrays to 4 elements, + report_str += f"\n\nAdditional Information: " + for key, value in info_to_print_dict.items(): + if key == "statistics": + continue + if isinstance(value, dict): + report_str += f"\n{key}:\n{json.dumps(value, indent=4)}" + elif isinstance(value, pd.DataFrame): + max_rows = 5 + df_str = value.head(max_rows).to_string() + if len(value) > max_rows: + df_str += f"\n... (total {len(value)} rows)" + report_str += f"\n{key}:\n{df_str}" + else: + report_str += f"\n{key}: {truncate(value)}" + return report_str diff --git a/cleanlab/datalab/issue_manager/label.py b/cleanlab/datalab/issue_manager/label.py new file mode 100644 index 0000000000..e6783f48f5 --- /dev/null +++ b/cleanlab/datalab/issue_manager/label.py @@ -0,0 +1,226 @@ +# Copyright (C) 2017-2023 Cleanlab Inc. +# This file is part of cleanlab. +# +# cleanlab is free software: you can redistribute it and/or modify +# it under the terms of the GNU Affero General Public License as published +# by the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# cleanlab is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU Affero General Public License for more details. +# +# You should have received a copy of the GNU Affero General Public License +# along with cleanlab. If not, see . +from __future__ import annotations + +from typing import TYPE_CHECKING, Any, ClassVar, Dict, Optional + +import numpy as np + +from cleanlab.classification import CleanLearning +from cleanlab.datalab.issue_manager import IssueManager +from cleanlab.internal.validation import assert_valid_inputs + +if TYPE_CHECKING: # pragma: no cover + import pandas as pd + + from cleanlab.datalab.datalab import Datalab + + +class LabelIssueManager(IssueManager): + """Manages label issues in a Datalab. + + Parameters + ---------- + datalab : + A Datalab instance. + + clean_learning_kwargs : + Keyword arguments to pass to the :py:meth:`CleanLearning ` constructor. + + health_summary_parameters : + Keyword arguments to pass to the :py:meth:`health_summary ` function. + """ + + description: ClassVar[ + str + ] = """Examples whose given label is estimated to be potentially incorrect + (e.g. due to annotation error) are flagged as having label issues. + """ + + issue_name: ClassVar[str] = "label" + verbosity_levels = { + 0: [], + 1: [], + 2: [], + 3: ["classes_by_label_quality", "overlapping_classes"], + } + + def __init__( + self, + datalab: Datalab, + clean_learning_kwargs: Optional[Dict[str, Any]] = None, + health_summary_parameters: Optional[Dict[str, Any]] = None, + **_, + ): + super().__init__(datalab) + self.cl = CleanLearning(**(clean_learning_kwargs or {})) + self.health_summary_parameters: Dict[str, Any] = health_summary_parameters or {} + self._reset() + + @staticmethod + def _process_find_label_issues_kwargs(kwargs: Dict[str, Any]) -> Dict[str, Any]: + """Searches for keyword arguments that are meant for the + CleanLearning.find_label_issues method call + + Examples + -------- + >>> from cleanlab.datalab.issue_manager.label import LabelIssueManager + >>> LabelIssueManager._process_clean_learning_kwargs(thresholds=[0.1, 0.9]) + {'thresholds': [0.1, 0.9]} + """ + accepted_kwargs = [ + "thresholds", + "noise_matrix", + "inverse_noise_matrix", + "save_space", + "clf_kwargs", + "validation_func", + ] + return {k: v for k, v in kwargs.items() if k in accepted_kwargs and v is not None} + + def _reset(self) -> None: + """Reset the attributes of this manager based on the available datalab info + and the keyword arguments stored as instance attributes. + + This allows the builder to use pre-computed info from the datalab to speed up + some computations in the :py:meth:`find_issues` method. + """ + if not self.health_summary_parameters: + statistics_dict = self.datalab.get_info("statistics") + self.health_summary_parameters = { + "labels": self.datalab._labels, + "asymmetric": statistics_dict.get("asymmetric", None), + "class_names": list(self.datalab._label_map.values()), + "num_examples": statistics_dict.get("num_examples"), + "joint": statistics_dict.get("joint", None), + "confident_joint": statistics_dict.get("confident_joint", None), + "multi_label": statistics_dict.get("multi_label", None), + "verbose": False, + } + self.health_summary_parameters = { + k: v for k, v in self.health_summary_parameters.items() if v is not None + } + + def find_issues( + self, + pred_probs: np.ndarray, + health_summary_kwargs: Optional[Dict[str, Any]] = None, + **kwargs, + ) -> None: + self.health_summary_parameters.update({"pred_probs": pred_probs}) + # Find examples with label issues + self.issues = self.cl.find_label_issues( + labels=self.datalab._labels, + pred_probs=pred_probs, + **self._process_find_label_issues_kwargs(kwargs), + ) + self.issues.rename(columns={"label_quality": self.issue_score_key}, inplace=True) + + summary_dict = self.get_health_summary( + pred_probs=pred_probs, **(health_summary_kwargs or {}) + ) + + # Get a summarized dataframe of the label issues + self.summary = self.make_summary(score=summary_dict["overall_label_health_score"]) + + # Collect info about the label issues + self.info = self.collect_info(issues=self.issues, summary_dict=summary_dict) + + # Drop columns from issues that are in the info + self.issues = self.issues.drop(columns=["given_label", "predicted_label"]) + + def get_health_summary(self, pred_probs, **kwargs) -> dict: + """Returns a short summary of the health of this Lab.""" + from cleanlab.dataset import health_summary + + # Validate input + self._validate_pred_probs(pred_probs) + + summary_kwargs = self._get_summary_parameters(pred_probs, **kwargs) + summary = health_summary(**summary_kwargs) + return summary + + def _get_summary_parameters(self, pred_probs, **kwargs) -> Dict["str", Any]: + """Collects a set of input parameters for the health summary function based on + any info available in the datalab. + + Parameters + ---------- + pred_probs : + The predicted probabilities for each example. + + kwargs : + Keyword arguments to pass to the health summary function. + + Returns + ------- + summary_parameters : + A dictionary of parameters to pass to the health summary function. + """ + if "confident_joint" in self.health_summary_parameters: + summary_parameters = { + "confident_joint": self.health_summary_parameters["confident_joint"] + } + elif all([x in self.health_summary_parameters for x in ["joint", "num_examples"]]): + summary_parameters = { + k: self.health_summary_parameters[k] for k in ["joint", "num_examples"] + } + else: + summary_parameters = { + "pred_probs": pred_probs, + "labels": self.datalab._labels, + } + + summary_parameters["class_names"] = self.health_summary_parameters["class_names"] + + for k in ["asymmetric", "verbose"]: + # Start with the health_summary_parameters, then override with kwargs + if k in self.health_summary_parameters: + summary_parameters[k] = self.health_summary_parameters[k] + if k in kwargs: + summary_parameters[k] = kwargs[k] + return summary_parameters + + def collect_info(self, issues: pd.DataFrame, summary_dict: dict) -> dict: + issues_info = { + "num_label_issues": sum(issues[f"is_{self.issue_name}_issue"]), + "average_label_quality": issues[self.issue_score_key].mean(), + "given_label": issues["given_label"].tolist(), + "predicted_label": issues["predicted_label"].tolist(), + } + + health_summary_info = { + "confident_joint": summary_dict["joint"], + "classes_by_label_quality": summary_dict["classes_by_label_quality"], + "overlapping_classes": summary_dict["overlapping_classes"], + } + + cl_info = {} + for k in self.cl.__dict__: + if k not in ["py", "noise_matrix", "inverse_noise_matrix", "confident_joint"]: + continue + cl_info[k] = self.cl.__dict__[k] + + info_dict = { + **issues_info, + **health_summary_info, + **cl_info, + } + + return info_dict + + def _validate_pred_probs(self, pred_probs) -> None: + assert_valid_inputs(X=None, y=self.datalab._labels, pred_probs=pred_probs) diff --git a/cleanlab/datalab/issue_manager/noniid.py b/cleanlab/datalab/issue_manager/noniid.py new file mode 100644 index 0000000000..6185fb32a8 --- /dev/null +++ b/cleanlab/datalab/issue_manager/noniid.py @@ -0,0 +1,425 @@ +from __future__ import annotations + +from typing import TYPE_CHECKING, Any, ClassVar, Dict, Optional, Union, cast +import warnings +import itertools + +from scipy.stats import gaussian_kde +import numpy as np +import pandas as pd +import numpy.typing as npt +from scipy.sparse import csr_matrix +from sklearn.neighbors import NearestNeighbors +from sklearn.utils.validation import check_is_fitted + +from cleanlab.datalab.issue_manager import IssueManager + +if TYPE_CHECKING: # pragma: no cover + from cleanlab.datalab.datalab import Datalab + + +def simplified_kolmogorov_smirnov_test( + neighbor_histogram: npt.NDArray[np.float64], + non_neighbor_histogram: npt.NDArray[np.float64], +) -> float: + """Computes the Kolmogorov-Smirnov statistic between two groups of data. + The statistic is the largest difference between the empirical cumulative + distribution functions (ECDFs) of the two groups. + + Parameters + ---------- + neighbor_histogram : + Histogram data for the nearest neighbor group. + + non_neighbor_histogram : + Histogram data for the non-neighbor group. + + Returns + ------- + statistic : + The KS statistic between the two ECDFs. + + Note + ---- + - Both input arrays should have the same length. + - The input arrays are histograms, which means they contain the count + or frequency of values in each group. The data in the histograms + should be normalized so that they sum to one. + + To calculate the KS statistic, the function first calculates the ECDFs + for both input arrays, which are step functions that show the cumulative + sum of the data up to each point. The function then calculates the + largest absolute difference between the two ECDFs. + """ + + neighbor_cdf = np.cumsum(neighbor_histogram) + non_neighbor_cdf = np.cumsum(non_neighbor_histogram) + + statistic = np.max(np.abs(neighbor_cdf - non_neighbor_cdf)) + return statistic + + +class NonIIDIssueManager(IssueManager): + """Manages issues related to non-iid data distributions. + + Parameters + ---------- + datalab : + The Datalab instance that this issue manager searches for issues in. + + metric : + The distance metric used to compute the KNN graph of the examples in the dataset. + If set to `None`, the metric will be automatically selected based on the dimensionality + of the features used to represent the examples in the dataset. + + k : + The number of nearest neighbors to consider when computing the KNN graph of the examples. + + num_permutations : + The number of trials to run when performing permutation testing to determine whether + the distribution of index-distances between neighbors in the dataset is IID or not. + + """ + + description: ClassVar[ + str + ] = """Whether the dataset exhibits statistically significant + violations of the IID assumption like: + changepoints or shift, drift, autocorrelation, etc. + The specific violation considered is whether the + examples are ordered such that almost adjacent examples + tend to have more similar feature values. + """ + issue_name: ClassVar[str] = "non_iid" + verbosity_levels = { + 0: ["p-value"], + 1: [], + 2: [], + } + + def __init__( + self, + datalab: Datalab, + metric: Optional[str] = None, + k: int = 10, + num_permutations: int = 25, + **_, + ): + super().__init__(datalab) + self.metric = metric + self.k = k + self.num_permutations = num_permutations + self.tests = { + "ks": simplified_kolmogorov_smirnov_test, + } + self.background_distribution = None + + def find_issues(self, features: Optional[npt.NDArray] = None, **kwargs) -> None: + knn_graph = self._process_knn_graph_from_inputs(kwargs) + old_knn_metric = self.datalab.get_info("statistics").get("knn_metric") + metric_changes = self.metric and self.metric != old_knn_metric + + if knn_graph is None or metric_changes: + if features is None: + raise ValueError( + "If a knn_graph is not provided, features must be provided to fit a new knn." + ) + + if self.metric is None: + self.metric = "cosine" if features.shape[1] > 3 else "euclidean" + knn = NearestNeighbors(n_neighbors=self.k, metric=self.metric) + + if self.metric and self.metric != knn.metric: + warnings.warn( + f"Metric {self.metric} does not match metric {knn.metric} used to fit knn. " + "Most likely an existing NearestNeighbors object was passed in, but a different " + "metric was specified." + ) + self.metric = knn.metric + + try: + check_is_fitted(knn) + except: + knn.fit(features) + + self.neighbor_index_choices = self._get_neighbors(knn=knn) + else: + self.neighbor_index_choices = self._get_neighbors(knn_graph=knn_graph) + + self.num_neighbors = self.k + + indices = np.arange(self.N) + self.neighbor_index_distances = np.abs(indices.reshape(-1, 1) - self.neighbor_index_choices) + + self.statistics = self._get_statistics(self.neighbor_index_distances) + + self.p_value = self._permutation_test(num_permutations=self.num_permutations) + + scores = self._score_dataset() + score_median_threshold = np.median(scores) * 0.7 + self.issues = pd.DataFrame( + { + f"is_{self.issue_name}_issue": scores < score_median_threshold, + self.issue_score_key: scores, + }, + ) + + self.summary = self.make_summary(score=self.p_value) + + if knn_graph is None: + self.info = self.collect_info(knn=knn) + self.info = self.collect_info(knn_graph=knn_graph, knn=knn) + + def _process_knn_graph_from_inputs(self, kwargs: Dict[str, Any]) -> Union[csr_matrix, None]: + """Determine if a knn_graph is provided in the kwargs or if one is already stored in the associated Datalab instance.""" + knn_graph_kwargs: Optional[csr_matrix] = kwargs.get("knn_graph", None) + knn_graph_stats = self.datalab.get_info("statistics").get("weighted_knn_graph", None) + + knn_graph: Optional[csr_matrix] = None + if knn_graph_kwargs is not None: + knn_graph = knn_graph_kwargs + elif knn_graph_stats is not None: + knn_graph = knn_graph_stats + + need_to_recompute_knn = isinstance(knn_graph, csr_matrix) and ( + kwargs.get("k", 0) > knn_graph.nnz // knn_graph.shape[0] + or self.k > knn_graph.nnz // knn_graph.shape[0] + ) + + if need_to_recompute_knn: + # If the provided knn graph is insufficient, then we need to recompute the knn graph + # with the provided features + knn_graph = None + return knn_graph + + def collect_info( + self, knn_graph: Optional[csr_matrix] = None, knn: Optional[NearestNeighbors] = None + ) -> dict: + issues_dict = { + "p-value": self.p_value, + } + + params_dict = { + "metric": self.metric, + "k": self.k, + } + if knn_graph is None: + assert knn is not None, "If knn_graph is None, knn must be provided." + knn_graph = knn.kneighbors_graph(mode="distance") # type: ignore[union-attr] + + assert knn_graph is not None, "knn_graph must be provided or computed." + statistics_dict = self._build_statistics_dictionary(knn_graph=knn_graph) + + info_dict = { + **issues_dict, + **params_dict, # type: ignore[arg-type] + **statistics_dict, # type: ignore[arg-type] + } + return info_dict + + def _build_statistics_dictionary(self, knn_graph: csr_matrix) -> Dict[str, Dict[str, Any]]: + statistics_dict: Dict[str, Dict[str, Any]] = {"statistics": {}} + + # Add the knn graph as a statistic if necessary + graph_key = "weighted_knn_graph" + old_knn_graph = self.datalab.get_info("statistics").get(graph_key, None) + old_graph_exists = old_knn_graph is not None + prefer_new_graph = ( + (knn_graph is not None and not old_graph_exists) + or knn_graph.nnz > old_knn_graph.nnz + or self.metric != self.datalab.get_info("statistics").get("knn_metric", None) + ) + if prefer_new_graph: + statistics_dict["statistics"][graph_key] = knn_graph + if self.metric is not None: + statistics_dict["statistics"]["knn_metric"] = self.metric + + return statistics_dict + + def _permutation_test(self, num_permutations) -> float: + N = self.N + + perms = np.fromiter( + itertools.chain.from_iterable( + np.random.permutation(N) for i in range(num_permutations) + ), + dtype=int, + ).reshape(num_permutations, N) + + neighbor_index_choices = self.neighbor_index_choices + neighbor_index_choices = neighbor_index_choices.reshape(1, *neighbor_index_choices.shape) + perm_neighbor_choices = perms[:, neighbor_index_choices].reshape( + num_permutations, *neighbor_index_choices.shape[1:] + ) + neighbor_index_distances = np.abs(perms[..., None] - perm_neighbor_choices).reshape( + num_permutations, -1 + ) + + statistics = [] + for neighbor_index_dist in neighbor_index_distances: + stats = self._get_statistics( + neighbor_index_dist, + ) + statistics.append(stats) + + ks_stats = np.array([stats["ks"] for stats in statistics]) + ks_stats_kde = gaussian_kde(ks_stats) + p_value = ks_stats_kde.integrate_box(self.statistics["ks"], 100) + + return p_value + + def _score_dataset(self) -> npt.NDArray[np.float64]: + """This function computes a variant of the KS statistic for each + datapoint. Rather than computing the maximum difference + between the CDF of the neighbor distances (foreground + distribution) and the CDF of the all index distances + (background distribution), we compute the absolute difference + in area-under-the-curve of the two CDFs. + + The foreground distribution is computed by sampling the + neighbor distances from the KNN graph, but the background + distribution is computed analytically. The background CDF for + a datapoint i can be split up into three parts. Let d = min(i, + N - i - 1). + + 1. For 0 < j <= d, the slope of the CDF is 2 / (N - 1) since + there are two datapoints in the dataset that are distance j + from datapoint i. We call this threshold the 'double distance + threshold' + + 2. For d < j <= N - d - 1, the slope of the CDF is + 1 / (N - 1) since there is only one datapoint in the dataset + that is distance j from datapoint i. + + 3. For j > N - d - 1, the slope of the CDF is 0 and is + constant at 1.0 since there are no datapoints in the dataset + that are distance j from datapoint i. + + We compute the area differences on each of the k intervals for + which the foreground CDF is constant which allows for the + possibility that the background CDF may intersect the + foreground CDF on this interval. We do not account for these + cases when computing absolute AUC difference. + + Our algorithm is simple, sort the k sampled neighbor + distances. Then, for each of the k neighbor distances sampled, + compute the AUC for each CDF up to that point. Then, subtract + from each area the previous area in the sorted order to get + the AUC of the CDF on the interval between those two + points. Subtract the background interval AUCs from the + foreground interval AUCs, take the absolute value, and + sum. The algorithm is vectorized such that this statistic is + computed for each of the N datapoints simultaneously. + + The statistics are then normalized by their respective maximum + possible distance (N - d - 1) and then mapped to [0,1] via + tanh. + """ + N = self.N + + sorted_neighbors = np.sort(self.neighbor_index_distances, axis=1) + + # find the maximum distance that occurs with double probability + middle_idx = np.floor((N - 1) / 2).astype(int) + double_distances = np.arange(N).reshape(N, 1) + double_distances[double_distances > middle_idx] -= N - 1 + double_distances = np.abs(double_distances) + + sorted_neighbors = np.hstack([sorted_neighbors, np.ones((N, 1)) * (N - 1)]).astype(int) + + # the set of distances that are less than the double distance threshold + set_beginning = sorted_neighbors <= double_distances + # the set of distances that are greater than the double distance threshold but have nonzero probability + set_middle = (sorted_neighbors > double_distances) & ( + sorted_neighbors <= (N - double_distances - 1) + ) + # the set of distances that occur with 0 probability + set_end = sorted_neighbors > (N - double_distances - 1) + + shifted_neighbors = np.zeros(sorted_neighbors.shape) + shifted_neighbors[:, 1:] = sorted_neighbors[:, :-1] + diffs = sorted_neighbors - shifted_neighbors # the distances between the sorted indices + + area_beginning = (double_distances**2) / (N - 1) + length = N - 2 * double_distances - 1 + a = 2 * double_distances / (N - 1) + area_middle = 0.5 * (a + 1) * length + + # compute the area under the CDF for each of the indices in sorted_neighbors + background_area = np.zeros(diffs.shape) + background_diffs = np.zeros(diffs.shape) + background_area[set_beginning] = ((sorted_neighbors**2) / (N - 1))[set_beginning] + background_area[set_middle] = ( + area_beginning + + 0.5 + * ( + (sorted_neighbors + 3 * double_distances) + * (sorted_neighbors - double_distances) + / (N - 1) + ) + )[set_middle] + background_area[set_end] = ( + area_beginning + area_middle + (sorted_neighbors - (N - double_distances - 1) * 1.0) + )[set_end] + + # compute the area under the CDF between indices in sorted_neighbors + shifted_background = np.zeros(background_area.shape) + shifted_background[:, 1:] = background_area[:, :-1] + background_diffs = background_area - shifted_background + + # compute the foreground CDF and AUC between indices in sorted_neighbors + foreground_cdf = np.arange(sorted_neighbors.shape[1]) / (sorted_neighbors.shape[1] - 1) + foreground_diffs = foreground_cdf.reshape(1, -1) * diffs + + # compute the differences between foreground and background area intervals + area_diffs = np.abs(foreground_diffs - background_diffs) + stats = np.sum(area_diffs, axis=1) + + # normalize scores by the index and transform to [0, 1] + indices = np.arange(N) + reverse = N - indices + normalizer = np.where(indices > reverse, indices, reverse) + + scores = stats / normalizer + scores = np.tanh(-1 * scores) + 1 + return scores + + def _get_neighbors( + self, knn: Optional[NearestNeighbors] = None, knn_graph: Optional[csr_matrix] = None + ) -> np.ndarray: + """ + Given a fitted knn object or a knn graph, returns an (N, k) array in + which j is in A[i] if item i and j are nearest neighbors. + """ + if knn_graph is not None: + N = knn_graph.shape[0] + kneighbors = knn_graph.indices.reshape(N, -1) + elif knn is not None: + _, kneighbors = knn.kneighbors() + N = kneighbors.shape[0] + else: + raise ValueError("Must provide either knn or knn_graph") + self.N = N + return kneighbors + + def _get_statistics( + self, + neighbor_index_distances, + ) -> dict[str, float]: + neighbor_index_distances = neighbor_index_distances.flatten() + sorted_neighbors = np.sort(neighbor_index_distances) + sorted_neighbors = np.hstack([sorted_neighbors, np.ones((1)) * (self.N - 1)]).astype(int) + + if self.background_distribution is None: + self.background_distribution = (self.N - np.arange(1, self.N)) / ( + self.N * (self.N - 1) / 2 + ) + + background_distribution = cast(np.ndarray, self.background_distribution) + background_cdf = np.cumsum(background_distribution) + + foreground_cdf = np.arange(sorted_neighbors.shape[0]) / (sorted_neighbors.shape[0] - 1) + + statistic = np.max(np.abs(foreground_cdf - background_cdf[sorted_neighbors - 1])) + statistics = {"ks": statistic} + return statistics diff --git a/cleanlab/datalab/issue_manager/outlier.py b/cleanlab/datalab/issue_manager/outlier.py new file mode 100644 index 0000000000..9f349b4cf3 --- /dev/null +++ b/cleanlab/datalab/issue_manager/outlier.py @@ -0,0 +1,276 @@ +# Copyright (C) 2017-2023 Cleanlab Inc. +# This file is part of cleanlab. +# +# cleanlab is free software: you can redistribute it and/or modify +# it under the terms of the GNU Affero General Public License as published +# by the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# cleanlab is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU Affero General Public License for more details. +# +# You should have received a copy of the GNU Affero General Public License +# along with cleanlab. If not, see . +from __future__ import annotations + +from typing import TYPE_CHECKING, Any, ClassVar, Dict, Optional, Tuple, Union, cast + +from scipy.sparse import csr_matrix +from scipy.stats import iqr +import numpy as np +import numpy.typing as npt +import pandas as pd + +from cleanlab.datalab.issue_manager import IssueManager +from cleanlab.outlier import OutOfDistribution, transform_distances_to_scores + +if TYPE_CHECKING: # pragma: no cover + from sklearn.neighbors import NearestNeighbors + from cleanlab.datalab.datalab import Datalab + + +class OutlierIssueManager(IssueManager): + """Manages issues related to out-of-distribution examples.""" + + description: ClassVar[ + str + ] = """Examples that are very different from the rest of the dataset + (i.e. potentially out-of-distribution or rare/anomalous instances). + """ + issue_name: ClassVar[str] = "outlier" + verbosity_levels = { + 0: [], + 1: [], + 2: ["average_ood_score"], + 3: [], + } + + DEFAULT_THRESHOLDS = { + "features": 0.37037, + "pred_probs": 0.13, + } + """Default thresholds for outlier detection. + + If outlier detection is performed on the features, an example whose average + distance to their k nearest neighbors is greater than + Q3_avg_dist + (1 / threshold - 1) * IQR_avg_dist is considered an outlier. + + If outlier detection is performed on the predicted probabilities, an example + whose average score is lower than threshold * median_outlier_score is + considered an outlier. + """ + + def __init__( + self, + datalab: Datalab, + threshold: Optional[float] = None, + **kwargs, + ): + super().__init__(datalab) + + ood_kwargs = kwargs.get("ood_kwargs", {}) + + valid_ood_params = OutOfDistribution.DEFAULT_PARAM_DICT.keys() + params = { + key: value + for key, value in ((k, kwargs.get(k, None)) for k in valid_ood_params) + if value is not None + } + + if params: + ood_kwargs["params"] = params + + self.ood: OutOfDistribution = OutOfDistribution(**ood_kwargs) + + self.threshold = threshold + self._embeddings: Optional[np.ndarray] = None + self._metric: str = None # type: ignore + + def find_issues( + self, + features: Optional[npt.NDArray] = None, + pred_probs: Optional[np.ndarray] = None, + **kwargs, + ) -> None: + knn_graph = self._process_knn_graph_from_inputs(kwargs) + distances: Optional[np.ndarray] = None + + if knn_graph is not None: + N = knn_graph.shape[0] + k = knn_graph.nnz // N + t = cast(int, self.ood.params["t"]) + distances = knn_graph.data.reshape(-1, k) + assert isinstance(distances, np.ndarray) + scores = transform_distances_to_scores(distances, k=k, t=t) + elif features is not None: + scores = self._score_with_features(features, **kwargs) + elif pred_probs is not None: + scores = self._score_with_pred_probs(pred_probs, **kwargs) + else: + if kwargs.get("knn_graph", None) is not None: + raise ValueError( + "knn_graph is provided, but not sufficiently large to compute the scores based on the provided hyperparameters." + ) + raise ValueError(f"Either features pred_probs must be provided.") + + if features is not None or knn_graph is not None: + if knn_graph is None: + assert ( + features is not None + ), "features must be provided so that we can compute the knn graph." + knn_graph = self._process_knn_graph_from_features(kwargs) + distances = knn_graph.data.reshape(knn_graph.shape[0], -1) + + assert isinstance(distances, np.ndarray) + ( + self.threshold, + is_issue_column, + ) = self._compute_threshold_and_issue_column_from_distances(distances, self.threshold) + + else: + assert pred_probs is not None + # Threshold based on pred_probs, very small scores are outliers + if self.threshold is None: + self.threshold = self.DEFAULT_THRESHOLDS["pred_probs"] + if not 0 <= self.threshold: + raise ValueError(f"threshold must be non-negative, but got {self.threshold}.") + is_issue_column = scores < self.threshold * np.median(scores) + + self.issues = pd.DataFrame( + { + f"is_{self.issue_name}_issue": is_issue_column, + self.issue_score_key: scores, + }, + ) + + self.summary = self.make_summary(score=scores.mean()) + + self.info = self.collect_info(knn_graph=knn_graph) + + def _process_knn_graph_from_inputs(self, kwargs: Dict[str, Any]) -> Union[csr_matrix, None]: + """Determine if a knn_graph is provided in the kwargs or if one is already stored in the associated Datalab instance.""" + knn_graph_kwargs: Optional[csr_matrix] = kwargs.get("knn_graph", None) + knn_graph_stats = self.datalab.get_info("statistics").get("weighted_knn_graph", None) + + knn_graph: Optional[csr_matrix] = None + if knn_graph_kwargs is not None: + knn_graph = knn_graph_kwargs + elif knn_graph_stats is not None: + knn_graph = knn_graph_stats + + if isinstance(knn_graph, csr_matrix) and kwargs.get("k", 0) > ( + knn_graph.nnz // knn_graph.shape[0] + ): + # If the provided knn graph is insufficient, then we need to recompute the knn graph + # with the provided features + knn_graph = None + return knn_graph + + def _compute_threshold_and_issue_column_from_distances( + self, distances: np.ndarray, threshold: Optional[float] = None + ) -> Tuple[float, np.ndarray]: + avg_distances = distances.mean(axis=1) + if threshold: + if not (isinstance(threshold, (int, float)) and 0 <= threshold <= 1): + raise ValueError( + f"threshold must be a number between 0 and 1, got {threshold} of type {type(threshold)}." + ) + if threshold is None: + threshold = OutlierIssueManager.DEFAULT_THRESHOLDS["features"] + q3_distance = np.percentile(avg_distances, 75) + iqr_scale = 1 / threshold - 1 if threshold != 0 else np.inf + return threshold, avg_distances > q3_distance + iqr_scale * iqr(avg_distances) + + def _process_knn_graph_from_features(self, kwargs: Dict) -> csr_matrix: + # Check if the weighted knn graph exists in info + knn_graph = self.datalab.get_info("statistics").get("weighted_knn_graph", None) + + k: int = 0 # Used to check if the knn graph needs to be recomputed, already set in the knn object + if knn_graph is not None: + k = knn_graph.nnz // knn_graph.shape[0] + + knn: NearestNeighbors = self.ood.params["knn"] # type: ignore + if kwargs.get("knn", None) is not None or knn.n_neighbors > k: # type: ignore[union-attr] + # If the pre-existing knn graph has fewer neighbors than the knn object, + # then we need to recompute the knn graph + assert knn == self.ood.params["knn"] # type: ignore[union-attr] + knn_graph = knn.kneighbors_graph(mode="distance") # type: ignore[union-attr] + self._metric = knn.metric # type: ignore[union-attr] + + return knn_graph + + def collect_info(self, *, knn_graph: Optional[csr_matrix] = None) -> dict: + issues_dict = { + "average_ood_score": self.issues[self.issue_score_key].mean(), + "threshold": self.threshold, + } + pred_probs_issues_dict: Dict[str, Any] = {} + feature_issues_dict = {} + + if knn_graph is not None: + knn = self.ood.params["knn"] # type: ignore + N = knn_graph.shape[0] + k = knn_graph.nnz // N + dists = knn_graph.data.reshape(N, -1)[:, 0] + nn_ids = knn_graph.indices.reshape(N, -1)[:, 0] + + feature_issues_dict.update( + { + "k": k, # type: ignore[union-attr] + "nearest_neighbor": nn_ids.tolist(), + "distance_to_nearest_neighbor": dists.tolist(), + } + ) + if self.ood.params["knn"] is not None: + knn = self.ood.params["knn"] + feature_issues_dict.update({"metric": knn.metric}) # type: ignore[union-attr] + + if self.ood.params["confident_thresholds"] is not None: + pass # + statistics_dict = self._build_statistics_dictionary(knn_graph=knn_graph) + ood_params_dict = self.ood.params + knn_dict = { + **pred_probs_issues_dict, + **feature_issues_dict, + } + info_dict: Dict[str, Any] = { + **issues_dict, + **ood_params_dict, # type: ignore[arg-type] + **knn_dict, + **statistics_dict, + } + return info_dict + + def _build_statistics_dictionary( + self, *, knn_graph: Optional[csr_matrix] + ) -> Dict[str, Dict[str, Any]]: + statistics_dict: Dict[str, Dict[str, Any]] = {"statistics": {}} + + # Add the knn graph as a statistic if necessary + graph_key = "weighted_knn_graph" + old_knn_graph = self.datalab.get_info("statistics").get(graph_key, None) + old_graph_exists = old_knn_graph is not None + prefer_new_graph = ( + not old_graph_exists + or (isinstance(knn_graph, csr_matrix) and knn_graph.nnz > old_knn_graph.nnz) + or self._metric != self.datalab.get_info("statistics").get("knn_metric", None) + ) + if prefer_new_graph: + if knn_graph is not None: + statistics_dict["statistics"][graph_key] = knn_graph + if self._metric is not None: + statistics_dict["statistics"]["knn_metric"] = self._metric + + return statistics_dict + + def _score_with_pred_probs(self, pred_probs: np.ndarray, **kwargs) -> np.ndarray: + # Remove "threshold" from kwargs if it exists + kwargs.pop("threshold", None) + scores = self.ood.fit_score(pred_probs=pred_probs, labels=self.datalab._labels, **kwargs) + return scores + + def _score_with_features(self, features: npt.NDArray, **kwargs) -> npt.NDArray: + scores = self.ood.fit_score(features=features) + return scores diff --git a/cleanlab/datalab/report.py b/cleanlab/datalab/report.py new file mode 100644 index 0000000000..1cbeebc1a9 --- /dev/null +++ b/cleanlab/datalab/report.py @@ -0,0 +1,110 @@ +# Copyright (C) 2017-2023 Cleanlab Inc. +# This file is part of cleanlab. +# +# cleanlab is free software: you can redistribute it and/or modify +# it under the terms of the GNU Affero General Public License as published +# by the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# cleanlab is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU Affero General Public License for more details. +# +# You should have received a copy of the GNU Affero General Public License +# along with cleanlab. If not, see . +""" +Module that handles reporting of all types of issues identified in the data. +""" + +from typing import TYPE_CHECKING + +import pandas as pd + +from cleanlab.datalab.factory import _IssueManagerFactory + + +if TYPE_CHECKING: # pragma: no cover + from cleanlab.datalab.data_issues import DataIssues + + +class Reporter: + """Class that generates a report about the issues stored in a :py:class:`DataIssues` object. + + Parameters + ---------- + data_issues : + The :py:class:`DataIssues` object containing the issues to report on. This is usually + generated by the :py:class:`Datalab` class, stored in the :py:attr:`data_issues` attribute, + and then passed to the :py:class:`Reporter` class to generate a report. + + verbosity : + The default verbosity of the report to generate. Each :py:class`IssueManager` + specifies the available verbosity levels and what additional information + is included at each level. + + include_description : + Whether to include the description of each issue type in the report. The description + is included by default, but can be excluded by setting this parameter to ``False``. + + Note + ---- + This class is not intended to be used directly. Instead, use the + `Datalab.find_issues` method which internally utilizes an IssueFinder instance. + """ + + def __init__( + self, data_issues: "DataIssues", verbosity: int = 1, include_description: bool = True + ): + self.data_issues = data_issues + self.verbosity = verbosity + self.include_description = include_description + + def get_report(self, num_examples: int) -> str: + """Constructs a report about identified issues in the data. + + Parameters + ---------- + num_examples : + The number of examples to include in the report for each issue type. + + + Returns + ------- + report_str : + A string containing the report. + + Examples + -------- + >>> from cleanlab.datalab.report import Reporter + >>> reporter = Reporter(data_issues=data_issues, include_description=False) + >>> report_str = reporter.get_report(num_examples=5) + >>> print(report_str) + """ + report_str = "" + issue_summary = self.data_issues.issue_summary + issue_summary_sorted = issue_summary.sort_values(by="num_issues", ascending=False) + report_str += self._write_summary(summary=issue_summary_sorted) + + issue_reports = [ + _IssueManagerFactory.from_str(issue_type=key).report( + issues=self.data_issues.get_issues(issue_name=key), + summary=self.data_issues.get_summary(issue_name=key), + info=self.data_issues.get_info(issue_name=key), + num_examples=num_examples, + verbosity=self.verbosity, + include_description=self.include_description, + ) + for key in issue_summary_sorted["issue_type"].tolist() + ] + + report_str += "\n\n\n".join(issue_reports) + return report_str + + def _write_summary(self, summary: pd.DataFrame) -> str: + return ( + "Here is a summary of the different kinds of issues found in the data:\n\n" + + summary.to_string(index=False) + + "\n\n" + + "(Note: A lower score indicates a more severe issue across all examples in the dataset.)\n\n\n" + ) diff --git a/cleanlab/datalab/serialize.py b/cleanlab/datalab/serialize.py new file mode 100644 index 0000000000..548661f1a4 --- /dev/null +++ b/cleanlab/datalab/serialize.py @@ -0,0 +1,138 @@ +# Copyright (C) 2017-2023 Cleanlab Inc. +# This file is part of cleanlab. +# +# cleanlab is free software: you can redistribute it and/or modify +# it under the terms of the GNU Affero General Public License as published +# by the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# cleanlab is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU Affero General Public License for more details. +# +# You should have received a copy of the GNU Affero General Public License +# along with cleanlab. If not, see . +from __future__ import annotations + +import os +import pickle +import warnings +from typing import TYPE_CHECKING, Optional + +import pandas as pd + +import cleanlab +from cleanlab.datalab.data import Data + +if TYPE_CHECKING: # pragma: no cover + from datasets.arrow_dataset import Dataset + + from cleanlab.datalab.datalab import Datalab + + +# Constants: +OBJECT_FILENAME = "datalab.pkl" +ISSUES_FILENAME = "issues.csv" +ISSUE_SUMMARY_FILENAME = "summary.csv" +INFO_FILENAME = "info.pkl" +DATA_DIRNAME = "data" + + +class _Serializer: + @staticmethod + def _save_data_issues(path: str, datalab: Datalab) -> None: + """Saves the issues to disk.""" + issues_path = os.path.join(path, ISSUES_FILENAME) + datalab.data_issues.issues.to_csv(issues_path, index=False) + + issue_summary_path = os.path.join(path, ISSUE_SUMMARY_FILENAME) + datalab.data_issues.issue_summary.to_csv(issue_summary_path, index=False) + + @staticmethod + def _save_data(path: str, datalab: Datalab) -> None: + """Saves the dataset to disk.""" + data_path = os.path.join(path, DATA_DIRNAME) + datalab.data.save_to_disk(data_path) + + @staticmethod + def _validate_version(datalab: Datalab) -> None: + current_version = cleanlab.__version__ # type: ignore[attr-defined] + datalab_version = datalab.cleanlab_version + if current_version != datalab_version: + warnings.warn( + f"Saved Datalab was created using different version of cleanlab " + f"({datalab_version}) than current version ({current_version}). " + f"Things may be broken!" + ) + + @classmethod + def serialize(cls, path: str, datalab: Datalab, force: bool) -> None: + """Serializes the datalab object to disk. + + Parameters + ---------- + path : str + Path to save the datalab object to. + + datalab : Datalab + The datalab object to save. + + force : bool + If True, will overwrite existing files at the specified path. + """ + path_exists = os.path.exists(path) + if not path_exists: + os.mkdir(path) + else: + if not force: + raise FileExistsError("Please specify a new path or set force=True") + print(f"WARNING: Existing files will be overwritten by newly saved files at: {path}") + + # Save the datalab object to disk. + with open(os.path.join(path, OBJECT_FILENAME), "wb") as f: + pickle.dump(datalab, f) + + # Save the issues to disk. Use placeholder method for now. + cls._save_data_issues(path=path, datalab=datalab) + + # Save the dataset to disk + cls._save_data(path=path, datalab=datalab) + + @classmethod + def deserialize(cls, path: str, data: Optional[Dataset] = None) -> Datalab: + """Deserializes the datalab object from disk.""" + + if not os.path.exists(path): + raise ValueError(f"No folder found at specified path: {path}") + + with open(os.path.join(path, OBJECT_FILENAME), "rb") as f: + datalab: Datalab = pickle.load(f) + + cls._validate_version(datalab) + + # Load the issues from disk. + issues_path = os.path.join(path, ISSUES_FILENAME) + if not hasattr(datalab.data_issues, "issues") and os.path.exists(issues_path): + datalab.data_issues.issues = pd.read_csv(issues_path) + + issue_summary_path = os.path.join(path, ISSUE_SUMMARY_FILENAME) + if not hasattr(datalab.data_issues, "issue_summary") and os.path.exists(issue_summary_path): + datalab.data_issues.issue_summary = pd.read_csv(issue_summary_path) + + if data is not None: + if hash(data) != hash(datalab._data): + raise ValueError( + "Data has been modified since Lab was saved. " + "Cannot load Lab with modified data." + ) + + if len(data) != len(datalab.labels): + raise ValueError( + f"Length of data ({len(data)}) does not match length of labels ({len(datalab.labels)})" + ) + + datalab._data = Data(data, datalab.label_name) + datalab.data = datalab._data._data + + return datalab diff --git a/docs/requirements.txt b/docs/requirements.txt index f23a4bdec1..3570a8a28c 100644 --- a/docs/requirements.txt +++ b/docs/requirements.txt @@ -16,6 +16,7 @@ requests==2.28.2 tensorflow-datasets==4.5.2 tensorflow==2.9.1 tensorflow-io==0.26.0 +sentence-transformers==2.2.2 speechbrain==0.5.13 huggingface_hub==0.11.1 fasttext-wheel==0.9.2 @@ -24,3 +25,4 @@ skorch==0.12.1 torchvision==0.14.1 torchaudio==0.13.1 timm==0.6.12 +datasets>=2.9.0 diff --git a/docs/source/cleanlab/datalab/data.rst b/docs/source/cleanlab/datalab/data.rst new file mode 100644 index 0000000000..6da27efbc7 --- /dev/null +++ b/docs/source/cleanlab/datalab/data.rst @@ -0,0 +1,9 @@ +data +==== + +.. automodule:: cleanlab.datalab.data + :autosummary: + :members: + :undoc-members: + :show-inheritance: + :ignore-module-all: \ No newline at end of file diff --git a/docs/source/cleanlab/datalab/data_issues.rst b/docs/source/cleanlab/datalab/data_issues.rst new file mode 100644 index 0000000000..d3a578ae2b --- /dev/null +++ b/docs/source/cleanlab/datalab/data_issues.rst @@ -0,0 +1,9 @@ +data_issues +=========== + +.. automodule:: cleanlab.datalab.data_issues + :autosummary: + :members: + :undoc-members: + :show-inheritance: + :ignore-module-all: \ No newline at end of file diff --git a/docs/source/cleanlab/datalab/datalab.rst b/docs/source/cleanlab/datalab/datalab.rst new file mode 100644 index 0000000000..8a38a27f95 --- /dev/null +++ b/docs/source/cleanlab/datalab/datalab.rst @@ -0,0 +1,9 @@ +datalab +======= + +.. automodule:: cleanlab.datalab.datalab + :autosummary: + :members: + :undoc-members: + :show-inheritance: + :ignore-module-all: \ No newline at end of file diff --git a/docs/source/cleanlab/datalab/factory.rst b/docs/source/cleanlab/datalab/factory.rst new file mode 100644 index 0000000000..d65d1eac5d --- /dev/null +++ b/docs/source/cleanlab/datalab/factory.rst @@ -0,0 +1,9 @@ +factory +======= + +.. automodule:: cleanlab.datalab.factory + :autosummary: + :members: + :undoc-members: + :show-inheritance: + :ignore-module-all: \ No newline at end of file diff --git a/docs/source/cleanlab/datalab/guide/custom_issue_manager.rst b/docs/source/cleanlab/datalab/guide/custom_issue_manager.rst new file mode 100644 index 0000000000..d28dccf292 --- /dev/null +++ b/docs/source/cleanlab/datalab/guide/custom_issue_manager.rst @@ -0,0 +1,227 @@ +.. _issue_manager_creating_your_own: + +Creating Your Own Issues Manager +================================ + + + +This guide walks through the process of creating creating your own +:py:class:`IssueManager ` +to detect a custom-defined type of issue alongside the pre-defined issue types in +:py:class:`Datalab `. + +.. seealso:: + + - :py:meth:`register `: + You can either use this function at runtime to register a new issue manager: + + .. code-block:: python + + from cleanlab.datalab.factory import register + register(MyIssueManager) + + or add as a decorator to the class definition: + + .. code-block:: python + + @register + class MyIssueManager(IssueManager): + ... + +Prerequisites +------------- + +As a starting point for this guide, we'll import the necessary things for the next section and create a dummy dataset. + +.. note:: + + .. include:: ../optional_dependencies.rst + +.. code-block:: python + + + import numpy as np + import pandas as pd + from cleanlab import IssueManager + + # Create a dummy dataset + N = 20 + data = pd.DataFrame( + { + "text": [f"example {i}" for i in range(N)], + "label": np.random.randint(0, 2, N), + }, + ) + + +Implementing IssueManagers +-------------------------- + +.. _basic_issue_manager: + +Basic Issue Check +~~~~~~~~~~~~~~~~~ + + +To create a basic issue manager, inherit from the +:py:class:`IssueManager ` class, +assign a name to the class as the class-variable, `issue_name`, and implement the +:py:meth:`find_issues ` method. + +The :py:meth:`find_issues ` +method should mark each example in the dataset as an issue or not with a boolean array. +It should also provide a score for each example in the dataset that quantifies the quality of the example +with regards to the issue. + +.. code-block:: python + + class Basic(IssueManager): + # Assign a name to the issue + issue_name = "basic" + def find_issues(self, **kwargs) -> None: + # Compute scores for each example + scores = np.random.rand(len(self.datalab.data)) + + # Construct a dataframe where examples are marked for issues + # and the score for each example is included. + self.issues = pd.DataFrame( + { + f"is_{self.issue_name}_issue" : scores < 0.1, + self.issue_score_key : scores, + }, + ) + + # Score the dataset as a whole based on this issue type + self.summary = self.get_summary(score = scores.mean()) + + +.. _intermediate_issue_manager: + +Intermediate Issue Check +~~~~~~~~~~~~~~~~~~~~~~~~ + + +To create an intermediate issue: + +- Perform the same steps as in the :ref:`basic issue check ` section. +- Populate the `info` attribute with a dictionary of information about the identified issues. + +The information can be included in a report generated by :py:class:`Datalab `, +if you add any of the keys to the `verbosity_levels` class-attribute. +Optionally, you can also add a description of the type of issue this issue manager handles to the `description` class-attribute. + +.. code-block:: python + + class Intermediate(IssueManager): + issue_name = "intermediate" + # Add a dictionary of information to include in the report + verbosity_levels = { + 0: [], + 1: ["std"], + 2: ["raw_scores"], + } + # Add a description of the issue + description = "Intermediate issues are a bit more involved than basic issues." + def find_issues(self, *, intermediate_arg: int, **kwargs) -> None: + N = len(self.datalab.data) + raw_scores = np.random.rand(N) + std = raw_scores.std() + threshold = min(0, raw_scores.mean() - std) + sin_filter = np.sin(intermediate_arg * np.arange(N) / N) + kernel = sin_filter ** 2 + scores = kernel * raw_scores + self.issues = pd.DataFrame( + { + f"is_{self.issue_name}_issue" : scores < threshold, + self.issue_score_key : scores, + }, + ) + self.summary = self.get_summary(score = scores.mean()) + + # Useful information that will be available in the Datalab instance + self.info = { + "std": std, + "raw_scores": raw_scores, + "kernel": kernel, + } + +Advanced Issue Check +~~~~~~~~~~~~~~~~~~~~ + +.. note:: + + WIP: This section is a work in progress. + + + +Use with Datalab +---------------- + +We can create a +:py:class:`Datalab ` +instance and run issue checks with the custom issue managers we created like so: + + +.. code-block:: python + + from cleanlab.datalab.factory import register + from cleanlab import Datalab + + + # Register the issue manager + for issue_manager in [Basic, Intermediate]: + register(issue_manager) + + # Instantiate a datalab instance + datalab = Datalab(data, label_name="label") + + # Run the issue check + issue_types = {"basic": {}, "intermediate": {"intermediate_arg": 2}} + datalab.find_issues(issue_types=issue_types) + + # Print report + datalab.report(verbosity=0) + + +The report will look something like this: + +.. code-block:: text + + Here is a summary of the different kinds of issues found in the data: + + issue_type score num_issues + basic 0.477762 2 + intermediate 0.286455 0 + + (Note: A lower score indicates a more severe issue across all examples in the dataset.) + + + ------------------------------------------- basic issues ------------------------------------------- + + Number of examples with this issue: 2 + Overall dataset quality in terms of this issue: : 0.4778 + + Examples representing most severe instances of this issue: + is_basic_issue basic_score + 13 True 0.003042 + 8 True 0.058117 + 11 False 0.121908 + 15 False 0.169312 + 17 False 0.229044 + + + --------------------------------------- intermediate issues ---------------------------------------- + + About this issue: + Intermediate issues are a bit more involved than basic issues. + + Number of examples with this issue: 0 + Overall dataset quality in terms of this issue: : 0.2865 + + Examples representing most severe instances of this issue: + is_intermediate_issue intermediate_score kernel + 0 False 0.000000 0.0 + 1 False 0.007059 0.009967 + 3 False 0.010995 0.087332 + 2 False 0.016296 0.03947 + 11 False 0.019459 0.794251 diff --git a/docs/source/cleanlab/datalab/guide/index.rst b/docs/source/cleanlab/datalab/guide/index.rst new file mode 100644 index 0000000000..769b8cc3f7 --- /dev/null +++ b/docs/source/cleanlab/datalab/guide/index.rst @@ -0,0 +1,19 @@ +Datalab guides +============== + +This page contains a list of guides for using Datalab. + +.. note:: + + .. include:: ../optional_dependencies.rst + + +Developer guides +---------------- + +These guides are for developers who want to contribute to Datalab. + +.. toctree:: + :maxdepth: 3 + + custom_issue_manager \ No newline at end of file diff --git a/docs/source/cleanlab/datalab/index.rst b/docs/source/cleanlab/datalab/index.rst new file mode 100644 index 0000000000..9f1b04dfba --- /dev/null +++ b/docs/source/cleanlab/datalab/index.rst @@ -0,0 +1,39 @@ +datalab +======= + +.. warning:: + Methods in this ``datalab`` module are bleeding edge and may have sharp edges. They are not guaranteed to be stable between different ``cleanlab`` versions. + +.. automodule:: cleanlab.datalab + :autosummary: + :members: + :undoc-members: + :show-inheritance: + +Getting Started +--------------- + +.. include:: optional_dependencies.rst + +Guides +------ + +.. toctree:: + :maxdepth: 2 + + guide/index + + +API Reference +------------- + +.. toctree:: + :maxdepth: 2 + + datalab + data + data_issues + issue_finder + factory + issue_manager/index + report diff --git a/docs/source/cleanlab/datalab/issue_finder.rst b/docs/source/cleanlab/datalab/issue_finder.rst new file mode 100644 index 0000000000..d5540dd90b --- /dev/null +++ b/docs/source/cleanlab/datalab/issue_finder.rst @@ -0,0 +1,12 @@ +issue_finder +============ + +.. note:: This module is not intended to be used directly by users. It is used by the :mod:`cleanlab.datalab.datalab` module. + Specifically, it is used by the :py:meth:`Datalab.find_issues ` method. + +.. automodule:: cleanlab.datalab.issue_finder + :autosummary: + :members: + :undoc-members: + :show-inheritance: + :ignore-module-all: \ No newline at end of file diff --git a/docs/source/cleanlab/datalab/issue_manager/duplicate.rst b/docs/source/cleanlab/datalab/issue_manager/duplicate.rst new file mode 100644 index 0000000000..37d6bc8c9b --- /dev/null +++ b/docs/source/cleanlab/datalab/issue_manager/duplicate.rst @@ -0,0 +1,9 @@ +duplicate +========= + + +.. automodule:: cleanlab.datalab.issue_manager.duplicate + :autosummary: + :members: + :undoc-members: + :show-inheritance: diff --git a/docs/source/cleanlab/datalab/issue_manager/index.rst b/docs/source/cleanlab/datalab/issue_manager/index.rst new file mode 100644 index 0000000000..92815b8c9c --- /dev/null +++ b/docs/source/cleanlab/datalab/issue_manager/index.rst @@ -0,0 +1,13 @@ +issue_manager +============= + +.. warning:: + Methods in this ``issue_manager`` module are bleeding edge and may have sharp edges. They are not guaranteed to be stable between different ``cleanlab`` versions. + + +.. toctree:: + Base issue_manager module + label + outlier + duplicate + noniid \ No newline at end of file diff --git a/docs/source/cleanlab/datalab/issue_manager/issue_manager.rst b/docs/source/cleanlab/datalab/issue_manager/issue_manager.rst new file mode 100644 index 0000000000..a0974cf86a --- /dev/null +++ b/docs/source/cleanlab/datalab/issue_manager/issue_manager.rst @@ -0,0 +1,8 @@ +issue_manager +============= + +.. automodule:: cleanlab.datalab.issue_manager.issue_manager + :autosummary: + :members: + :undoc-members: + :show-inheritance: diff --git a/docs/source/cleanlab/datalab/issue_manager/label.rst b/docs/source/cleanlab/datalab/issue_manager/label.rst new file mode 100644 index 0000000000..334bce732f --- /dev/null +++ b/docs/source/cleanlab/datalab/issue_manager/label.rst @@ -0,0 +1,8 @@ +label +===== + +.. automodule:: cleanlab.datalab.issue_manager.label + :autosummary: + :members: + :undoc-members: + :show-inheritance: diff --git a/docs/source/cleanlab/datalab/issue_manager/noniid.rst b/docs/source/cleanlab/datalab/issue_manager/noniid.rst new file mode 100644 index 0000000000..c93df82679 --- /dev/null +++ b/docs/source/cleanlab/datalab/issue_manager/noniid.rst @@ -0,0 +1,9 @@ +noniid +======= + + +.. automodule:: cleanlab.datalab.issue_manager.noniid + :autosummary: + :members: + :undoc-members: + :show-inheritance: diff --git a/docs/source/cleanlab/datalab/issue_manager/outlier.rst b/docs/source/cleanlab/datalab/issue_manager/outlier.rst new file mode 100644 index 0000000000..c2ff3ab62c --- /dev/null +++ b/docs/source/cleanlab/datalab/issue_manager/outlier.rst @@ -0,0 +1,9 @@ +outlier +======= + + +.. automodule:: cleanlab.datalab.issue_manager.outlier + :autosummary: + :members: + :undoc-members: + :show-inheritance: diff --git a/docs/source/cleanlab/datalab/optional_dependencies.rst b/docs/source/cleanlab/datalab/optional_dependencies.rst new file mode 100644 index 0000000000..84378be950 --- /dev/null +++ b/docs/source/cleanlab/datalab/optional_dependencies.rst @@ -0,0 +1,11 @@ +This package has additional dependencies that are not required for the core ``cleanlab`` package. To install them, run: + +.. code-block:: console + + $ pip install cleanlab[datalab] + +For the developmental version of the package, install from source: + +.. code-block:: console + + $ pip install git+https://github.com/cleanlab/cleanlab.git#egg=cleanlab[datalab] \ No newline at end of file diff --git a/docs/source/cleanlab/datalab/report.rst b/docs/source/cleanlab/datalab/report.rst new file mode 100644 index 0000000000..3f5f84d4d6 --- /dev/null +++ b/docs/source/cleanlab/datalab/report.rst @@ -0,0 +1,12 @@ +report +====== + +.. note:: This module is not intended to be used directly by users. It is used by the :mod:`cleanlab.datalab.datalab` module. + Specifically, it is used by the :py:meth:`Datalab.report ` method. + +.. automodule:: cleanlab.datalab.report + :autosummary: + :members: + :undoc-members: + :show-inheritance: + :ignore-module-all: \ No newline at end of file diff --git a/docs/source/index.rst b/docs/source/index.rst index c7546f9563..78ba8aee75 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -126,6 +126,7 @@ Please see our `contributing guidelines Workflows of Data-Centric AI Image Classification (pytorch) Text Classification (tensorflow) @@ -151,8 +152,9 @@ Please see our `contributing guidelines \n", + "Quickstart\n", + "
    \n", + " \n", + "Already have a `model`? Run cross-validation to get out-of-sample `pred_probs`, and then run the code below to audit your dataset and identify any potential issues.\n", + "\n", + "\n", + "
    \n", + " \n", + "```python\n", + "\n", + "from cleanlab import Datalab\n", + "\n", + "lab = Datalab(data=your_dataset, label_name=\"column_name_of_labels\")\n", + "lab.find_issues(pred_probs=your_pred_probs, issue_types={\"label\":{}})\n", + "\n", + "lab.get_issues(\"label\")\n", + " \n", + "```\n", + " \n", + "
    \n", + "
    " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "eqsqBq3PiUHA" + }, + "source": [ + "## 1. Install dependencies and import them\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "i7nT-U9qc8MS" + }, + "source": [ + "You can use `pip` to install all packages required for this tutorial as follows:\n", + "\n", + "```ipython3\n", + "!pip install speechbrain tensorflow sklearn tensorflow_io\n", + "!pip install cleanlab[datalab]\n", + "# Make sure to install the version corresponding to this tutorial\n", + "# E.g. if viewing master branch documentation:\n", + "# !pip install git+https://github.com/cleanlab/cleanlab.git\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "nbsphinx": "hidden" + }, + "outputs": [], + "source": [ + "# Package installation (hidden on docs website).\n", + "# Package versions used: tensorflow==2.9.1 speechbrain==0.5.12 tensorflow-io==0.26.0 torch==1.11.0 torchaudio==0.11.0\n", + "\n", + "dependencies = [\"cleanlab\", \"sklearn\", \"speechbrain==0.5.12\", \"tensorflow==2.9.1\", \"tensorflow_io==0.26.0\", \"huggingface_hub==0.7.0\", \"datasets\"]\n", + "\n", + "# Supress outputs that may appear if tensorflow happens to be improperly installed: \n", + "import os \n", + "os.environ[\"TF_CPP_MIN_LOG_LEVEL\"] = \"3\" \n", + "\n", + "if \"google.colab\" in str(get_ipython()): # Check if it's running in Google Colab\n", + " %pip install cleanlab # for colab\n", + " cmd = ' '.join([dep for dep in dependencies if dep != \"cleanlab\"])\n", + " %pip install $cmd\n", + "else:\n", + " missing_dependencies = []\n", + " for dependency in dependencies:\n", + " try:\n", + " __import__(dependency)\n", + " except ImportError:\n", + " missing_dependencies.append(dependency)\n", + "\n", + " if len(missing_dependencies) > 0:\n", + " print(\"Missing required dependencies:\")\n", + " print(*missing_dependencies, sep=\", \")\n", + " print(\"\\nPlease install them before running the rest of this notebook.\") " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "x-oboEbRdhf6" + }, + "source": [ + "Let's import some of the packages needed throughout this tutorial.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "LaEiwXUiVHCS" + }, + "outputs": [], + "source": [ + "import os\n", + "import pandas as pd\n", + "import numpy as np\n", + "import random\n", + "import tensorflow as tf\n", + "import torch\n", + "\n", + "from cleanlab import Datalab\n", + "\n", + "SEED = 456 # ensure reproducibility" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "nbsphinx": "hidden" + }, + "outputs": [], + "source": [ + "# This (optional) cell is hidden from docs.cleanlab.ai \n", + "\n", + "def set_seed(seed=0):\n", + " \"\"\"Ensure reproducibility.\"\"\"\n", + " np.random.seed(seed)\n", + " torch.manual_seed(seed)\n", + " torch.backends.cudnn.deterministic = True\n", + " torch.backends.cudnn.benchmark = False\n", + " torch.cuda.manual_seed_all(seed)\n", + "\n", + "\n", + "set_seed(SEED)\n", + "pd.options.display.max_colwidth = 500\n", + "tf.get_logger().setLevel('FATAL') # suppress more TF logs" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "SOen_sxQidLC" + }, + "source": [ + "## 2. Load the data\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "uHVskN2eeNj6" + }, + "source": [ + "We must first fetch the dataset. To run the below command, you'll need to have `wget` installed; alternatively you can manually navigate to the link in your browser and download from there.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "GRDPEg7-VOQe", + "outputId": "cb886220-e86e-4a77-9f3a-d7844c37c3a6" + }, + "outputs": [], + "source": [ + "%%capture\n", + "\n", + "!wget https://github.com/Jakobovski/free-spoken-digit-dataset/archive/v1.0.9.tar.gz\n", + "!mkdir spoken_digits\n", + "!tar -xf v1.0.9.tar.gz -C spoken_digits" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "tRvNnyB0e_IE" + }, + "source": [ + "The audio data are .wav files in the `recordings/` folder. Note that the label for each audio clip (i.e. digit from 0 to 9) is indicated in the prefix of the file name (e.g. `6_nicolas_32.wav` has the label 6). If instead applying cleanlab to your own dataset, its classes should be represented as integer indices 0, 1, ..., num_classes - 1." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "FDA5sGZwUSur", + "outputId": "0cedc509-63fd-4dc3-d32f-4b537dfe3895" + }, + "outputs": [], + "source": [ + "DATA_PATH = \"spoken_digits/free-spoken-digit-dataset-1.0.9/recordings/\"\n", + "\n", + "# Get list of .wav file names\n", + "# os.listdir order is nondeterministic, so for reproducibility,\n", + "# we sort first and then do a deterministic shuffle\n", + "file_names = sorted(i for i in os.listdir(DATA_PATH) if i.endswith(\".wav\"))\n", + "random.Random(SEED).shuffle(file_names)\n", + "\n", + "file_paths = [os.path.join(DATA_PATH, name) for name in file_names]\n", + "\n", + "# Check out first 3 files\n", + "file_paths[:3]" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Xi2592bVhSab" + }, + "source": [ + "Let's listen to some example audio clips from the dataset. We introduce a `display_example` function to process the .wav file so we can listen to it in this notebook (can skip these details)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "
    See the implementation of `display_example` **(click to expand)**\n", + "\n", + "```python\n", + "# Note: This pulldown content is for docs.cleanlab.ai, if running on local Jupyter or Colab, please ignore it.\n", + "\n", + "import tensorflow_io as tfio\n", + "from pathlib import Path\n", + "from IPython import display\n", + "\n", + "# Utility function for loading audio files and making sure the sample rate is correct.\n", + "@tf.function\n", + "def load_wav_16k_mono(filename):\n", + " \"\"\"Load a WAV file, convert it to a float tensor, resample to 16 kHz single-channel audio.\"\"\"\n", + " file_contents = tf.io.read_file(filename)\n", + " wav, sample_rate = tf.audio.decode_wav(file_contents, desired_channels=1)\n", + " wav = tf.squeeze(wav, axis=-1)\n", + " sample_rate = tf.cast(sample_rate, dtype=tf.int64)\n", + " wav = tfio.audio.resample(wav, rate_in=sample_rate, rate_out=16000)\n", + " return wav\n", + "\n", + "\n", + "def display_example(wav_file_name, audio_rate=16000):\n", + " \"\"\"Allows us to listen to any wav file and displays its given label in the dataset.\"\"\"\n", + " wav_file_example = load_wav_16k_mono(wav_file_name)\n", + " label = Path(wav_file_name).parts[-1].split(\"_\")[0]\n", + " print(f\"Given label for this example: {label}\")\n", + " display.display(display.Audio(wav_file_example, rate=audio_rate))\n", + "```\n", + "\n", + "
    " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "nbsphinx": "hidden" + }, + "outputs": [], + "source": [ + "import tensorflow_io as tfio\n", + "from pathlib import Path\n", + "from IPython import display\n", + "\n", + "# Utility function for loading audio files and making sure the sample rate is correct.\n", + "@tf.function\n", + "def load_wav_16k_mono(filename):\n", + " \"\"\"Load a WAV file, convert it to a float tensor, resample to 16 kHz single-channel audio.\"\"\"\n", + " file_contents = tf.io.read_file(filename)\n", + " wav, sample_rate = tf.audio.decode_wav(file_contents, desired_channels=1)\n", + " wav = tf.squeeze(wav, axis=-1)\n", + " sample_rate = tf.cast(sample_rate, dtype=tf.int64)\n", + " wav = tfio.audio.resample(wav, rate_in=sample_rate, rate_out=16000)\n", + " return wav\n", + "\n", + "\n", + "def display_example(wav_file_name, audio_rate=16000):\n", + " \"\"\"Allows us to listen to any wav file and displays its given label in the dataset.\"\"\"\n", + " wav_file_example = load_wav_16k_mono(wav_file_name)\n", + " label = Path(wav_file_name).parts[-1].split(\"_\")[0]\n", + " print(f\"Given label for this example: {label}\")\n", + " display.display(display.Audio(wav_file_example, rate=audio_rate))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "2bLlDRI6hzon" + }, + "source": [ + "Click the play button below to listen to this example .wav file. Feel free to change the `wav_file_name_example` variable below to listen to other audio clips in the dataset.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 92 + }, + "id": "dLBvUZLlII5w", + "outputId": "c6a4917f-4a82-4a89-9193-415072e45550" + }, + "outputs": [], + "source": [ + "wav_file_name_example = \"spoken_digits/free-spoken-digit-dataset-1.0.9/recordings/7_jackson_43.wav\" # change this to hear other examples\n", + "display_example(wav_file_name_example)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "-QvbZA7yHwkh" + }, + "source": [ + "## 3. Use pre-trained SpeechBrain model to featurize audio\n", + "\n", + "The [SpeechBrain](https://github.com/speechbrain/speechbrain) package offers many Pytorch neural networks that have been pretrained for speech recognition tasks. Here we instantiate an audio feature extractor using SpeechBrain's `EncoderClassifier`. We'll use the \"spkrec-xvect-voxceleb\" network which has been pre-trained on the [VoxCeleb](https://www.robots.ox.ac.uk/~vgg/data/voxceleb/) speech dataset.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "vL9lkiKsHvKr" + }, + "outputs": [], + "source": [ + "%%capture\n", + "\n", + "from speechbrain.pretrained import EncoderClassifier\n", + "\n", + "feature_extractor = EncoderClassifier.from_hparams(\n", + " \"speechbrain/spkrec-xvect-voxceleb\",\n", + " # run_opts={\"device\":\"cuda\"} # Uncomment this to run on GPU if you have one (optional)\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "vXlE6IK4ibcr" + }, + "source": [ + "Next, we run the audio clips through the pre-trained model to extract vector features (aka embeddings).\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 143 + }, + "id": "obQYDKdLiUU6", + "outputId": "4e923d5c-2cf4-4a5c-827b-0a4fea9d87e4" + }, + "outputs": [], + "source": [ + "# Create dataframe with .wav file names\n", + "df = pd.DataFrame(file_paths, columns=[\"wav_audio_file_path\"])\n", + "df[\"label\"] = df.wav_audio_file_path.map(lambda x: int(Path(x).parts[-1].split(\"_\")[0]))\n", + "df.head(3)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "I8JqhOZgi94g" + }, + "outputs": [], + "source": [ + "import torchaudio\n", + "\n", + "def extract_audio_embeddings(model, wav_audio_file_path: str) -> tuple:\n", + " \"\"\"Feature extractor that embeds audio into a vector.\"\"\"\n", + " signal, fs = torchaudio.load(wav_audio_file_path) # Reformat audio signal into a tensor\n", + " embeddings = model.encode_batch(\n", + " signal\n", + " ) # Pass tensor through pretrained neural net and extract representation\n", + " return embeddings" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "2FSQ2GR9R_YA" + }, + "outputs": [], + "source": [ + "# Extract audio embeddings\n", + "embeddings_list = []\n", + "for i, file_name in enumerate(df.wav_audio_file_path): # for each .wav file name\n", + " embeddings = extract_audio_embeddings(feature_extractor, file_name)\n", + " embeddings_list.append(embeddings.cpu().numpy())\n", + "\n", + "embeddings_array = np.squeeze(np.array(embeddings_list))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "dELkcdXgjTn_" + }, + "source": [ + "Now we have our features in a 2D numpy array. Each row in the array corresponds to an audio clip. We're now able to represent each audio clip as a 512-dimensional feature vector!\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "kAkY31IVXyr8", + "outputId": "fd70d8d6-2f11-48d5-ae9c-a8c97d453632" + }, + "outputs": [], + "source": [ + "print(embeddings_array)\n", + "print(\"Shape of array: \", embeddings_array.shape)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "o4RBcaARmfVG" + }, + "source": [ + "## 4. Fit linear model and compute out-of-sample predicted probabilities\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "y9BIVyI9kHa4" + }, + "source": [ + "A typical way to leverage pretrained networks for a particular classification task is to add a linear output layer and fine-tune the network parameters on the new data. However this can be computationally intensive. Alternatively, we can freeze the pretrained weights of the network and only train the output layer without having to rely on GPU(s). Here we do this conveniently by fitting a scikit-learn linear model on top of the extracted network embeddings.\n", + "\n", + "To identify label issues, cleanlab requires a probabilistic prediction from your model for every datapoint that should be considered. However these predictions will be _overfit_ (and thus unreliable) for datapoints the model was previously trained on. cleanlab is intended to only be used with **out-of-sample** predicted probabilities, i.e. on datapoints held-out from the model during the training.\n", + "\n", + "K-fold cross-validation is a straightforward way to produce out-of-sample predicted probabilities for every datapoint in the dataset, by training K copies of our model on different data subsets and using each copy to predict on the subset of data it did not see during training. An additional benefit of cross-validation is that it provides more reliable evaluation of our model than a single training/validation split. We can obtain cross-validated out-of-sample predicted probabilities from any classifier via the [cross_val_predict](https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.cross_val_predict.html) wrapper provided in scikit-learn.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "i_drkY9YOcw4" + }, + "outputs": [], + "source": [ + "from sklearn.linear_model import LogisticRegression\n", + "from sklearn.model_selection import cross_val_predict\n", + "\n", + "model = LogisticRegression(C=0.01, max_iter=1000, tol=1e-1, random_state=SEED)\n", + "\n", + "num_crossval_folds = 5 # can decrease this value to reduce runtime, or increase it to get better results\n", + "pred_probs = cross_val_predict(\n", + " estimator=model, X=embeddings_array, y=df.label.values, cv=num_crossval_folds, method=\"predict_proba\"\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "FW1yI9Ryrfkj" + }, + "source": [ + "For each audio clip, the corresponding predicted probabilities in `pred_probs` are produced by a copy of our `LogisticRegression` model that has never been trained on this audio clip. Hence we call these predictions _out-of-sample_. An additional benefit of cross-validation is that it provides more reliable evaluation of our model than a single training/validation split.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "_b-AQeoXOc7q", + "outputId": "15ae534a-f517-4906-b177-ca91931a8954" + }, + "outputs": [], + "source": [ + "from sklearn.metrics import accuracy_score\n", + "\n", + "predicted_labels = pred_probs.argmax(axis=1)\n", + "cv_accuracy = accuracy_score(df.label.values, predicted_labels)\n", + "print(f\"Cross-validated estimate of accuracy on held-out data: {cv_accuracy}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "SPz8WBwIlxUE" + }, + "source": [ + "## 5. Use cleanlab to find label issues\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "laui-jXMm6qR" + }, + "source": [ + "Based on the given labels, out-of-sample predicted probabilities and features, cleanlab can quickly help us identify label issues in our dataset. For a dataset with N examples from K classes, the labels should be a 1D array of length N and predicted probabilities should be a 2D (N x K) array. \n", + "\n", + "Here, we use cleanlab to find potential label errors in our data. `Datalab` has several ways of loading the data. In this case, we can just pass the DataFrame created above to instantiate the object. We will then pass in the predicted probabilites to the `find_issues()` method so that Datalab can use them to find potential label errors in our data." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "lab = Datalab(df, label_name=\"label\")\n", + "lab.find_issues(pred_probs=pred_probs, issue_types={\"label\":{}})" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can view the results of running Datalab by calling the `report` method:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "lab.report()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We observe from the report that cleanlab has found some label issues in our dataset. Let us investigate these examples further.\n", + "\n", + "We can view the more details about the label quality for each example using the `get_issues` method, specifying `label` as the issue type." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "label_issues = lab.get_issues(\"label\")\n", + "label_issues.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This method returns a dataframe containing a label quality score for each example. These numeric scores lie between 0 and 1, where lower scores indicate examples more likely to be mislabeled. The dataframe also contains a boolean column specifying whether or not each example is identified to have a label issue (indicating it is likely mislabeled).\n", + "\n", + "We can then filter for the examples that have been identified as a label error:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "identified_label_issues = label_issues[label_issues[\"is_label_issue\"] == True]\n", + "lowest_quality_labels = identified_label_issues.sort_values(\"label_score\").index\n", + "\n", + "print(f\"Here are indices of the most likely errors: \\n {lowest_quality_labels.values}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "iI07jQ0BnTgt" + }, + "source": [ + "These examples flagged by cleanlab are those worth inspecting more closely." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 237 + }, + "id": "FQwRHgbclpsO", + "outputId": "fee5c335-c00e-4fcc-f22b-718705e93182" + }, + "outputs": [], + "source": [ + "df.iloc[lowest_quality_labels]" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "PsDmd5WDnZJG" + }, + "source": [ + "Let's listen to some audio clips below of label issues that were identified in this list.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "p9jLn3Lp85rU" + }, + "source": [ + "In this example, the given label is **6** but it sounds like **8**.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 92 + }, + "id": "ff1NFVlDoysO", + "outputId": "8141a036-44c1-4349-c338-880432513e37" + }, + "outputs": [], + "source": [ + "wav_file_name_example = \"spoken_digits/free-spoken-digit-dataset-1.0.9/recordings/6_yweweler_14.wav\"\n", + "display_example(wav_file_name_example)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "HwokyN0bfVsn" + }, + "source": [ + "In the three examples below, the given label is **6** but they sound quite ambiguous.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 92 + }, + "id": "GZgovGkdiaiP", + "outputId": "d76b2ccf-8be2-4f3a-df4c-2c5c99150db7" + }, + "outputs": [], + "source": [ + "wav_file_name_example = \"spoken_digits/free-spoken-digit-dataset-1.0.9/recordings/6_yweweler_36.wav\"\n", + "display_example(wav_file_name_example)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 92 + }, + "id": "lfa2eHbMwG8R", + "outputId": "6627ebe2-d439-4bf5-e2cb-44f6278ae86c" + }, + "outputs": [], + "source": [ + "wav_file_name_example = \"spoken_digits/free-spoken-digit-dataset-1.0.9/recordings/6_yweweler_35.wav\"\n", + "display_example(wav_file_name_example)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "wav_file_name_example = \"spoken_digits/free-spoken-digit-dataset-1.0.9/recordings/6_nicolas_8.wav\"\n", + "display_example(wav_file_name_example)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "-rf8iSngtV83" + }, + "source": [ + "You can see that even widely-used datasets like Spoken Digit contain problematic labels. Never blindly trust your data! You should always check it for potential issues, many of which can be easily identified by cleanlab.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "nbsphinx": "hidden" + }, + "outputs": [], + "source": [ + "# Note: This cell is only for docs.cleanlab.ai, if running on local Jupyter or Colab, please ignore it.\n", + "\n", + "highlighted_indices = [1946, 516, 469, 2132] # verify these examples were found in find_label_issues\n", + "if not all(x in lowest_quality_labels for x in highlighted_indices):\n", + " raise Exception(\"Some highlighted examples are missing from label_issues_indices.\")" + ] + } + ], + "metadata": { + "accelerator": "GPU", + "colab": { + "collapsed_sections": [], + "name": "audio_quickstart_tutorial_deterministic.ipynb", + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.9.13" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/docs/source/tutorials/datalab/datalab_advanced.ipynb b/docs/source/tutorials/datalab/datalab_advanced.ipynb new file mode 100644 index 0000000000..f89244f54d --- /dev/null +++ b/docs/source/tutorials/datalab/datalab_advanced.ipynb @@ -0,0 +1,817 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Datalab: Advanced workflows to audit your data" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "`Datalab` helps you identify various issues in your machine learning datasets that may negatively impact the performance of your machine learning model if not addressed. By default, `Datalab` can help you identify noisy labels, outliers, (near) duplicates, and other types of problems that commonly occur in real-world data.\n", + "\n", + "`Datalab` performs these checks by utilizing the (probabilistic) predictions from *any* ML model that has already been trained or its learned representations of the data. Underneath the hood, this class calls all the appropriate cleanlab methods for your dataset and provided model outputs, in order to best audit the data and alert you of important issues. This makes it easy to apply many functionalities of this library all within a single line of code. \n", + "\n", + "**This tutorial will demonstrate some advanced functionalities of Datalab including:**\n", + "\n", + "- Incremental issue search\n", + "- Specifying nondefault arguments to issue checks\n", + "- Save and load Datalab objects\n", + "- Adding a custom IssueManager\n", + "\n", + "If you are new to `Datalab`, check out this [quickstart tutorial](datalab_quickstart.html) for a 5-min introduction!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "
    \n", + "Quickstart\n", + "
    \n", + " \n", + "Already have (out-of-sample) `pred_probs` from a model trained on an existing set of labels? Maybe you have some `features` as well? Run the code below to examine your dataset for multiple types of issues.\n", + "\n", + "
    \n", + " \n", + "```ipython3 \n", + "from cleanlab import Datalab\n", + "\n", + "lab = Datalab(data=your_dataset, label_name=\"column_name_of_labels\")\n", + "lab.find_issues(features=your_feature_matrix, pred_probs=your_pred_probs)\n", + "\n", + "lab.report()\n", + "```\n", + " \n", + "
    \n", + "
    " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Install and import required dependencies" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "`Datalab` has additional dependencies that are not included in the standard installation of cleanlab.\n", + "\n", + "You can use pip to install all packages required for this tutorial as follows:\n", + "\n", + "```\n", + "!pip install matplotlib \n", + "!pip install cleanlab[datalab]\n", + "\n", + "# Make sure to install the version corresponding to this tutorial\n", + "# E.g. if viewing master branch documentation:\n", + "# !pip install git+https://github.com/cleanlab/cleanlab.git\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "nbsphinx": "hidden" + }, + "outputs": [], + "source": [ + "# Package installation (hidden on docs website).\n", + "dependencies = [\"cleanlab\", \"matplotlib\", \"datasets\"] # TODO: make sure this list is updated\n", + "\n", + "if \"google.colab\" in str(get_ipython()): # Check if it's running in Google Colab\n", + " %pip install cleanlab # for colab\n", + " cmd = ' '.join([dep for dep in dependencies if dep != \"cleanlab\"])\n", + " %pip install $cmd\n", + "else:\n", + " missing_dependencies = []\n", + " for dependency in dependencies:\n", + " try:\n", + " __import__(dependency)\n", + " except ImportError:\n", + " missing_dependencies.append(dependency)\n", + "\n", + " if len(missing_dependencies) > 0:\n", + " print(\"Missing required dependencies:\")\n", + " print(*missing_dependencies, sep=\", \")\n", + " print(\"\\nPlease install them before running the rest of this notebook.\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# TODO: remove cell before merging to master\n", + "# !pip install git+https://github.com/cleanlab/cleanlab.git#egg=cleanlab[datalab]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "from sklearn.linear_model import LogisticRegression\n", + "from sklearn.model_selection import cross_val_predict\n", + "\n", + "from cleanlab import Datalab" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Create and load the data" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We'll load a toy classification dataset for this tutorial. The dataset has two numerical features and a label column with three classes." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "
    See the code for data generation. **(click to expand)**\n", + " \n", + "```ipython3\n", + "# Note: This pulldown content is for docs.cleanlab.ai, if running on local Jupyter or Colab, please ignore it.\n", + "\n", + "from sklearn.model_selection import train_test_split\n", + "from cleanlab.benchmarking.noise_generation import (\n", + " generate_noise_matrix_from_trace,\n", + " generate_noisy_labels,\n", + ")\n", + "\n", + "SEED = 123\n", + "np.random.seed(SEED)\n", + "\n", + "BINS = {\n", + " \"low\": [-np.inf, 3.3],\n", + " \"mid\": [3.3, 6.6],\n", + " \"high\": [6.6, +np.inf],\n", + "}\n", + "\n", + "BINS_MAP = {\n", + " \"low\": 0,\n", + " \"mid\": 1,\n", + " \"high\": 2,\n", + "}\n", + "\n", + "\n", + "def create_data():\n", + "\n", + " X = np.random.rand(250, 2) * 5\n", + " y = np.sum(X, axis=1)\n", + " # Map y to bins based on the BINS dict\n", + " y_bin = np.array([k for y_i in y for k, v in BINS.items() if v[0] <= y_i < v[1]])\n", + " y_bin_idx = np.array([BINS_MAP[k] for k in y_bin])\n", + "\n", + " # Split into train and test\n", + " X_train, X_test, y_train, y_test, y_train_idx, y_test_idx = train_test_split(\n", + " X, y_bin, y_bin_idx, test_size=0.5, random_state=SEED\n", + " )\n", + "\n", + " # Add several (5) out-of-distribution points. Sliding them along the decision boundaries\n", + " # to make them look like they are out-of-frame\n", + " X_out = np.array(\n", + " [\n", + " [-1.5, 3.0],\n", + " [-1.75, 6.5],\n", + " [1.5, 7.2],\n", + " [2.5, -2.0],\n", + " [5.5, 7.0],\n", + " ]\n", + " )\n", + " # Add a near duplicate point to the last outlier, with some tiny noise added\n", + " near_duplicate = X_out[-1:] + np.random.rand(1, 2) * 1e-6\n", + " X_out = np.concatenate([X_out, near_duplicate])\n", + "\n", + " y_out = np.sum(X_out, axis=1)\n", + " y_out_bin = np.array([k for y_i in y_out for k, v in BINS.items() if v[0] <= y_i < v[1]])\n", + " y_out_bin_idx = np.array([BINS_MAP[k] for k in y_out_bin])\n", + "\n", + " # Add to train\n", + " X_train = np.concatenate([X_train, X_out])\n", + " y_train = np.concatenate([y_train, y_out])\n", + " y_train_idx = np.concatenate([y_train_idx, y_out_bin_idx])\n", + "\n", + " # Add an exact duplicate example to the training set\n", + " exact_duplicate_idx = np.random.randint(0, len(X_train))\n", + " X_duplicate = X_train[exact_duplicate_idx, None]\n", + " y_duplicate = y_train[exact_duplicate_idx, None]\n", + " y_duplicate_idx = y_train_idx[exact_duplicate_idx, None]\n", + "\n", + " # Add to train\n", + " X_train = np.concatenate([X_train, X_duplicate])\n", + " y_train = np.concatenate([y_train, y_duplicate])\n", + " y_train_idx = np.concatenate([y_train_idx, y_duplicate_idx])\n", + "\n", + " py = np.bincount(y_train_idx) / float(len(y_train_idx))\n", + " m = len(BINS)\n", + "\n", + " noise_matrix = generate_noise_matrix_from_trace(\n", + " m,\n", + " trace=0.9 * m,\n", + " py=py,\n", + " valid_noise_matrix=True,\n", + " seed=SEED,\n", + " )\n", + "\n", + " noisy_labels_idx = generate_noisy_labels(y_train_idx, noise_matrix)\n", + " noisy_labels = np.array([list(BINS_MAP.keys())[i] for i in noisy_labels_idx])\n", + "\n", + " return X_train, y_train_idx, noisy_labels, noisy_labels_idx, X_out, X_duplicate\n", + "```\n", + "\n", + "
    " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "nbsphinx": "hidden" + }, + "outputs": [], + "source": [ + "from sklearn.model_selection import train_test_split\n", + "from cleanlab.benchmarking.noise_generation import (\n", + " generate_noise_matrix_from_trace,\n", + " generate_noisy_labels,\n", + ")\n", + "\n", + "SEED = 123\n", + "np.random.seed(SEED)\n", + "\n", + "BINS = {\n", + " \"low\": [-np.inf, 3.3],\n", + " \"mid\": [3.3, 6.6],\n", + " \"high\": [6.6, +np.inf],\n", + "}\n", + "\n", + "BINS_MAP = {\n", + " \"low\": 0,\n", + " \"mid\": 1,\n", + " \"high\": 2,\n", + "}\n", + "\n", + "\n", + "def create_data():\n", + "\n", + " X = np.random.rand(250, 2) * 5\n", + " y = np.sum(X, axis=1)\n", + " # Map y to bins based on the BINS dict\n", + " y_bin = np.array([k for y_i in y for k, v in BINS.items() if v[0] <= y_i < v[1]])\n", + " y_bin_idx = np.array([BINS_MAP[k] for k in y_bin])\n", + "\n", + " # Split into train and test\n", + " X_train, X_test, y_train, y_test, y_train_idx, y_test_idx = train_test_split(\n", + " X, y_bin, y_bin_idx, test_size=0.5, random_state=SEED\n", + " )\n", + "\n", + " # Add several (5) out-of-distribution points. Sliding them along the decision boundaries\n", + " # to make them look like they are out-of-frame\n", + " X_out = np.array(\n", + " [\n", + " [-1.5, 3.0],\n", + " [-1.75, 6.5],\n", + " [1.5, 7.2],\n", + " [2.5, -2.0],\n", + " [5.5, 7.0],\n", + " ]\n", + " )\n", + " # Add a near duplicate point to the last outlier, with some tiny noise added\n", + " near_duplicate = X_out[-1:] + np.random.rand(1, 2) * 1e-6\n", + " X_out = np.concatenate([X_out, near_duplicate])\n", + "\n", + " y_out = np.sum(X_out, axis=1)\n", + " y_out_bin = np.array([k for y_i in y_out for k, v in BINS.items() if v[0] <= y_i < v[1]])\n", + " y_out_bin_idx = np.array([BINS_MAP[k] for k in y_out_bin])\n", + "\n", + " # Add to train\n", + " X_train = np.concatenate([X_train, X_out])\n", + " y_train = np.concatenate([y_train, y_out])\n", + " y_train_idx = np.concatenate([y_train_idx, y_out_bin_idx])\n", + "\n", + " # Add an exact duplicate example to the training set\n", + " exact_duplicate_idx = np.random.randint(0, len(X_train))\n", + " X_duplicate = X_train[exact_duplicate_idx, None]\n", + " y_duplicate = y_train[exact_duplicate_idx, None]\n", + " y_duplicate_idx = y_train_idx[exact_duplicate_idx, None]\n", + "\n", + " # Add to train\n", + " X_train = np.concatenate([X_train, X_duplicate])\n", + " y_train = np.concatenate([y_train, y_duplicate])\n", + " y_train_idx = np.concatenate([y_train_idx, y_duplicate_idx])\n", + "\n", + " py = np.bincount(y_train_idx) / float(len(y_train_idx))\n", + " m = len(BINS)\n", + "\n", + " noise_matrix = generate_noise_matrix_from_trace(\n", + " m,\n", + " trace=0.9 * m,\n", + " py=py,\n", + " valid_noise_matrix=True,\n", + " seed=SEED,\n", + " )\n", + "\n", + " noisy_labels_idx = generate_noisy_labels(y_train_idx, noise_matrix)\n", + " noisy_labels = np.array([list(BINS_MAP.keys())[i] for i in noisy_labels_idx])\n", + "\n", + " return X_train, y_train_idx, noisy_labels, noisy_labels_idx, X_out, X_duplicate" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "X_train, y_train_idx, noisy_labels, noisy_labels_idx, X_out, X_duplicate = create_data()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We make a scatter plot of the features, with a color corresponding to the observed labels. Incorrect given labels are highlighted in red if they do not match the true label, outliers highlighted with an a black cross, and duplicates highlighted with a cyan cross." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "
    See the code to visualize the data. **(click to expand)**\n", + " \n", + "```ipython3\n", + "# Note: This pulldown content is for docs.cleanlab.ai, if running on local Jupyter or Colab, please ignore it.\n", + "\n", + "import matplotlib.pyplot as plt\n", + "\n", + "def plot_data(X_train, y_train_idx, noisy_labels_idx, X_out, X_duplicate):\n", + " # Plot data with clean labels and noisy labels, use BINS_MAP for the legend\n", + " fig, ax = plt.subplots(figsize=(8, 6))\n", + " \n", + " low = ax.scatter(X_train[noisy_labels_idx == 0, 0], X_train[noisy_labels_idx == 0, 1], label=\"low\")\n", + " mid = ax.scatter(X_train[noisy_labels_idx == 1, 0], X_train[noisy_labels_idx == 1, 1], label=\"mid\")\n", + " high = ax.scatter(X_train[noisy_labels_idx == 2, 0], X_train[noisy_labels_idx == 2, 1], label=\"high\")\n", + " \n", + " ax.set_title(\"Noisy labels\")\n", + " ax.set_xlabel(r\"$x_1$\")\n", + " ax.set_ylabel(r\"$x_2$\")\n", + "\n", + " # Plot true boundaries (x+y=3.3, x+y=6.6)\n", + " ax.set_xlim(-3.5, 8.5)\n", + " ax.set_ylim(-3.5, 8.5)\n", + " ax.plot([-0.7, 4.0], [4.0, -0.7], color=\"k\", linestyle=\"--\", alpha=0.5)\n", + " ax.plot([-0.7, 7.3], [7.3, -0.7], color=\"k\", linestyle=\"--\", alpha=0.5)\n", + "\n", + " # Draw red circles around the points that are misclassified (i.e. the points that are in the wrong bin)\n", + " for i, (X, y) in enumerate(zip([X_train, X_train], [y_train_idx, noisy_labels_idx])):\n", + " for j, (k, v) in enumerate(BINS_MAP.items()):\n", + " label_err = ax.scatter(\n", + " X[(y == v) & (y != y_train_idx), 0],\n", + " X[(y == v) & (y != y_train_idx), 1],\n", + " s=180,\n", + " marker=\"o\",\n", + " facecolor=\"none\",\n", + " edgecolors=\"red\",\n", + " linewidths=2.5,\n", + " alpha=0.5,\n", + " label=\"Label error\",\n", + " )\n", + "\n", + "\n", + " outlier = ax.scatter(X_out[:, 0], X_out[:, 1], color=\"k\", marker=\"x\", s=100, linewidth=2, label=\"Outlier\")\n", + "\n", + " # Plot the exact duplicate\n", + " dups = ax.scatter(\n", + " X_duplicate[:, 0],\n", + " X_duplicate[:, 1],\n", + " color=\"c\",\n", + " marker=\"x\",\n", + " s=100,\n", + " linewidth=2,\n", + " label=\"Duplicates\",\n", + " )\n", + " \n", + " first_legend = ax.legend(handles=[low, mid, high], loc=[0.785, 0.8], title=\"Given Class Label\", alignment=\"left\", title_fontproperties={\"weight\":\"semibold\"})\n", + " second_legend = ax.legend(handles=[label_err, outlier, dups], loc=[0.785, 0.6], title=\"Type of Issue\", alignment=\"left\", title_fontproperties={\"weight\":\"semibold\"})\n", + " \n", + " ax = plt.gca().add_artist(first_legend)\n", + " ax = plt.gca().add_artist(second_legend)\n", + " plt.tight_layout()\n", + "```\n", + " \n", + "
    " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "nbsphinx": "hidden" + }, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "def plot_data(X_train, y_train_idx, noisy_labels_idx, X_out, X_duplicate):\n", + " # Plot data with clean labels and noisy labels, use BINS_MAP for the legend\n", + " fig, ax = plt.subplots(figsize=(8, 6))\n", + " \n", + " low = ax.scatter(X_train[noisy_labels_idx == 0, 0], X_train[noisy_labels_idx == 0, 1], label=\"low\")\n", + " mid = ax.scatter(X_train[noisy_labels_idx == 1, 0], X_train[noisy_labels_idx == 1, 1], label=\"mid\")\n", + " high = ax.scatter(X_train[noisy_labels_idx == 2, 0], X_train[noisy_labels_idx == 2, 1], label=\"high\")\n", + " \n", + " ax.set_title(\"Noisy labels\")\n", + " ax.set_xlabel(r\"$x_1$\")\n", + " ax.set_ylabel(r\"$x_2$\")\n", + "\n", + " # Plot true boundaries (x+y=3.3, x+y=6.6)\n", + " ax.set_xlim(-3.5, 8.5)\n", + " ax.set_ylim(-3.5, 8.5)\n", + " ax.plot([-0.7, 4.0], [4.0, -0.7], color=\"k\", linestyle=\"--\", alpha=0.5)\n", + " ax.plot([-0.7, 7.3], [7.3, -0.7], color=\"k\", linestyle=\"--\", alpha=0.5)\n", + "\n", + " # Draw red circles around the points that are misclassified (i.e. the points that are in the wrong bin)\n", + " for i, (X, y) in enumerate(zip([X_train, X_train], [y_train_idx, noisy_labels_idx])):\n", + " for j, (k, v) in enumerate(BINS_MAP.items()):\n", + " label_err = ax.scatter(\n", + " X[(y == v) & (y != y_train_idx), 0],\n", + " X[(y == v) & (y != y_train_idx), 1],\n", + " s=180,\n", + " marker=\"o\",\n", + " facecolor=\"none\",\n", + " edgecolors=\"red\",\n", + " linewidths=2.5,\n", + " alpha=0.5,\n", + " label=\"Label error\",\n", + " )\n", + "\n", + "\n", + " outlier = ax.scatter(X_out[:, 0], X_out[:, 1], color=\"k\", marker=\"x\", s=100, linewidth=2, label=\"Outlier\")\n", + "\n", + " # Plot the exact duplicate\n", + " dups = ax.scatter(\n", + " X_duplicate[:, 0],\n", + " X_duplicate[:, 1],\n", + " color=\"c\",\n", + " marker=\"x\",\n", + " s=100,\n", + " linewidth=2,\n", + " label=\"Duplicates\",\n", + " )\n", + " \n", + " first_legend = ax.legend(handles=[low, mid, high], loc=[0.785, 0.8], title=\"Given Class Label\", alignment=\"left\", title_fontproperties={\"weight\":\"semibold\"})\n", + " second_legend = ax.legend(handles=[label_err, outlier, dups], loc=[0.785, 0.6], title=\"Type of Issue\", alignment=\"left\", title_fontproperties={\"weight\":\"semibold\"})\n", + " \n", + " ax = plt.gca().add_artist(first_legend)\n", + " ax = plt.gca().add_artist(second_legend)\n", + " plt.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plot_data(X_train, y_train_idx, noisy_labels_idx, X_out, X_duplicate)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In real-world scenarios, you won't know the true labels or the distribution of the features, so we won't use these in this tutorial, except for evaluation purposes." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Get out-of-sample predicted probabilities from a classifier" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To detect certain types of issues in classification data (e.g. label errors), `Datalab` relies on predicted class probabilities from a trained model. Ideally, the prediction for each example should be out-of-sample (to avoid overfitting), coming from a copy of the model that was not trained on this example. \n", + "\n", + "This tutorial uses a simple logistic regression model \n", + "and the `cross_val_predict()` function from scikit-learn to generate out-of-sample predicted class probabilities for every example in the training set. You can replace this with *any* other classifier model and train it with cross-validation to get out-of-sample predictions." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "model = LogisticRegression()\n", + "pred_probs = cross_val_predict(\n", + " estimator=model, X=X_train, y=noisy_labels, cv=5, method=\"predict_proba\"\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Instantiate Datalab object" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here we instantiate the Datalab object that will be used in the remainder in the tutorial by passing in the data created above.\n", + "\n", + "`Datalab` has several ways of loading the data. In this case, we'll simply wrap the training features and noisy labels in a dictionary so that we can pass it to `Datalab`.\n", + "\n", + "Other supported data formats for `Datalab` include: [HuggingFace Datasets](https://huggingface.co/docs/datasets/index) and [pandas DataFrame](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.html). `Datalab` works across most data modalities (image, text, tabular, audio, etc). It is intended to find issues that commonly occur in datasets for which you have trained a supervised ML model, regardless of the type of data.\n", + "\n", + "Currently, pandas DataFrames that contain categorical columns might cause some issues when instantiating the `Datalab` object, so it is recommended to ensure that your DataFrame does not contain any categorical columns, or use other data formats (eg. python dictionary, HuggingFace Datasets) to pass in your data." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "data = {\"X\": X_train, \"y\": noisy_labels}\n", + "\n", + "lab = Datalab(data, label_name=\"y\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## **Functionality 1**: Incremental issue search " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can call `find_issues` multiple times on a `Datalab` object to detect issues one type at a time.\n", + "\n", + "This is done via the `issue_types` argument which accepts a dictionary of issue types and any corresponding keyword arguments to specify nondefault keyword arguments to use for detecting each type of issues. In this first call, we only want to detect label issues, which are detected solely based on `pred_probs`, hence there is no need for us to pass in `features` here." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "lab.find_issues(pred_probs=pred_probs, issue_types={\"label\": {}}) \n", + "lab.report()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can check for additional types of issues with the same `Datalab`. Here, we would like to detect outliers and near duplicates which both utilize the features of the data.\n", + "\n", + "Notice that this second call to `find_issues()` updates the output of `report()`, we can see the existing label issues detected alongside the new issues." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "lab.find_issues(features=data[\"X\"], issue_types={\"outlier\": {}, \"near_duplicate\": {}})\n", + "lab.report()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## **Functionality 2**: Specifying nondefault arguments" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can also overwrite previously-executed checks for a type of issue. Here we re-run the detection of outliers, but specify that different non-default settings should be used (in this case, the number of neighbors `k` compared against to determine which datapoints are outliers). \n", + "The results from this new detection will replace the original outlier detection results in the updated `Datalab`. You could similarly specify non-default settings for other issue types in the first call to `Datalab.find_issues()`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "lab.find_issues(features=data[\"X\"], issue_types={\"outlier\": {\"k\": 30}})\n", + "lab.report()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can also increase the verbosity of the `report` to see additional information about the data issues and control how many top-ranked examples are shown for each issue." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "lab.report(num_examples=10, verbosity=2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Notice how the number of flagged outlier issues has changed after specfying different settings to use for outlier detection." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## **Functionality 3**: Save and load Datalab objects" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "A `Datalab` can be saved to a folder at a specified path. In a future Python process, this path can be used to load the `Datalab` from file back into memory. Your dataset is not saved as part of this process, so you'll need to save/load it separately to keep working with it." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "path = \"datalab-files\"\n", + "lab.save(path, force=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can load a `Datalab` object we have on file and view the previously detected issues." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "new_lab = Datalab.load(path)\n", + "new_lab.report()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## **Functionality 4**: Adding a custom IssueManager" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "`Datalab` detects pre-defined types of issues for you in one line of code: `find_issues()`. What if you want to check for other custom types of issues along with these pre-defined types, all within the same line of code?\n", + "\n", + "All issue types in `Datalab` are subclasses of cleanlab's `IssueManager` class.\n", + "To register a custom issue type for use with `Datalab`, simply also make it a subclass of `IssueManager`.\n", + "\n", + "The necessary members to implement in the subclass are:\n", + "\n", + "- A class variable called `issue_name` that acts as a unique identifier for the type of issue.\n", + "- An instance method called `find_issues` that:\n", + " - Computes a quality score for each example in the dataset (between 0-1), in terms of how *unlikely* it is to be an issue.\n", + " - Flags each example as an issue or not (may be based on thresholding the quality scores).\n", + " - Combine these in a dataframe that is assigned to an `issues` attribute of the `IssueManager`.\n", + " - Define a summary score for the overall quality of entire dataset, in terms of this type of issue. Set this score as part of the `summary` attribute of the `IssueManager`.\n", + " \n", + "To demonstrate this, we create an arbitrary issue type that checks the divisibility of an example's index in the dataset by 13." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from cleanlab.datalab.issue_manager import IssueManager\n", + "from cleanlab.datalab.factory import register\n", + "\n", + "\n", + "def scoring_function(idx: int, div: int = 13) -> float:\n", + " if idx == 0:\n", + " # Zero excluded from the divisibility check, gets the highest score\n", + " return 1\n", + " rem = idx % div\n", + " inv_scale = idx // div\n", + " if rem == 0:\n", + " return 0.5 * (1 - np.exp(-0.1*(inv_scale-1)))\n", + " else:\n", + " return 1 - 0.49 * (1 - np.exp(-inv_scale**0.5))*rem/div\n", + "\n", + "\n", + "@register # register this issue type for use with Datalab\n", + "class SuperstitionIssueManager(IssueManager):\n", + " \"\"\"A custom issue manager that keeps track of issue indices that\n", + " are divisible by 13.\n", + " \"\"\"\n", + " description: str = \"Examples with indices that are divisible by 13 may be unlucky.\" # Optional\n", + " issue_name: str = \"superstition\"\n", + "\n", + " def find_issues(self, div=13, **_) -> None:\n", + " ids = self.datalab.issues.index.to_series()\n", + " issues_mask = ids.apply(lambda idx: idx % div == 0 and idx != 0)\n", + " scores = ids.apply(lambda idx: scoring_function(idx, div))\n", + " self.issues = pd.DataFrame(\n", + " {\n", + " f\"is_{self.issue_name}_issue\": issues_mask,\n", + " self.issue_score_key: scores,\n", + " },\n", + " )\n", + " summary_score = 1 - sum(issues_mask) / len(issues_mask)\n", + " self.summary = self.make_summary(score = summary_score)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Once registered, this `IssueManager` will perform custom issue checks when `find_issues` is called on a `Datalab` instance.\n", + "\n", + "As our `Datalab` instance here already has results from the outlier and near duplicate checks, we perform the custom issue check separately." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "lab.find_issues(issue_types={\"superstition\": {}})\n", + "lab.report()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.9.13" + }, + "vscode": { + "interpreter": { + "hash": "d4d1e4263499bec80672ea0156c357c1ee493ec2b1c70f0acce89fc37c4a6abe" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/docs/source/tutorials/datalab/datalab_quickstart.ipynb b/docs/source/tutorials/datalab/datalab_quickstart.ipynb new file mode 100644 index 0000000000..da1d62e3eb --- /dev/null +++ b/docs/source/tutorials/datalab/datalab_quickstart.ipynb @@ -0,0 +1,750 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Datalab: A unified audit to detect all kinds of issues in data and labels" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "`Datalab` helps you identify various issues in your machine learning datasets, such as noisy labels, outliers, (near) duplicates, and other types of problems that commonly occur in real-world data that may negatively impact the performance of your machine learning model if not addressed. `Datalab` utilizes *any* ML model you have already trained for your data to diagnose these issues, it only requires access to either: (probabilistic) predictions from your model or its learned representations of the data.\n", + "\n", + "\n", + "**Overview of what we'll do in this tutorial:**\n", + "\n", + "- Compute out-of-sample predicted probabilities for a sample dataset using cross-validation.\n", + "- Use `Datalab` to identify issues such as noisy labels, outliers, (near) duplicates, and other types of problems \n", + "- View the issue summaries and other information about our sample dataset\n", + "\n", + "You can easily replace our demo dataset with your own image/text/tabular/audio/etc dataset, and then run the same code to discover what sort of issues lurk within it!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "
    \n", + "Quickstart\n", + "
    \n", + " \n", + "Already have (out-of-sample) `pred_probs` from a model trained on an existing set of labels? Maybe you have some `features` as well? Run the code below to examine your dataset for multiple types of issues.\n", + "\n", + "
    \n", + " \n", + "```ipython3 \n", + "from cleanlab import Datalab\n", + "\n", + "lab = Datalab(data=your_dataset, label_name=\"column_name_of_labels\")\n", + "lab.find_issues(features=your_feature_matrix, pred_probs=your_pred_probs)\n", + "\n", + "lab.report()\n", + "```\n", + " \n", + "
    \n", + "
    " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1. Install and import required dependencies" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "`Datalab` has additional dependencies that are not included in the standard installation of cleanlab.\n", + "\n", + "You can use pip to install all packages required for this tutorial as follows:\n", + "\n", + "```\n", + "!pip install matplotlib \n", + "!pip install cleanlab[datalab]\n", + "\n", + "# Make sure to install the version corresponding to this tutorial\n", + "# E.g. if viewing master branch documentation:\n", + "# !pip install git+https://github.com/cleanlab/cleanlab.git\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "nbsphinx": "hidden" + }, + "outputs": [], + "source": [ + "# Package installation (hidden on docs website).\n", + "dependencies = [\"cleanlab\", \"matplotlib\", \"datasets\"] # TODO: make sure this list is updated\n", + "\n", + "if \"google.colab\" in str(get_ipython()): # Check if it's running in Google Colab\n", + " %pip install cleanlab # for colab\n", + " cmd = ' '.join([dep for dep in dependencies if dep != \"cleanlab\"])\n", + " %pip install $cmd\n", + "else:\n", + " missing_dependencies = []\n", + " for dependency in dependencies:\n", + " try:\n", + " __import__(dependency)\n", + " except ImportError:\n", + " missing_dependencies.append(dependency)\n", + "\n", + " if len(missing_dependencies) > 0:\n", + " print(\"Missing required dependencies:\")\n", + " print(*missing_dependencies, sep=\", \")\n", + " print(\"\\nPlease install them before running the rest of this notebook.\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# TODO: remove cell before merging to master\n", + "# !pip install git+https://github.com/cleanlab/cleanlab.git#egg=cleanlab[datalab]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "from sklearn.linear_model import LogisticRegression\n", + "from sklearn.model_selection import cross_val_predict\n", + "\n", + "from cleanlab import Datalab" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2. Create and load the data (can skip these details)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We'll load a toy classification dataset for this tutorial. The dataset has two numerical features and a label column with three possible classes. Each example is classified as either: *low*, *mid* or *high*." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "
    See the code for data generation. **(click to expand)**\n", + " \n", + "```ipython3\n", + "# Note: This pulldown content is for docs.cleanlab.ai, if running on local Jupyter or Colab, please ignore it.\n", + "\n", + "from sklearn.model_selection import train_test_split\n", + "from cleanlab.benchmarking.noise_generation import (\n", + " generate_noise_matrix_from_trace,\n", + " generate_noisy_labels,\n", + ")\n", + "\n", + "SEED = 123\n", + "np.random.seed(SEED)\n", + "\n", + "BINS = {\n", + " \"low\": [-np.inf, 3.3],\n", + " \"mid\": [3.3, 6.6],\n", + " \"high\": [6.6, +np.inf],\n", + "}\n", + "\n", + "BINS_MAP = {\n", + " \"low\": 0,\n", + " \"mid\": 1,\n", + " \"high\": 2,\n", + "}\n", + "\n", + "\n", + "def create_data():\n", + "\n", + " X = np.random.rand(250, 2) * 5\n", + " y = np.sum(X, axis=1)\n", + " # Map y to bins based on the BINS dict\n", + " y_bin = np.array([k for y_i in y for k, v in BINS.items() if v[0] <= y_i < v[1]])\n", + " y_bin_idx = np.array([BINS_MAP[k] for k in y_bin])\n", + "\n", + " # Split into train and test\n", + " X_train, X_test, y_train, y_test, y_train_idx, y_test_idx = train_test_split(\n", + " X, y_bin, y_bin_idx, test_size=0.5, random_state=SEED\n", + " )\n", + "\n", + " # Add several (5) out-of-distribution points. Sliding them along the decision boundaries\n", + " # to make them look like they are out-of-frame\n", + " X_out = np.array(\n", + " [\n", + " [-1.5, 3.0],\n", + " [-1.75, 6.5],\n", + " [1.5, 7.2],\n", + " [2.5, -2.0],\n", + " [5.5, 7.0],\n", + " ]\n", + " )\n", + " # Add a near duplicate point to the last outlier, with some tiny noise added\n", + " near_duplicate = X_out[-1:] + np.random.rand(1, 2) * 1e-6\n", + " X_out = np.concatenate([X_out, near_duplicate])\n", + "\n", + " y_out = np.sum(X_out, axis=1)\n", + " y_out_bin = np.array([k for y_i in y_out for k, v in BINS.items() if v[0] <= y_i < v[1]])\n", + " y_out_bin_idx = np.array([BINS_MAP[k] for k in y_out_bin])\n", + "\n", + " # Add to train\n", + " X_train = np.concatenate([X_train, X_out])\n", + " y_train = np.concatenate([y_train, y_out])\n", + " y_train_idx = np.concatenate([y_train_idx, y_out_bin_idx])\n", + "\n", + " # Add an exact duplicate example to the training set\n", + " exact_duplicate_idx = np.random.randint(0, len(X_train))\n", + " X_duplicate = X_train[exact_duplicate_idx, None]\n", + " y_duplicate = y_train[exact_duplicate_idx, None]\n", + " y_duplicate_idx = y_train_idx[exact_duplicate_idx, None]\n", + "\n", + " # Add to train\n", + " X_train = np.concatenate([X_train, X_duplicate])\n", + " y_train = np.concatenate([y_train, y_duplicate])\n", + " y_train_idx = np.concatenate([y_train_idx, y_duplicate_idx])\n", + "\n", + " py = np.bincount(y_train_idx) / float(len(y_train_idx))\n", + " m = len(BINS)\n", + "\n", + " noise_matrix = generate_noise_matrix_from_trace(\n", + " m,\n", + " trace=0.9 * m,\n", + " py=py,\n", + " valid_noise_matrix=True,\n", + " seed=SEED,\n", + " )\n", + "\n", + " noisy_labels_idx = generate_noisy_labels(y_train_idx, noise_matrix)\n", + " noisy_labels = np.array([list(BINS_MAP.keys())[i] for i in noisy_labels_idx])\n", + "\n", + " return X_train, y_train_idx, noisy_labels, noisy_labels_idx, X_out, X_duplicate\n", + "```\n", + "\n", + "
    " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "nbsphinx": "hidden" + }, + "outputs": [], + "source": [ + "from sklearn.model_selection import train_test_split\n", + "from cleanlab.benchmarking.noise_generation import (\n", + " generate_noise_matrix_from_trace,\n", + " generate_noisy_labels,\n", + ")\n", + "\n", + "SEED = 123\n", + "np.random.seed(SEED)\n", + "\n", + "BINS = {\n", + " \"low\": [-np.inf, 3.3],\n", + " \"mid\": [3.3, 6.6],\n", + " \"high\": [6.6, +np.inf],\n", + "}\n", + "\n", + "BINS_MAP = {\n", + " \"low\": 0,\n", + " \"mid\": 1,\n", + " \"high\": 2,\n", + "}\n", + "\n", + "\n", + "def create_data():\n", + "\n", + " X = np.random.rand(250, 2) * 5\n", + " y = np.sum(X, axis=1)\n", + " # Map y to bins based on the BINS dict\n", + " y_bin = np.array([k for y_i in y for k, v in BINS.items() if v[0] <= y_i < v[1]])\n", + " y_bin_idx = np.array([BINS_MAP[k] for k in y_bin])\n", + "\n", + " # Split into train and test\n", + " X_train, X_test, y_train, y_test, y_train_idx, y_test_idx = train_test_split(\n", + " X, y_bin, y_bin_idx, test_size=0.5, random_state=SEED\n", + " )\n", + "\n", + " # Add several (5) out-of-distribution points. Sliding them along the decision boundaries\n", + " # to make them look like they are out-of-frame\n", + " X_out = np.array(\n", + " [\n", + " [-1.5, 3.0],\n", + " [-1.75, 6.5],\n", + " [1.5, 7.2],\n", + " [2.5, -2.0],\n", + " [5.5, 7.0],\n", + " ]\n", + " )\n", + " # Add a near duplicate point to the last outlier, with some tiny noise added\n", + " near_duplicate = X_out[-1:] + np.random.rand(1, 2) * 1e-6\n", + " X_out = np.concatenate([X_out, near_duplicate])\n", + "\n", + " y_out = np.sum(X_out, axis=1)\n", + " y_out_bin = np.array([k for y_i in y_out for k, v in BINS.items() if v[0] <= y_i < v[1]])\n", + " y_out_bin_idx = np.array([BINS_MAP[k] for k in y_out_bin])\n", + "\n", + " # Add to train\n", + " X_train = np.concatenate([X_train, X_out])\n", + " y_train = np.concatenate([y_train, y_out])\n", + " y_train_idx = np.concatenate([y_train_idx, y_out_bin_idx])\n", + "\n", + " # Add an exact duplicate example to the training set\n", + " exact_duplicate_idx = np.random.randint(0, len(X_train))\n", + " X_duplicate = X_train[exact_duplicate_idx, None]\n", + " y_duplicate = y_train[exact_duplicate_idx, None]\n", + " y_duplicate_idx = y_train_idx[exact_duplicate_idx, None]\n", + "\n", + " # Add to train\n", + " X_train = np.concatenate([X_train, X_duplicate])\n", + " y_train = np.concatenate([y_train, y_duplicate])\n", + " y_train_idx = np.concatenate([y_train_idx, y_duplicate_idx])\n", + "\n", + " py = np.bincount(y_train_idx) / float(len(y_train_idx))\n", + " m = len(BINS)\n", + "\n", + " noise_matrix = generate_noise_matrix_from_trace(\n", + " m,\n", + " trace=0.9 * m,\n", + " py=py,\n", + " valid_noise_matrix=True,\n", + " seed=SEED,\n", + " )\n", + "\n", + " noisy_labels_idx = generate_noisy_labels(y_train_idx, noise_matrix)\n", + " noisy_labels = np.array([list(BINS_MAP.keys())[i] for i in noisy_labels_idx])\n", + "\n", + " return X_train, y_train_idx, noisy_labels, noisy_labels_idx, X_out, X_duplicate" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "X_train, y_train_idx, noisy_labels, noisy_labels_idx, X_out, X_duplicate = create_data()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We make a scatter plot of the features, with a color corresponding to the observed labels. Incorrect given labels are highlighted in red if they do not match the true label, outliers highlighted with an a black cross, and duplicates highlighted with a cyan cross." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "
    See the code to visualize the data. **(click to expand)**\n", + " \n", + "```ipython3\n", + "# Note: This pulldown content is for docs.cleanlab.ai, if running on local Jupyter or Colab, please ignore it.\n", + "\n", + "import matplotlib.pyplot as plt\n", + "\n", + "def plot_data(X_train, y_train_idx, noisy_labels_idx, X_out, X_duplicate):\n", + " # Plot data with clean labels and noisy labels, use BINS_MAP for the legend\n", + " fig, ax = plt.subplots(figsize=(8, 6))\n", + " \n", + " low = ax.scatter(X_train[noisy_labels_idx == 0, 0], X_train[noisy_labels_idx == 0, 1], label=\"low\")\n", + " mid = ax.scatter(X_train[noisy_labels_idx == 1, 0], X_train[noisy_labels_idx == 1, 1], label=\"mid\")\n", + " high = ax.scatter(X_train[noisy_labels_idx == 2, 0], X_train[noisy_labels_idx == 2, 1], label=\"high\")\n", + " \n", + " ax.set_title(\"Noisy labels\")\n", + " ax.set_xlabel(r\"$x_1$\")\n", + " ax.set_ylabel(r\"$x_2$\")\n", + "\n", + " # Plot true boundaries (x+y=3.3, x+y=6.6)\n", + " ax.set_xlim(-3.5, 8.5)\n", + " ax.set_ylim(-3.5, 8.5)\n", + " ax.plot([-0.7, 4.0], [4.0, -0.7], color=\"k\", linestyle=\"--\", alpha=0.5)\n", + " ax.plot([-0.7, 7.3], [7.3, -0.7], color=\"k\", linestyle=\"--\", alpha=0.5)\n", + "\n", + " # Draw red circles around the points that are misclassified (i.e. the points that are in the wrong bin)\n", + " for i, (X, y) in enumerate(zip([X_train, X_train], [y_train_idx, noisy_labels_idx])):\n", + " for j, (k, v) in enumerate(BINS_MAP.items()):\n", + " label_err = ax.scatter(\n", + " X[(y == v) & (y != y_train_idx), 0],\n", + " X[(y == v) & (y != y_train_idx), 1],\n", + " s=180,\n", + " marker=\"o\",\n", + " facecolor=\"none\",\n", + " edgecolors=\"red\",\n", + " linewidths=2.5,\n", + " alpha=0.5,\n", + " label=\"Label error\",\n", + " )\n", + "\n", + "\n", + " outlier = ax.scatter(X_out[:, 0], X_out[:, 1], color=\"k\", marker=\"x\", s=100, linewidth=2, label=\"Outlier\")\n", + "\n", + " # Plot the exact duplicate\n", + " dups = ax.scatter(\n", + " X_duplicate[:, 0],\n", + " X_duplicate[:, 1],\n", + " color=\"c\",\n", + " marker=\"x\",\n", + " s=100,\n", + " linewidth=2,\n", + " label=\"Duplicates\",\n", + " )\n", + " \n", + " first_legend = ax.legend(handles=[low, mid, high], loc=[0.785, 0.8], title=\"Given Class Label\", alignment=\"left\", title_fontproperties={\"weight\":\"semibold\"})\n", + " second_legend = ax.legend(handles=[label_err, outlier, dups], loc=[0.785, 0.6], title=\"Type of Issue\", alignment=\"left\", title_fontproperties={\"weight\":\"semibold\"})\n", + " \n", + " ax = plt.gca().add_artist(first_legend)\n", + " ax = plt.gca().add_artist(second_legend)\n", + " plt.tight_layout()\n", + "```\n", + " \n", + "
    " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "nbsphinx": "hidden" + }, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "def plot_data(X_train, y_train_idx, noisy_labels_idx, X_out, X_duplicate):\n", + " # Plot data with clean labels and noisy labels, use BINS_MAP for the legend\n", + " fig, ax = plt.subplots(figsize=(8, 6))\n", + " \n", + " low = ax.scatter(X_train[noisy_labels_idx == 0, 0], X_train[noisy_labels_idx == 0, 1], label=\"low\")\n", + " mid = ax.scatter(X_train[noisy_labels_idx == 1, 0], X_train[noisy_labels_idx == 1, 1], label=\"mid\")\n", + " high = ax.scatter(X_train[noisy_labels_idx == 2, 0], X_train[noisy_labels_idx == 2, 1], label=\"high\")\n", + " \n", + " ax.set_title(\"Noisy labels\")\n", + " ax.set_xlabel(r\"$x_1$\")\n", + " ax.set_ylabel(r\"$x_2$\")\n", + "\n", + " # Plot true boundaries (x+y=3.3, x+y=6.6)\n", + " ax.set_xlim(-3.5, 8.5)\n", + " ax.set_ylim(-3.5, 8.5)\n", + " ax.plot([-0.7, 4.0], [4.0, -0.7], color=\"k\", linestyle=\"--\", alpha=0.5)\n", + " ax.plot([-0.7, 7.3], [7.3, -0.7], color=\"k\", linestyle=\"--\", alpha=0.5)\n", + "\n", + " # Draw red circles around the points that are misclassified (i.e. the points that are in the wrong bin)\n", + " for i, (X, y) in enumerate(zip([X_train, X_train], [y_train_idx, noisy_labels_idx])):\n", + " for j, (k, v) in enumerate(BINS_MAP.items()):\n", + " label_err = ax.scatter(\n", + " X[(y == v) & (y != y_train_idx), 0],\n", + " X[(y == v) & (y != y_train_idx), 1],\n", + " s=180,\n", + " marker=\"o\",\n", + " facecolor=\"none\",\n", + " edgecolors=\"red\",\n", + " linewidths=2.5,\n", + " alpha=0.5,\n", + " label=\"Label error\",\n", + " )\n", + "\n", + "\n", + " outlier = ax.scatter(X_out[:, 0], X_out[:, 1], color=\"k\", marker=\"x\", s=100, linewidth=2, label=\"Outlier\")\n", + "\n", + " # Plot the exact duplicate\n", + " dups = ax.scatter(\n", + " X_duplicate[:, 0],\n", + " X_duplicate[:, 1],\n", + " color=\"c\",\n", + " marker=\"x\",\n", + " s=100,\n", + " linewidth=2,\n", + " label=\"Duplicates\",\n", + " )\n", + " \n", + " first_legend = ax.legend(handles=[low, mid, high], loc=[0.785, 0.8], title=\"Given Class Label\", alignment=\"left\", title_fontproperties={\"weight\":\"semibold\"})\n", + " second_legend = ax.legend(handles=[label_err, outlier, dups], loc=[0.785, 0.6], title=\"Type of Issue\", alignment=\"left\", title_fontproperties={\"weight\":\"semibold\"})\n", + " \n", + " ax = plt.gca().add_artist(first_legend)\n", + " ax = plt.gca().add_artist(second_legend)\n", + " plt.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plot_data(X_train, y_train_idx, noisy_labels_idx, X_out, X_duplicate)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In real-world scenarios, you won't know the true labels or the distribution of the features, so we won't use these in this tutorial, except for evaluation purposes.\n", + "\n", + "\n", + "\n", + "`Datalab` has several ways of loading the data.\n", + "In this case, we'll simply wrap the training features and noisy labels in a dictionary so that we can pass it to `Datalab`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "data = {\"X\": X_train, \"y\": noisy_labels}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Other supported data formats for `Datalab` include: [HuggingFace Datasets](https://huggingface.co/docs/datasets/index) and [pandas DataFrame](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.html). `Datalab` works across most data modalities (image, text, tabular, audio, etc). It is intended to find issues that commonly occur in datasets for which you have trained a supervised ML model, regardless of the type of data.\n", + "\n", + "Currently, pandas DataFrames that contain categorical columns might cause some issues when instantiating the `Datalab` object, so it is recommended to ensure that your DataFrame does not contain any categorical columns, or use other data formats (eg. python dictionary, HuggingFace Datasets) to pass in your data." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3. Get out-of-sample predicted probabilities from a classifier" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To detect certain types of issues in classification data (e.g. label errors), `Datalab` relies on predicted class probabilities from a trained model. Ideally, the prediction for each example should be out-of-sample (to avoid overfitting), coming from a copy of the model that was not trained on this example. \n", + "\n", + "This tutorial uses a simple logistic regression model \n", + "and the `cross_val_predict()` function from scikit-learn to generate out-of-sample predicted class probabilities for every example in the training set. You can replace this with *any* other classifier model and train it with cross-validation to get out-of-sample predictions." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "model = LogisticRegression()\n", + "pred_probs = cross_val_predict(\n", + " estimator=model, X=data[\"X\"], y=data[\"y\"], cv=5, method=\"predict_proba\"\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4. Use Datalab to find issues in the dataset" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We create a `Datalab` object from the dataset, also providing the name of the label column in the dataset. Only instantiate one `Datalab` object per dataset, and note that only classification datasets are supported for now.\n", + "\n", + "All that is need to audit your data is to call `find_issues()`.\n", + "This method accepts various inputs like: predicted class probabilities, numeric feature representations of the data. The more information you provide here, the more thoroughly `Datalab` will audit your data! Note that `features` should be some numeric representation of each example, either obtained through preprocessing transformation of your raw data or embeddings from a (pre)trained model. In this case, our data is already entirely numeric so we just provide the features directly." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "lab = Datalab(data, label_name=\"y\")\n", + "lab.find_issues(pred_probs=pred_probs, features=data[\"X\"])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now let's review the results of this audit using `report()`.\n", + "This provides a high-level summary of each type of issue found in the dataset." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "lab.report()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 5. Learn more about the issues in your dataset" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "There are several methods to get more details about a particular issue.\n", + "\n", + "The `get_summary()` method fetches summary statistics regarding how severe each type of issue is overall across the whole dataset." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "lab.get_summary()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can also only request the summary for a particular type of issue." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "lab.get_summary(\"label\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The `get_issues()` method returns information for each individual example about: whether or not it is plagued by this issue, as well as a quality score for how severe this issue appears to be. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "lab.get_issues().head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Similar to above, we can pass the type of issue as a argument to `get_issues()` to get the information for that particular issue.\n", + "\n", + "Lower scores indicate more severe instances of the issue, so you can sort by these values to see the most concerning examples in your dataset for each type of issue. Here we show an example of how to get the examples that have been identified as having the most severe label issues." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "examples_w_issue = (\n", + " lab.get_issues(\"label\")\n", + " .query(\"is_label_issue\")\n", + " .sort_values(\"label_score\")\n", + ")\n", + "\n", + "examples_w_issue.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Looking at the labels for some of these top-ranked examples, we find their given label was indeed incorrect!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Additional information (statistics, intermediate results, etc) related to a particular issue type can be accessed via `get_info(issue_name)`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "lab.get_info(\"label\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Lastly, you can get all sorts of information regarding your dataset using the `get_info()` method (with no arguments passed). This will not be printed in this tutorial as the return is a large dictionary but feel free to check it out yourself!" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "`Datalab` makes it very easy to check your datasets for all sorts of issues that are important to deal with for training robust models. The inputs it uses to detect issues can come from *any* model you have trained (the better your model, the more accurate the issue detection will be).\n", + "\n", + "For more information, check out this [examples notebook](https://github.com/cleanlab/examples/blob/master/datalab_image_classification/datalab.ipynb) and the [advanced Datalab tutorial](datalab_advanced.html)." + ] + } + ], + "metadata": { + "celltoolbar": "Edit Metadata", + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.9.13" + }, + "vscode": { + "interpreter": { + "hash": "d4d1e4263499bec80672ea0156c357c1ee493ec2b1c70f0acce89fc37c4a6abe" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/docs/source/tutorials/datalab/image.ipynb b/docs/source/tutorials/datalab/image.ipynb new file mode 100644 index 0000000000..4f928b3b43 --- /dev/null +++ b/docs/source/tutorials/datalab/image.ipynb @@ -0,0 +1,551 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Image Classification with PyTorch and Datalab\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This 5-minute quickstart tutorial demonstrates how to find potential label errors in image classification data. Here we use the MNIST dataset containing 70,000 images of handwritten digits from 0 to 9.\n", + "\n", + "**Overview of what we'll do in this tutorial:**\n", + "\n", + "- Build a simple [PyTorch](https://pytorch.org/) neural net and wrap it with [skorch](https://skorch.readthedocs.io/) to make it scikit-learn compatible.\n", + "\n", + "- Use this model to compute out-of-sample predicted probabilities, `pred_probs`, via cross-validation.\n", + "\n", + "- Use these predictions to estimate which images in the dataset are mislabeled via cleanlab's `Datalab` class.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "
    \n", + "Quickstart\n", + "
    \n", + " \n", + "Already have a `model`? Run cross-validation to get out-of-sample `pred_probs` and then the code below to find any potential label errors in your dataset.\n", + "\n", + "\n", + "
    \n", + " \n", + "```python\n", + "from cleanlab import Datalab\n", + "\n", + "lab = Datalab(data=your_dataset, label_name=\"column_name_of_labels\")\n", + "lab.find_issues(pred_probs=your_pred_probs, issue_types={\"label\":{}})\n", + "\n", + "lab.get_issues(\"label\")\n", + "```\n", + " \n", + "
    \n", + "
    " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1. Install and import required dependencies\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can use `pip` to install all packages required for this tutorial as follows:\n", + "\n", + "```ipython3\n", + "!pip install matplotlib torch torchvision skorch datasets\n", + "!pip install cleanlab[datalab]\n", + "# Make sure to install the version corresponding to this tutorial\n", + "# E.g. if viewing master branch documentation:\n", + "# !pip install git+https://github.com/cleanlab/cleanlab.git\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "nbsphinx": "hidden" + }, + "outputs": [], + "source": [ + "# Package installation (this cell is hidden from docs.cleanlab.ai).\n", + "# If running on Colab, may want to use GPU (select: Runtime > Change runtime type > Hardware accelerator > GPU)\n", + "# Package versions used: matplotlib==3.5.1 torch==1.11.0 skorch==0.11.0\n", + "\n", + "dependencies = [\"cleanlab\", \"matplotlib\", \"torch\", \"torchvision\", \"skorch\", \"datasets\"]\n", + "\n", + "if \"google.colab\" in str(get_ipython()): # Check if it's running in Google Colab\n", + " %pip install cleanlab # for colab\n", + " cmd = ' '.join([dep for dep in dependencies if dep != \"cleanlab\"])\n", + " %pip install $cmd\n", + "else:\n", + " missing_dependencies = []\n", + " for dependency in dependencies:\n", + " try:\n", + " __import__(dependency)\n", + " except ImportError:\n", + " missing_dependencies.append(dependency)\n", + "\n", + " if len(missing_dependencies) > 0:\n", + " print(\"Missing required dependencies:\")\n", + " print(*missing_dependencies, sep=\", \")\n", + " print(\"\\nPlease install them before running the rest of this notebook.\")\n", + "\n", + "# Suppress benign warnings: \n", + "import warnings \n", + "warnings.filterwarnings(\"ignore\", \"Lazy modules are a new feature.*\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "from torch import nn\n", + "from sklearn.datasets import fetch_openml\n", + "from sklearn.model_selection import cross_val_predict\n", + "from sklearn.metrics import accuracy_score\n", + "from skorch import NeuralNetClassifier" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "nbsphinx": "hidden" + }, + "outputs": [], + "source": [ + "# This (optional) cell is hidden from docs.cleanlab.ai \n", + "\n", + "import numpy as np \n", + "\n", + "SEED = 123 # for reproducibility \n", + "np.random.seed(SEED)\n", + "torch.manual_seed(SEED)\n", + "torch.backends.cudnn.deterministic = True\n", + "torch.backends.cudnn.benchmark = False\n", + "torch.cuda.manual_seed_all(SEED)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2. Fetch and scale the MNIST dataset\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "mnist = fetch_openml(\"mnist_784\") # Fetch the MNIST dataset\n", + "\n", + "X = mnist.data.astype(\"float32\").to_numpy() # 2D array (images are flattened into 1D)\n", + "X /= 255.0 # Scale the features to the [0, 1] range\n", + "X = X.reshape(len(X), 1, 28, 28) # reshape into [N, C, H, W] for PyTorch\n", + "\n", + "labels = mnist.target.astype(\"int64\").to_numpy() # 1D array of given labels" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "
    \n", + "Bringing Your Own Data (BYOD)?\n", + "\n", + "Assign your data's features to variable `X` and its labels to variable `labels` instead, and continue with the rest of the tutorial.\n", + "\n", + "
    " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3. Define a classification model\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here, we define a simple neural network with PyTorch.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "class ClassifierModule(nn.Module):\n", + " def __init__(self):\n", + " super().__init__()\n", + "\n", + " self.cnn = nn.Sequential(\n", + " nn.Conv2d(1, 6, 3),\n", + " nn.ReLU(),\n", + " nn.BatchNorm2d(6),\n", + " nn.MaxPool2d(kernel_size=2, stride=2),\n", + " nn.Conv2d(6, 16, 3),\n", + " nn.ReLU(),\n", + " nn.BatchNorm2d(16),\n", + " nn.MaxPool2d(kernel_size=2, stride=2),\n", + " )\n", + " self.out = nn.Sequential(\n", + " nn.Flatten(),\n", + " nn.LazyLinear(128),\n", + " nn.ReLU(),\n", + " nn.Linear(128, 10),\n", + " nn.Softmax(dim=-1),\n", + " )\n", + "\n", + " def forward(self, X):\n", + " X = self.cnn(X)\n", + " X = self.out(X)\n", + " return X" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4. Ensure your classifier is scikit-learn compatible\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As some cleanlab features require scikit-learn compatibility, we adapt the above PyTorch neural net accordingly. [skorch](https://skorch.readthedocs.io) is a convenient package that helps with this. Alternatively, you can also easily wrap an arbitrary model to be scikit-learn compatible as demonstrated [here](https://github.com/cleanlab/cleanlab#use-cleanlab-with-any-model-for-most-ml-tasks)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "model_skorch = NeuralNetClassifier(ClassifierModule)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 5. Compute out-of-sample predicted probabilities\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If we'd like cleanlab to identify potential label errors in the whole dataset and not just the training set, we can consider using the entire dataset when computing the out-of-sample predicted probabilities, `pred_probs`, via cross-validation.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "num_crossval_folds = 3 # for efficiency; values like 5 or 10 will generally work better\n", + "pred_probs = cross_val_predict(\n", + " model_skorch,\n", + " X,\n", + " labels,\n", + " cv=num_crossval_folds,\n", + " method=\"predict_proba\",\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "An additional benefit of cross-validation is that it facilitates more reliable evaluation of our model than a single training/validation split." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "predicted_labels = pred_probs.argmax(axis=1)\n", + "acc = accuracy_score(labels, predicted_labels)\n", + "print(f\"Cross-validated estimate of accuracy on held-out data: {acc}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 6. Use cleanlab to find label issues\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Based on the given labels and out-of-sample predicted probabilities, cleanlab can quickly help us identify label issues in our dataset. \n", + "\n", + "Here, we use cleanlab's `Datalab` to find potential label errors in our data. `Datalab` has several ways of loading the data. In this case, we’ll simply wrap the training features and noisy labels in a dictionary. We can instantiate our `Datalab` object with the dictionary created, and then pass in the model predicted probabilities we obtained above, and specify that we want to look for label errors by specifying that using the `issue_types` argument." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from cleanlab import Datalab\n", + "\n", + "data = {\"X\": X, \"y\": labels}\n", + "\n", + "lab = Datalab(data, label_name=\"y\")\n", + "lab.find_issues(pred_probs=pred_probs, issue_types={\"label\":{}})" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "After the audit is complete, we can view the results and information regarding the labels using Datalab's `get_issues` method." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "issue_results = lab.get_issues(\"label\")\n", + "issue_results.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The dataframe above contains a label quality score for each example. These numeric scores lie between 0 and 1, where lower scores indicate examples more likely to be mislabeled. It contains a boolean column specifying whether or not each example is identified to have a label issue (indicating it is likely mislabeled).\n", + "\n", + "We can sort the results obtained by label score to find the indices of the 15 most likely mislabeled examples in our dataset." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "ranked_label_issues = issue_results.sort_values(\"label_score\").index\n", + "\n", + "print(f\"Top 15 most likely label errors: \\n {ranked_label_issues.values[:15]}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "`ranked_label_issues` is a list of indices ranked by the label score of each example, the top indices in the list corresponding to examples that are worth inspecting more closely. To help visualize specific examples, we define a `plot_examples` function (can skip these details)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "
    See the implementation of `plot_examples` **(click to expand)**\n", + "\n", + "```python\n", + "# Note: This pulldown content is for docs.cleanlab.ai, if running on local Jupyter or Colab, please ignore it.\n", + "\n", + "import matplotlib.pyplot as plt\n", + "\n", + "def plot_examples(id_iter, nrows=1, ncols=1):\n", + " for count, id in enumerate(id_iter):\n", + " plt.subplot(nrows, ncols, count + 1)\n", + " plt.imshow(X[id].reshape(28, 28), cmap=\"gray\")\n", + " plt.title(f\"id: {id} \\n label: {y[id]}\")\n", + " plt.axis(\"off\")\n", + "\n", + " plt.tight_layout(h_pad=2.0)\n", + "```\n", + "
    " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "nbsphinx": "hidden" + }, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "def plot_examples(id_iter, nrows=1, ncols=1):\n", + " for count, id in enumerate(id_iter):\n", + " plt.subplot(nrows, ncols, count + 1)\n", + " plt.imshow(X[id].reshape(28, 28), cmap=\"gray\")\n", + " plt.title(f\"id: {id} \\n label: {labels[id]}\")\n", + " plt.axis(\"off\")\n", + "\n", + " plt.tight_layout(h_pad=2.0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's look at the top 15 examples cleanlab thinks are most likely to be incorrectly labeled. We can see a few label errors and odd edge cases. Feel free to change the values below to display more/fewer examples." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plot_examples(ranked_label_issues[range(15)], 3, 5)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's zoom into some specific examples from the above set:" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Given label is **4** but looks more like a **7**:\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plot_examples([59915])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Given label is **4** but also looks like **9**:\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plot_examples([24798])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "A very odd looking **5**:\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plot_examples([59701])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Given label is **3** but could be a **7**:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plot_examples([50340])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "cleanlab has shortlisted the most likely label errors to speed up your data cleaning process. With this list, you can decide whether to fix label issues or prune some of these examples from the dataset. \n", + "\n", + "You can see that even widely-used datasets like MNIST contain problematic labels. Never blindly trust your data! You should always check it for potential issues, many of which can be easily identified by cleanlab.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "nbsphinx": "hidden" + }, + "outputs": [], + "source": [ + "# Note: This cell is only for docs.cleanlab.ai, if running on local Jupyter or Colab, please ignore it.\n", + "\n", + "highlighted_indices = [59915, 24798, 59701, 50340] # verify these examples were found by cleanlab\n", + "if not all(x in ranked_label_issues for x in highlighted_indices):\n", + " raise Exception(\"Some highlighted examples are missing from ranked_label_issues.\")" + ] + } + ], + "metadata": { + "interpreter": { + "hash": "ced20e3e49bb4fa4ce8ad38f8f2535b7fc4c39b2b89554502b5dbdad1ad67eda" + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.9.13" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/docs/source/tutorials/datalab/index.rst b/docs/source/tutorials/datalab/index.rst new file mode 100644 index 0000000000..87c3921263 --- /dev/null +++ b/docs/source/tutorials/datalab/index.rst @@ -0,0 +1,12 @@ +Datalab Tutorials +========= + +.. toctree:: + :maxdepth: 1 + + Detecting Common Data Issues with Datalab + Perform Advanced Data Auditing with Datalab + Text Classification + Tabular Classification + Image Classification Label Errors + Audio Classification Label Errors