From 67b4a5664b899ec128c6d1599f4d36bc99b5c91e Mon Sep 17 00:00:00 2001 From: Mario Graff Date: Fri, 28 Feb 2025 15:40:28 +0000 Subject: [PATCH 1/4] Comparison in performance plot --- CompStats/__init__.py | 2 +- CompStats/interface.py | 66 ++++++++++++++++++++++++++++++++++++------ 2 files changed, 58 insertions(+), 10 deletions(-) diff --git a/CompStats/__init__.py b/CompStats/__init__.py index 8c23749..304ae65 100644 --- a/CompStats/__init__.py +++ b/CompStats/__init__.py @@ -11,7 +11,7 @@ # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. -__version__ = '0.1.10' +__version__ = '0.1.11' from CompStats.bootstrap import StatisticSamples from CompStats.measurements import CI, SE, difference_p_value from CompStats.performance import performance, difference, all_differences, plot_performance, plot_difference diff --git a/CompStats/interface.py b/CompStats/interface.py index f1143a3..d69dd8e 100644 --- a/CompStats/interface.py +++ b/CompStats/interface.py @@ -20,7 +20,6 @@ from CompStats.utils import progress_bar from CompStats import measurements from CompStats.measurements import SE -from CompStats.performance import plot_performance, plot_difference from CompStats.utils import dataframe @@ -248,7 +247,7 @@ def best(self): else: self._best = np.array([key] * value.shape[1]) return self._best - BiB = True if self.statistic_samples.BiB else False + BiB = bool(self.statistic_samples.BiB) keys = np.array(list(self.statistic.keys())) data = np.asanyarray([self.statistic[k] for k in keys]) @@ -338,6 +337,12 @@ def plot(self, value_name:str=None, CI:float=0.05, kind:str='point', linestyle:str='none', col_wrap:int=3, capsize:float=0.2, + comparison:bool=True, + right:bool=True, + comp_legend:str='Comparison', + winner_legend:str='Best', + tie_legend:str='Equivalent', + loser_legend:str='Different', **kwargs): """plot with seaborn @@ -363,32 +368,75 @@ def plot(self, value_name:str=None, value_name = 'Score' else: value_name = 'Error' + if not isinstance(self.statistic, dict): + comparison = False df = self.dataframe(value_name=value_name, var_name=var_name, - alg_legend=alg_legend, perf_names=perf_names) + alg_legend=alg_legend, perf_names=perf_names, + comparison=comparison, alpha=CI, right=right, + comp_legend=comp_legend, + winner_legend=winner_legend, + tie_legend=tie_legend, + loser_legend=loser_legend) if var_name not in df.columns: var_name = None col_wrap = None ci = lambda x: measurements.CI(x, alpha=CI) + if comparison: + kwargs.update(dict(hue=comp_legend)) f_grid = sns.catplot(df, x=value_name, errorbar=ci, y=alg_legend, col=var_name, kind=kind, linestyle=linestyle, col_wrap=col_wrap, capsize=capsize, **kwargs) return f_grid - - def dataframe(self, value_name:str='Score', + def dataframe(self, comparison:bool=False, + right:bool=True, + alpha:float=0.05, + value_name:str='Score', var_name:str='Performance', alg_legend:str='Algorithm', + comp_legend:str='Comparison', + winner_legend:str='Best', + tie_legend:str='Equivalent', + loser_legend:str='Different', perf_names:str=None): """Dataframe""" if perf_names is None and isinstance(self.best, np.ndarray): func_name = self.statistic_func.__name__ perf_names = [f'{func_name}({i})' for i, k in enumerate(self.best)] - return dataframe(self, value_name=value_name, - var_name=var_name, - alg_legend=alg_legend, - perf_names=perf_names) + df = dataframe(self, value_name=value_name, + var_name=var_name, + alg_legend=alg_legend, + perf_names=perf_names) + if not comparison: + return df + df[comp_legend] = tie_legend + diff = self.difference() + best = self.best + if isinstance(best, str): + for name, p in diff.p_value(right=right).items(): + if p >= alpha: + continue + df.loc[df[alg_legend] == name, comp_legend] = loser_legend + df.loc[df[alg_legend] == best, comp_legend] = winner_legend + else: + p_values = diff.p_value(right=right) + systems = list(p_values.keys()) + p_values = np.array([p_values[k] for k in systems]) + for name, p_value, winner in zip(perf_names, + p_values.T, + best): + mask = df[var_name] == name + for alg, p in zip(systems, p_value): + if p >= alpha and winner != alg: + continue + _ = mask & (df[alg_legend] == alg) + if winner == alg: + df.loc[_, comp_legend] = winner_legend + else: + df.loc[_, comp_legend] = loser_legend + return df @property def n_jobs(self): From 00e7b954173646359cfc4c67ba596948572215dd Mon Sep 17 00:00:00 2001 From: Mario Graff Date: Fri, 28 Feb 2025 16:21:35 +0000 Subject: [PATCH 2/4] col_wrap --- CompStats/interface.py | 4 ++++ CompStats/tests/test_interface.py | 20 +++++++++++++++++++- 2 files changed, 23 insertions(+), 1 deletion(-) diff --git a/CompStats/interface.py b/CompStats/interface.py index d69dd8e..a4262fb 100644 --- a/CompStats/interface.py +++ b/CompStats/interface.py @@ -370,6 +370,10 @@ def plot(self, value_name:str=None, value_name = 'Error' if not isinstance(self.statistic, dict): comparison = False + best = self.best + if isinstance(best, np.ndarray): + if best.shape[0] < col_wrap: + col_wrap = best.shape[0] df = self.dataframe(value_name=value_name, var_name=var_name, alg_legend=alg_legend, perf_names=perf_names, comparison=comparison, alpha=CI, right=right, diff --git a/CompStats/tests/test_interface.py b/CompStats/tests/test_interface.py index feebee9..f2d02c4 100644 --- a/CompStats/tests/test_interface.py +++ b/CompStats/tests/test_interface.py @@ -17,12 +17,30 @@ from sklearn.svm import LinearSVC from sklearn.ensemble import RandomForestClassifier from sklearn.naive_bayes import GaussianNB -from sklearn.datasets import load_iris, load_digits +from sklearn.datasets import load_iris, load_digits, load_breast_cancer from sklearn.model_selection import train_test_split import pandas as pd from CompStats.tests.test_performance import DATA +def test_Perf_plot_col_wrap(): + """Test plot when 2 classes""" + from CompStats.metrics import f1_score + + X, y = load_breast_cancer(return_X_y=True) + _ = train_test_split(X, y, test_size=0.3) + X_train, X_val, y_train, y_val = _ + ens = RandomForestClassifier().fit(X_train, y_train) + nb = GaussianNB().fit(X_train, y_train) + svm = LinearSVC().fit(X_train, y_train) + score = f1_score(y_val, ens.predict(X_val), + average=None, + num_samples=50) + score(nb.predict(X_val)) + score(svm.predict(X_val)) + score.plot() + + def test_Difference_dataframe(): """Test Difference dataframe""" from CompStats.metrics import f1_score From 31e3b5b5652f8cb619f8ab148228fa2a2da548be Mon Sep 17 00:00:00 2001 From: Mario Graff Date: Fri, 28 Feb 2025 18:11:07 +0000 Subject: [PATCH 3/4] Docs (1) --- README.rst | 32 +++-- docs/CompStats_metrics.ipynb | 204 +++++++++++++++--------------- docs/source/digits_difference.png | Bin 18318 -> 21246 bytes docs/source/digits_perf.png | Bin 0 -> 20400 bytes docs/source/metrics_api.rst | 45 ++++--- 5 files changed, 148 insertions(+), 133 deletions(-) create mode 100644 docs/source/digits_perf.png diff --git a/README.rst b/README.rst index 7e124c8..f71d132 100644 --- a/README.rst +++ b/README.rst @@ -27,7 +27,7 @@ CompStats Collaborative competitions have gained popularity in the scientific and technological fields. These competitions involve defining tasks, selecting evaluation scores, and devising result verification methods. In the standard scenario, participants receive a training set and are expected to provide a solution for a held-out dataset kept by organizers. An essential challenge for organizers arises when comparing algorithms' performance, assessing multiple participants, and ranking them. Statistical tools are often used for this purpose; however, traditional statistical methods often fail to capture decisive differences between systems' performance. CompStats implements an evaluation methodology for statistically analyzing competition results and competition. CompStats offers several advantages, including off-the-shell comparisons with correction mechanisms and the inclusion of confidence intervals. -To illustrate the use of `CompStats`, the following snippets show an example. The instructions load the necessary libraries, including the one to obtain the problem (e.g., digits), three different classifiers, and the last line is the score used to measure the performance and compare the algorithm. +To illustrate the use of `CompStats`, the following snippets show an example. The instructions load the necessary libraries, including the one to obtain the problem (e.g., digits), four different classifiers, and the last line is the score used to measure the performance and compare the algorithm. >>> from sklearn.svm import LinearSVC >>> from sklearn.naive_bayes import GaussianNB @@ -51,10 +51,10 @@ Once the predictions are available, it is time to measure the algorithm's perfor >>> score -The previous code shows the macro-f1 score and, in parenthesis, its standard error. The actual performance value is stored in the `statistic` function. +The previous code shows the macro-f1 score and its standard error. The actual performance value is stored in the attributes `statistic` function, and `se` ->>> score.statistic -0.9434834454375508 +>>> score.statistic, score.se +(0.9521479775366307, 0.009717884979482313) Continuing with the example, let us assume that one wants to test another classifier on the same problem, in this case, a random forest, as can be seen in the following two lines. The second line predicts the validation set and sets it to the analysis. @@ -63,28 +63,34 @@ Continuing with the example, let us assume that one wants to test another classi Statistic with its standard error (se) statistic (se) -0.9655 (0.0077) <= Random Forest -0.9435 (0.0099) <= alg-1 +0.9720 (0.0076) <= Random Forest +0.9521 (0.0097) <= alg-1 -Let us incorporate another prediction, now with the Naive Bayes classifier, as seen below. +Let us incorporate another predictions, now with Naive Bayes classifier, and Histogram Gradient Boosting as seen below. >>> nb = GaussianNB().fit(X_train, y_train) >>> score(nb.predict(X_val), name='Naive Bayes') Statistic with its standard error (se) statistic (se) -0.9655 (0.0077) <= Random Forest -0.9435 (0.0099) <= alg-1 -0.8549 (0.0153) <= Naive Bayes +0.9759 (0.0068) <= Hist. Grad. Boost. Tree +0.9720 (0.0076) <= Random Forest +0.9521 (0.0097) <= alg-1 +0.8266 (0.0159) <= Naive Bayes -The final step is to compare the performance of the three classifiers, which can be done with the `difference` method, as seen next. +The performance, its confidence interval (5%), and a statistical comparison (5%) between the best performing system with the rest of the algorithms is depicted in the following figure. + +>>> score.plot() + +The final step is to compare the performance of the four classifiers, which can be done with the `difference` method, as seen next. >>> diff = score.difference() >>> diff -difference p-values w.r.t Random Forest +difference p-values w.r.t Hist. Grad. Boost. Tree 0.0000 <= Naive Bayes -0.0120 <= alg-1 +0.0100 <= alg-1 +0.3240 <= Random Forest The class `Difference` has the `plot` method that can be used to depict the difference with respect to the best. diff --git a/docs/CompStats_metrics.ipynb b/docs/CompStats_metrics.ipynb index 2527d84..28c8838 100644 --- a/docs/CompStats_metrics.ipynb +++ b/docs/CompStats_metrics.ipynb @@ -48,58 +48,11 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": { - "id": "I1B4Ktin2VfE", - "colab": { - "base_uri": "https://localhost:8080/" - }, - "outputId": "b37f28d5-90d9-4d94-c28c-27f9054f1a23" + "id": "I1B4Ktin2VfE" }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Collecting git+https://github.com/INGEOTEC/CompStats@develop\n", - " Cloning https://github.com/INGEOTEC/CompStats (to revision develop) to /tmp/pip-req-build-yb73d9s4\n", - " Running command git clone --filter=blob:none --quiet https://github.com/INGEOTEC/CompStats /tmp/pip-req-build-yb73d9s4\n", - " Running command git checkout -b develop --track origin/develop\n", - " Switched to a new branch 'develop'\n", - " Branch 'develop' set up to track remote branch 'develop' from 'origin'.\n", - " Resolved https://github.com/INGEOTEC/CompStats to commit 438a8055b71bba437bad7bd1ef5427b29e0ed245\n", - " Installing build dependencies ... \u001b[?25l\u001b[?25hdone\n", - " Getting requirements to build wheel ... \u001b[?25l\u001b[?25hdone\n", - " Preparing metadata (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", - "Requirement already satisfied: numpy in /usr/local/lib/python3.11/dist-packages (from CompStats==0.1.7) (1.26.4)\n", - "Requirement already satisfied: scikit-learn>=1.3.0 in /usr/local/lib/python3.11/dist-packages (from CompStats==0.1.7) (1.6.1)\n", - "Requirement already satisfied: pandas in /usr/local/lib/python3.11/dist-packages (from CompStats==0.1.7) (2.2.2)\n", - "Requirement already satisfied: seaborn>=0.13.0 in /usr/local/lib/python3.11/dist-packages (from CompStats==0.1.7) (0.13.2)\n", - "Requirement already satisfied: scipy>=1.6.0 in /usr/local/lib/python3.11/dist-packages (from scikit-learn>=1.3.0->CompStats==0.1.7) (1.13.1)\n", - "Requirement already satisfied: joblib>=1.2.0 in /usr/local/lib/python3.11/dist-packages (from scikit-learn>=1.3.0->CompStats==0.1.7) (1.4.2)\n", - "Requirement already satisfied: threadpoolctl>=3.1.0 in /usr/local/lib/python3.11/dist-packages (from scikit-learn>=1.3.0->CompStats==0.1.7) (3.5.0)\n", - "Requirement already satisfied: matplotlib!=3.6.1,>=3.4 in /usr/local/lib/python3.11/dist-packages (from seaborn>=0.13.0->CompStats==0.1.7) (3.10.0)\n", - "Requirement already satisfied: python-dateutil>=2.8.2 in /usr/local/lib/python3.11/dist-packages (from pandas->CompStats==0.1.7) (2.8.2)\n", - "Requirement already satisfied: pytz>=2020.1 in /usr/local/lib/python3.11/dist-packages (from pandas->CompStats==0.1.7) (2025.1)\n", - "Requirement already satisfied: tzdata>=2022.7 in /usr/local/lib/python3.11/dist-packages (from pandas->CompStats==0.1.7) (2025.1)\n", - "Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.11/dist-packages (from matplotlib!=3.6.1,>=3.4->seaborn>=0.13.0->CompStats==0.1.7) (1.3.1)\n", - "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.11/dist-packages (from matplotlib!=3.6.1,>=3.4->seaborn>=0.13.0->CompStats==0.1.7) (0.12.1)\n", - "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.11/dist-packages (from matplotlib!=3.6.1,>=3.4->seaborn>=0.13.0->CompStats==0.1.7) (4.56.0)\n", - "Requirement already satisfied: kiwisolver>=1.3.1 in /usr/local/lib/python3.11/dist-packages (from matplotlib!=3.6.1,>=3.4->seaborn>=0.13.0->CompStats==0.1.7) (1.4.8)\n", - "Requirement already satisfied: packaging>=20.0 in /usr/local/lib/python3.11/dist-packages (from matplotlib!=3.6.1,>=3.4->seaborn>=0.13.0->CompStats==0.1.7) (24.2)\n", - "Requirement already satisfied: pillow>=8 in /usr/local/lib/python3.11/dist-packages (from matplotlib!=3.6.1,>=3.4->seaborn>=0.13.0->CompStats==0.1.7) (11.1.0)\n", - "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.11/dist-packages (from matplotlib!=3.6.1,>=3.4->seaborn>=0.13.0->CompStats==0.1.7) (3.2.1)\n", - "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.11/dist-packages (from python-dateutil>=2.8.2->pandas->CompStats==0.1.7) (1.17.0)\n", - "Building wheels for collected packages: CompStats\n", - " Building wheel for CompStats (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", - " Created wheel for CompStats: filename=CompStats-0.1.7-py3-none-any.whl size=41028 sha256=e70584ada7f0c49c8768febba12e978c4e122d93bf8452e2d42ea190cc5b1ece\n", - " Stored in directory: /tmp/pip-ephem-wheel-cache-sgv6titu/wheels/4f/d2/a1/8d1d30289bd99417ea947fc1e1f4587404d4e3a043b41f0289\n", - "Successfully built CompStats\n", - "Installing collected packages: CompStats\n", - "Successfully installed CompStats-0.1.7\n" - ] - } - ], + "outputs": [], "source": [ "try:\n", " import CompStats\n", @@ -122,7 +75,7 @@ "source": [ "`CompStats.metrics` aims to facilitate performance measurement (with standard errors and confidence intervals) and statistical comparisons between algorithms on a single problem, wrapping the different scores and loss functions found on `metrics`.\n", "\n", - "To illustrate the use of `CompStats.metrics`, the following snippets show an example. The instructions load the necessary libraries, including the one to obtain the problem (e.g., digits), three different classifiers, and the last line is the score used to measure the performance and compare the algorithm." + "To illustrate the use of `CompStats.metrics`, the following snippets show an example. The instructions load the necessary libraries, including the one to obtain the problem (e.g., digits), four different classifiers, and the last line is the score used to measure the performance and compare the algorithm." ], "metadata": { "id": "ZyRCAFoJ3LzP" @@ -133,7 +86,7 @@ "source": [ "from sklearn.svm import LinearSVC\n", "from sklearn.naive_bayes import GaussianNB\n", - "from sklearn.ensemble import RandomForestClassifier\n", + "from sklearn.ensemble import RandomForestClassifier, HistGradientBoostingClassifier\n", "from sklearn.datasets import load_digits\n", "from sklearn.model_selection import train_test_split\n", "from sklearn.base import clone\n", @@ -142,7 +95,7 @@ "metadata": { "id": "jEpd52Kq214r" }, - "execution_count": 2, + "execution_count": 12, "outputs": [] }, { @@ -166,7 +119,7 @@ "metadata": { "id": "JGJczaOW3WeK" }, - "execution_count": 3, + "execution_count": 13, "outputs": [] }, { @@ -189,33 +142,33 @@ "base_uri": "https://localhost:8080/" }, "id": "Al0u9ZPB3cSj", - "outputId": "33d3dc5e-d7c7-4a2e-a3af-284a99935733" + "outputId": "6eb7e800-b835-46af-84d8-16c3ad214d58" }, - "execution_count": 4, + "execution_count": 14, "outputs": [ { "output_type": "stream", "name": "stderr", "text": [ - "100%|██████████| 1/1 [00:05<00:00, 5.46s/it]\n" + "100%|██████████| 1/1 [00:00<00:00, 1.03it/s]\n" ] }, { "output_type": "execute_result", "data": { "text/plain": [ - "" + "" ] }, "metadata": {}, - "execution_count": 4 + "execution_count": 14 } ] }, { "cell_type": "markdown", "source": [ - "The previous code shows the macro-f1 score and, in parenthesis, its standard error. The actual performance value is stored in the `Perf.statistic` function." + "The previous code shows the macro-f1 score and, in parenthesis, its standard error. The actual performance value is stored in the attributes `statistic` function, and `se`." ], "metadata": { "id": "OV5-SrTh3loq" @@ -224,26 +177,26 @@ { "cell_type": "code", "source": [ - "score.statistic" + "score.statistic, score.se" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "Ye1HH4pn3jde", - "outputId": "a0f19b8f-eeb4-46ba-d0a1-8f3d59b67527" + "outputId": "3c7c9e30-06fa-4e62-b0ea-6eb53012af01" }, - "execution_count": 5, + "execution_count": 15, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ - "0.9434834454375508" + "(0.9521479775366307, 0.009717884979482313)" ] }, "metadata": {}, - "execution_count": 5 + "execution_count": 15 } ] }, @@ -267,15 +220,15 @@ "base_uri": "https://localhost:8080/" }, "id": "vboh7N9B3pDr", - "outputId": "980e3a62-1577-425d-ed59-69fbb93c4945" + "outputId": "73b9de04-f3b7-4a17-d2a7-09dc453c8f4e" }, - "execution_count": 6, + "execution_count": 16, "outputs": [ { "output_type": "stream", "name": "stderr", "text": [ - "100%|██████████| 1/1 [00:01<00:00, 1.04s/it]\n" + "100%|██████████| 1/1 [00:00<00:00, 1.03it/s]\n" ] }, { @@ -285,19 +238,19 @@ "\n", "Statistic with its standard error (se)\n", "statistic (se)\n", - "0.9655 (0.0077) <= Random Forest\n", - "0.9435 (0.0099) <= alg-1" + "0.9720 (0.0076) <= Random Forest\n", + "0.9521 (0.0097) <= alg-1" ] }, "metadata": {}, - "execution_count": 6 + "execution_count": 16 } ] }, { "cell_type": "markdown", "source": [ - "Let us incorporate another prediction, now with the Naive Bayes classifier, as seen below." + "Let us incorporate another predictions, now with Naive Bayes classifier, and Histogram Gradient Boosting as seen below." ], "metadata": { "id": "v2R8F5H73vuc" @@ -307,22 +260,24 @@ "cell_type": "code", "source": [ "nb = GaussianNB().fit(X_train, y_train)\n", - "score(nb.predict(X_val), name='Naive Bayes')" + "score(nb.predict(X_val), name='Naive Bayes')\n", + "hist = HistGradientBoostingClassifier().fit(X_train, y_train)\n", + "score(hist.predict(X_val), name='Hist. Grad. Boost. Tree')" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "pVOaQb0T3tyN", - "outputId": "258373fc-4afb-4442-9e5f-e9fb75d743ef" + "outputId": "a38ce6fe-cadd-4f85-d127-423d66c2947b" }, - "execution_count": 7, + "execution_count": 17, "outputs": [ { "output_type": "stream", "name": "stderr", "text": [ - "100%|██████████| 1/1 [00:01<00:00, 1.48s/it]\n" + "100%|██████████| 2/2 [00:02<00:00, 1.00s/it]\n" ] }, { @@ -332,20 +287,67 @@ "\n", "Statistic with its standard error (se)\n", "statistic (se)\n", - "0.9655 (0.0077) <= Random Forest\n", - "0.9435 (0.0099) <= alg-1\n", - "0.8549 (0.0153) <= Naive Bayes" + "0.9759 (0.0068) <= Hist. Grad. Boost. Tree\n", + "0.9720 (0.0076) <= Random Forest\n", + "0.9521 (0.0097) <= alg-1\n", + "0.8266 (0.0159) <= Naive Bayes" ] }, "metadata": {}, - "execution_count": 7 + "execution_count": 17 } ] }, { "cell_type": "markdown", "source": [ - "The final step is to compare the performance of the three classifiers, which can be done with the `Perf.difference` method, as seen next. " + "The performance, its confidence interval (5\\%), and a statistical comparison (5\\%) between the best performing system with the rest of the algorithms is depicted in the following figure." + ], + "metadata": { + "id": "EY2NX9twUWjQ" + } + }, + { + "cell_type": "code", + "source": [ + "score.plot()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 523 + }, + "id": "5hxPgZY-UXCc", + "outputId": "068f61bb-e52a-48b3-a0bb-d37eab65b299" + }, + "execution_count": 18, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ] + }, + "metadata": {}, + "execution_count": 18 + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "The final step is to compare the performance of the four classifiers, which can be done with the `Perf.difference` method, as seen next. " ], "metadata": { "id": "VRqHiUXN32ZX" @@ -362,22 +364,23 @@ "base_uri": "https://localhost:8080/" }, "id": "XWAqUpYE3za2", - "outputId": "3f108864-6a1f-41bf-dda3-ccab294444e5" + "outputId": "2804fcd4-d766-4de5-ee27-276d4d7f3324" }, - "execution_count": 8, + "execution_count": 22, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "\n", - "difference p-values w.r.t Random Forest\n", + "difference p-values w.r.t Hist. Grad. Boost. Tree\n", "0.0000 <= Naive Bayes\n", - "0.0120 <= alg-1" + "0.0100 <= alg-1\n", + "0.3240 <= Random Forest" ] }, "metadata": {}, - "execution_count": 8 + "execution_count": 22 } ] }, @@ -398,34 +401,33 @@ "metadata": { "colab": { "base_uri": "https://localhost:8080/", - "height": 546 + "height": 529 }, "id": "Fai01O3q3-SN", - "outputId": "eae94c83-bac5-473d-b708-23f549b27b07" + "outputId": "a5aaacce-74fc-42dc-86dc-09512421ffbe" }, - "execution_count": 9, + "execution_count": 23, "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "" - ] - }, - "metadata": {}, - "execution_count": 9 - }, { "output_type": "display_data", "data": { "text/plain": [ - "
" + "
" ], - "image/png": "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\n" + "image/png": "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\n" }, "metadata": {} } ] + }, + { + "cell_type": "code", + "source": [], + "metadata": { + "id": "VI3JFKudVYNI" + }, + "execution_count": null, + "outputs": [] } ] } \ No newline at end of file diff --git a/docs/source/digits_difference.png b/docs/source/digits_difference.png index 608e0b6211bef8ef94b427f31c47c18c6110c6df..74cee9d9c2a0616aae887c06042575269dc8149b 100644 GIT binary patch literal 21246 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 h{out&Am08(@%HA|Ik$KxH z*?VvP?~C)C-}5}b|9O7T>vcFK?)&?_zMt#!d9TYI`BTT%tlYAaLZPgo9Y3r{p)5R# z56beT_=FW_Zy)&j4x!u+_JC56ItfqX28l8H2=P>xQ}4j)jy8rWTb zE%1x=>}-E)mz`SX-AdlB{o9j@ZfjWWUVpGHEa}sF-`KnCvNSjO-QiU{8+9F>y$-oi z<1^?Fl#2Ln-wgcp@}k%UTbtJDNgbJ%J$kAh)j_%(qqQbxjxEBy;|^L9M+b+ToTYnH z3t4p*<5HH4W#F^RYuEGm+xcHv7f>i?m*ci6n_So7>u!Jh?XTY9W{g5%p9d%I@KN|tfIv0haU4h6E5q0$)n_@ z&U-I^|Co{P+Rnz=nbiF@U2VgILE@H2Lyz90b0-WvKk<0ak#+0VO$-*xBwMvBp7a-? z1&End#;C-`PgF4;4fd9~`HL9-2sIjL=`LPoF7+Ghg7LN@iC*P5x7GxCaykwvcvCgi zIi1EX^Oa5q&s#Qr-Qs@%a@Xg;m(S*D>|I2s#i6}r0vQ=oM)n+ z9l2{iokkfbkl!Nj@+>rTBL_$PlWh#=NBh{b#$8oab=f_9X z?!BgUQ7I<19kkA+}-t=jP%~oMrX!@Uk@>Jawh!o$MPdbk9Od0%2OMiItOZ+Kl^^x zOEm1MOSf+i_f^huuyb>BYagjKV+2cGt1BAr$?T1h_2yg2#H89(a4*@S`ICn6ey6E4 zVe?yVZqcWL_WKLz+>#5Jo*X4FGd0$4KUgTHl5U~9kyr7sNljA8(?hrMQ2c~+=3e{u z?O4m!qKWCzMkzeWy=D!Pq6S}o|Ni}Z#`jxn<=NM4rw2X@P)+D`I`g`9PqVL$#yC!n z@SSKh?Hj+eF8Y0~J!;6y$0tJDd0M4_b*qe%#-kl4OWVsLEAZpKHu!!OBcmAm zk*??kiY#fR+WF>zO(N=IaLGpnlNwJ5UL++ceJFWq$bxnS9<*C z2AblD6CM#K9zT1}aqWa{qho4MdMgJ_vAZUDJ1uu=;I2`5)Kd;Admd5IiqJ;=*_mm2 z*pGL2B}S)*%1*1lIDfq-ch*TIMw#~h{?;;y-mK7@Hy3wTy*$+X$=g!Apz5X0#$SGU z^6Q~nJiB+FOvoB=$1NqB*6-I37;U(A8kb$sI5Q%)W{b#indzZN`>i{|)^C@MI_S2t z$VR_7Smo}f-AVez9K*eh+TMIBrCD}^US3{dN|C1wzvW%0wg!tD`|J@G9v*A*>?F^d zKOyT`yk;hf`iy#xL;9_?TVtfIjTn@M(YEZl^hbm9?DS`QZR%Qu>({RrjkZmN7-M&M z1qMFXd4HdG`}QNTstJ`oyU#Ii-P-M-dFG5yO^QiuOJRU99x$I`*dJl8;|`P;tQ0LV z#|bO0kKH>(M9RY=A~KRR(=EauUeYV{Z+WQ_3?7mi(iWegZEu|eS8ns zvHMonOz~Wf(%VZy-)mROSo}QB^|7la`Eww?p{p^sF>7{aa)+d3-P^Zs{bXjR%Bn}| z(k*vLNYr*~Jbn69Z>X)L$nmq!ZejX~ds{?L96fr=(pgs4{o$pY*_mrP9zu^FKaNn2 zR*W#M&!BcUIF4#^edOlm-ZzR(R&soguzrzM&*v{+L{0|m6-6J|AthDcZ0mXFj!@*O zAd8f(doTMvywp)1t21qB7_`-x)bnb1ADpQ6sC znie_c=jU$`JnwQUL^^IG|CzL;Ts#uZ`&VWbw)fO$X0A5dYgl?1>umZ)({3C!7vx+d z=d-Kixmu!zldto1r}oNKt1MG`zdpTTnlrAqTPv%o`>dzbh~MWX*9iy8hkW@h4?MSs znRZ$9TVsWl6SSmAVQ-bNQO081^ftsLC5fQS`4~Fv*x+=p2M?ZH>&;e0k(SJ%%}6i49k%LrE49wKUsTd=e6n#ixbq#OwOBjb-a56F+-7R#q^qkd>2to0 zZsUUsG(49d{e8j8<;&&qNWJOwXZ4x3v1j7cE%vdak$WZje!ti%;Fnx|d7>@UbEr_P zv5gF@8N70gYJ!%1cQS)~F|D53vxdd#d!sc&)7{fk_2R{6drfM7uI3WRoqBbPi8CGp z!SIWp5TC-cn+q2%6fyX^O`Lsgs?O4-OIz%zIv$M9+&at2R}rf;t0rxxt)ei!gmkPl&^h_?wX94OHbact?z-iHw>J@#!;cSH8MV#z^|-?+H8H*2t! zrkZJQ-?`Jcvog-8EaIN)jT_0=MokL?#7^__@@4=@i0Blo&K|BjmoeFssS+-`ak~FK zr~iKI82o%ij^j0&B0zvq<@0Dht;b?L5}^6ef!@ zmMO!!vn5MYhDtqkV;R%TXC3D9)U#-o#!!2i=149UJwh>Db_XVz$mOc94%5R7)Au3; zei(?4(Lnv#Ow;mj-n{8IHg+{tCrIXfY(h@QE13lUqS^$o`w*&#ei6G8TG`yy zdhuMqfG;eTne8f#IOfR_VNmkSj)N;#hLd7Z<-z+cb`?PMO5S*(g%rw*Up#=NcP-|^ z=T-U3DU`f}g8%$w866J=dwcuq2@94`@{(Q7|J0uuYhpTbmz=8`2ODl^1tA_tAi$GWk_D$@AY=AK}9AM%G8ql<)#Z4Eh4y8+jjxw_v<=5 zYsjT|uB!t=-70xip012%v1IXskOh>P>t>Q^A3uF6_1G*-iWVDYJcAu~wEF*Z{r`4b zf_TNnOP9u=80OyC4J^Y!bMeYk_VyXio;@Sr?!$-U+P;e@zdwB~zl9Ktry^-r_Ob7` z`1uES^yTVTyH+fu^szZK<(~vLL3u_PmPNeeUQWqN_&-*XT*)A7{>k&_pR8ZMKCqTT z8C&JExL=sO;O`BrvWxIA1ihAu6|e^FyK;~YkjMqD(&SE|@URZC=HII~Wq9!_iRgY} zuI{#(yTa@L1siG+at**ri<;Dwr>~*7)2+W#S19g%&eB- zozAk#-eA-5C<+wkq5;S)pL^Yrmo)OlnI`D`@g4je^rp*d(_Lqh02kq zwzlr2P-a}WADCKAUhsif2G)_XYjt@3J)r{eCTnwZ!GC@uZ{WdDDIBI4o zC9gCqeQ2;)ytetXT=3e(q&-3@W}S?_ zS5)wlCGAgda|~E-rcjvo&EN6-4#v}b^!Raff75$8`mNQQUy~=DdqD7DJP>7q9EI{E zPsj^u!Qb)d@9`pOFRL%R-@9jRx`^^kVEIw=4eadC!@{`#Wn0d52vV!$rfIZ?+-unP zJ(w?@^EWj>cncWYDHQo{;OXCPdpxX+d$ft_bt>4)oyB**t&hLR!?evCXSy<09Nn#+ zBwwFlEqdk0VQt@q6t|j@Zbe0U(v{H8nU^}@x7LK0D@UK%t*yLtEcmoQ&M8@0dZAt! z=#1uwz}Xky+*^yse?B@bqW6W>%%`=*A-mOC)@N6=O?OQ@sPSjU;6j(w%Z*e~vmOrj zqS`c}*75GzRVmabFZ#wc4KG}{02CN_Dp=A^PAkkKJc4 zDGis~$jlsef2%~xq}_sVMw=g%DOq)tht~$}-#*;+xQwGuOqx^HxIQC!q^mjkP5supMN(-)rKpb*)>JOv5Wzt`HnNGo0Y8`KsaTS9xz{dl|L z-P^av>4amA54Lu;hB%*jyhqo|&o62n*HIo&&dJeURj|Nhr)hgp%oe-4I~#Tyy}r4k zCe+jzkRO220jqA{U`=Nmv)2eOW{5#!lwV0iBt9}=ss@3BnCdphA-DsqCqx8QK%a-) zCXG3ojgF&1(lcW^v{GPwk&ADapA42%8}6tm16wSQJk7arx4N>F{ZQKTn$w^Tgzx}c z@Tt8DvvhuW@f{InAR)9*_U5XFNINP6Mo57@yWhR51V|(bGU1fREW-_E;j+wUM` ziU7>z0G=oP1P=hhRD6AUs3O@|)p58&l}rObjtEsPyCa0HlbIN&k*>JI*SSIW(j^`) zt~cZRq@<<=oCN|3Bk;E3sSBK&d$n)*vORO@bnhoz-mfS~0{t)@)Bj|GR9}kn5MWlF%T}+iTeLh(hF`0faV~zl<}D-4Xzt3?bj= zVt|^=yVc9d$MHR2d!i5*p#LSP&k&W{ldpkytlaoxfo300z8KpF6U`0(j(N8EqfWxaiSI2&wki?lZp68%`gm&rA)TCXX60FKS|_y~%;hR*Yk+nm*`@C`KNw6lfbOW!6sgBS>69 zs}hPH3m-Gf>c2J8Qy&ZD$j{F&hf*riu>w7to)|8h8Xp|~c7useR8$4*Ksm6&Y!(~S zsQQ&Iu(i3wY(w_7iineJ^-h!Bgxu7on9ThZ&y!CpEA8AQ2AR0C8E@o!qJ;QPZC&v5 z#f+@B82T7Bw5*DE&z{!3PI#zNw`O9#E)LC|o$fWNO^Lg;hOH&Vr5zY8#> zeCkP2fQ(^ZzI>7NWB^%`x+ltCb)r6C{I61dd5h>4xAM3R!Tya(!|r_U1RN4j(}#qq zl5C{X+Jpy;`78_3rQ)tYPE@ingHK2ZsOz30u6yIgjp2Bu&SZv`WzG(6?!%sv1Aj!E z4vD|klYWfTq3^n7MEl@yJy;xRd9~wM)L87w-Da5|cQ;1KKb)y59sEPe}ckbA4`dVDh8(CT>>|C6A zMDmZ*3+``?#S6qhBA`x!N5-MVW3P?&(7A8FdCKWLr2y#sW$-M7KUI`Aq?+(V{o;=M z5*I=@!k9v}AaNg!*HQQmQY5!hXfAZKvTv6)sF;2%Y+)LEe{vY;e^448dFXfhULEJF;`QhQGFJH=`6lesqi5ht=UCsIgtN_pJ z)aK2bYtpWSl8N)t9F_Vsv~uH}ou`A#A-4ueNwykGUG00KR~#INo@M!G*Q+tId ze}okuy1iBfZGxGDqsJj$JJ*R&Gtz=0L!8vN%X)nUQ4qN{av93fNj5Rla*P*J%@8tV z(ca3?^_5X9a=H1wA6Y}8aJ24q>AX?sBW$NL*y5X`E3;qSUpi>>i|-*0(w-&nj(T$J zzWwI=tKRX}5LN7@iWHM`P|^?Te)3ZArE1O$oCS*x!Nw6I!#>Wjw;>w{Q{-fbv?i)u z_V{sm=%BUoB5_(gmPl;Kj60RD5rs~oq?LEl4`0Mr=FOX<6LM$NF)bM< z#p=T_{EP$sP$i6JO5dTq=ZZv+%{W{UeGqU^%&UcI zVzf5_eIV+{-A$%%48U+~+k^(LmzOJtM?_3ytfo-R*8$$4C%0yp%@K{Aivd8_uATY( z&T0WAjpNF_|G|?Nc-EK#)kT~N;-htxMKaC9To5S_A)-ZDvQa3`5WD_^N0M3ktw1jk zZROJ(HP{An0^0-E_p@`4%R<#0ho0KL(+(U{j|v49?rGCbpH_utSXx?&WpD3%m0RE)_LF3fN1}A9yR)n z*Axp5ic%zWMMcvUSA>UCX}jTisGho;D!qf5f&w-Omky zKmPGQY~i0Ti-G&c+-WHa;-_`gB*(hCj`@N5ENZ-J-ekTn32Mna*O=!`|A`O*c01i7 zc=!XG)KT2`pH|i5gzr1hsL+6Xx$7NA>*uK?;dXDne+9@)(s{r3zh)-jahBq8uBwwN`YFQ7U(;wsR3i)iW+s&I}q{vnV9?Lfv?WxDM z@~wQX*7T~86;v~#tLt(CGnktE1Id*~X*Al(l`Bhu^^{XCtKCwM7gkeKQ%^E@$Q=z? zV*biG9Ggt)GgJUFN+A|@b=%7?2U~Z9MMe*U2R508;#+zDm~D8)b2X*hnTgm`V+ap@ zyq>NlX;+$t(C3ZE2bw1^l)Zw3dj>$<%y$nM@Wg?f)5B`ba_eWT#O&%dNH;e z;_)qct++ZUDgXFO4$~wMw0&>(DAB}digD`6tyYw=_?S@0|HZ#l43A^^ZP%A^d=2%KCW2razJ0${ z+XFHffLLN7kvGJzTk_?*xdB`;GEg8iCwyK2YIoI2wFVDeH?ex?1DEH%Ys?sH!&N$- zh8Ry;yMF=udvcZ81A3+x1mQo?HC-7%lI*?McX&3;+@7~ei}+!){Ag<0$i@~ckTdpL zJQ7VOFZo00`EtNt0=nr|BVB5s6Y@kAg-10Esqk9z?_{-qC2sk1T4Q_X@rHq97VMXCu~~L zdx3@}8)&&A_&T}W!c_sd)`zOeN6UZ=yOEXk?1SwKDc^*BrMyOfVGW214v-go^~W8# z6hizGG6cs?;b(C5{4}GIXOOti6{!-eCe^QwKw73JL1cuctx?;Y%!x2d@{IK&ti-)ogo|ZBdh0U3#AHR=v$+Bg!7vH(VQz-JZ$2U3@gg#CP z0Wy-B>`EjKXSOC29!Bw1k^Clri)5I0-u$YkUcP)uuJQ9Akmrc(75w0mk9erzax4PA z*I#pkEfSw(esC=Ibh`C8VL{$3hEXASN$gfO;`DCXb@oZzxzvoVfIYhI_c>+a!8(oe zU6;T!^uoV=OCD?ybA1>BVJdI96|(3Sp^G;+31|^-FB)JeMk(?>c&`)sr< z^t_01<*t)K`&9@zMNO82#}K&5b=2dlSffMJ$6psvT$UA$*6lj`;&*^u=W1zSE8BW& zUu?i+RQtWn!bbsP3zNGoi=`qNTGt3tRhE~30KVXDoC$y00PK$*27{;V!$Yq06gDgs z;S@j-#^|XNU~|eDR)(#EknEL!Fm1Z3o)VIUYud2mgt>SD9voRgz{}$(lu}4KA~s!T zX^OCDp{&G6J5KEDjFNx)T03Va3nooBY7p4o*K2SY-N$DKt)uE?C~U2s`8&Za643xZ z)P@>4gE`?1FObA6faYzCXTiQdAb0@AMjjr3$?#`^+$d-drY733ueNh@AEyV~wQL5# zI{-^S2`x)56P>Bm`mo)aT4Jw2J1fEdtOz~EL{kJ*FVC{G)DHlPZAjk=*Mlqwge7~- zo1n?9uoIP(i2Fe+eZwU49Av2@+*eBxkPIDNIqdj4&)ZB=9YTECIa$JM&JbS><`uUg zii+{`DsTbg71;nVI4VIIVjz+kV)({r=jPyL>uY*ylI6&4tq_C$QZ$^#vNZOU?q^v# z_IQuNJqg<$Wq94Dxzi((wTR0c!`&)DXd+1o0=kzmaab8{U}0%peWbN>ASt2_bEYR} z(sZ|GhBAE!CM_wrm@{$y9Ckk+N@iA5D8J9FShcEbt8Lv=@^JBT#O=XDPw4PtDblr_ z$@mrgqvYl5H*W;Sr)rXoz0uWyDU3mgYhLNzB{VRVEsGkgU96XAr=esjxkXk&#%Cvu zNwUuc)0Gh97-FK{O+X{;Ek{ddjNgEQ6%SpA5Auxor$q33hlEIc6A~s2!k3`+q_#4i ztA$ooos|NeEOK17mObsqAiNiiihGAJwC;lCD5K_w3!b7CZyZBiSj|q4!kW^G(acOi zy+vU8I=of26!66BYh;GL9OO}g#JJ@e5h&~xkn5WL~TJPMwOK5tM^Q_a6!-t~|-&wzMdD_&1J)Sp8 zU}TCImdI9yp-&v54a0upUot$4P%8_SIzCCSc0& zDMvjawGMI8+L#l}%6WFO(Z1{Dd(v;;y?<}~_K$T$!>gmljHKY9@$>K;CtDwXQ~^Ys z9t@fF`e#l@RG+n5_Z#5Jt4gle>YPA9BBmi`1Y^&(I$_kHrIT3bOwwad&>Gvi zcqdu{%;tzzCZbETXUkAZbF{}HCV-&+lnnl!p$iR0R zjiVgZ8I-8~tdDpjGrhAjr!n~|?};@;ndMHOK~_i=jX}h+<%G6xizP?Bx6RKF>!b!g zaG6eK+V%#whMh{Yxumae3|Ub<+g?;ydr_Ws8@fbCLv|)%;`uk0b)pp{g;Rn|lhcC#pCKjX3W07^U zO$vf&8;^)=i)w0zg5m9Dd9MV?8WE#%9!G3=stMp&{1OgL9jo-zY>b3k7gs+1oL;~q zEUfhL<43whWimi8?}zmZD1Dnf?LD%@-*97BUHD$|j)B3>;PTY(t$lIf2DH(LruUwi z!`rfFCOTC$S@BH=26}u~jF`x--meRrsTw;XmGm z7X^jyILV#!S}JQS1Iii^kihW!?X9 znNI&xz>jl{k1_9WV-tX`iXtDh+0DaE*gIMr@+Ak?Q8ad@nECpP6-zPG#3uv9iVa&a zce?2^su`Qqod%=cw_!sODhZ$9tpm@B@jKvFd9$osqNahiJQ?z#N5v1BG;BE|VLudQ zc?|{=K^C+yBC}zS-?JTFr|C>bVWqTB%AA9)mlf!0inv93Mk;KpvX%5cW#+fg4L#u2}oc!_(hp6&M1|3*z|96}pFA9V#9aDF z*D!YsA_W7VUDWM!u&6@P01gCZIL-O6w8KEVQ!@ zGM$j%Bb0=wZ6v1ydF_2Nny}s%zo%q(K~wG50fQqz`2>2g5oS4jz7HxJQI7+vtwp6(FMS(lo_)SHpouQ7$*~O3 z>BqGJ$yF_K<5(*_N za!#$Ij>aby+#Ae|kh^o|P6-l=8Y5t(6_3S8SOKmH+~dBOTZI_qPDqzvivNNbhjx>b& zdT=JQZu;v%!(5#Fh%I8##nuxUpUr;t3=5kAo4oeZ#2@f z2j+$$?6#VDmK(<3A%rKLpq!|8GCVR8@zHjO&|je&$CD*M>Wat+N$_o^Vo<%?v^5n3 z{r6pYhKhdFS$_g@VMlFhf|m2Nb;8Cu!6crCmB=0ly=Vp(ry7*(kVhs;hLBl0$s=}R6YVyv8XwSOuK%oI|E!)FCZ+!av@TxON1s&7gflK9{M z$Cn=F__jk(P@b@{zbt81)+hj=Il*)#`ypi0DVyv)z7;?cK}Vv8p%uR(i43#8d&|Ti zTg@3w-*0pBA-4rtmLh-tzX*`qdCa}9ZG&Cp93wsePo4xROzW!V6@>Z3##dPXYi}O{ z0QTYrIDa_rg8yqk<-gYSNZMfaYGnxa^MXczP{CNna^^tnKj>M!pq;P{a;VEFE(hKI zN^d}$v;v5sDMBGro0DG03T^~Ef4+-wv$BYjI*>73wEz342zblBRGZe*gun2w&0Y=t_Y^ z1vk$QMLq;`1^G)zUB6}4_sq%Ff`2bRchZGQGptKryTNBv?Ej(ITBP`B$9l2q1(bn< zf_xO>q9fv;r2BbOMcg?Cqgi7Vh=ooMyT_(E>baF)^fFI)glw|W__IC0VDIH?M6oBi z2wJu(J1Iu|WSAD8d7oaYDR9R^!^p0;J(W3voK3h;dALW%}ke4Lq- zj4$vr#)8!B)F5P&Q#nC90k|>8k5%X(@x@b2>pLoK5PzKu z7@B|keYmIo97NI*Ow)nzct8)h<@-1zBO_;0Ak_V^#s{AC;+MtqnFFl3A=+#2E9XTz+Mv|d5fq~`Nr%5(^Qfj zr-uQv@FI)cX}y3V&$`Yd>k=ezf)p#`&P9?$KejR5s_)wYP?WOpZcr&mK3u+zAapi% z4j23g1!!=ZH1X^py%0j*idJaYRv0z;p*oto_Ez%W?)L{~{@nJ9rMt(M^n1C2>6O>M zQ@*Jm6C9vt_GHLGeUVR!CLH?r7X zexBrN`&bekFf}dto-SpRp@oxBftZq-lqx z`+c8?)A~yumYS)%$)r%!? zmI3;+IA`uqsT`3;UcY`#wF|!MxyUxzh}Owyo!WJ_FE_a~!|LN^>CnjKlm{%X4?VMx zGyrLPNYX@bAv-HnwN>C!I%@ia1#-L?6gJj2mU9i%Pi)q(RIZ}N<6)RC=Hjf*zLu)x z(0^nas4nL0%V)t312m+;zA$uYpVZce$@x-qsBkkDq8uI)$r99?e1W3ja(*#Ve@OMw z6wS^1v>SMrAxHV6Cd*~<_$Sj;esOU%6myXaIBPT@W zLtLQ}7?^*?JpU2m`lsX?J#3(PmeKOsvcT)2xfD4S47MZkl9fa**UkB^AIkuG{0E%)n`mGUB8-0pdj3Bna(>Ff6(!TB!C~+u zO)=ML8mPBxKF0|+SEvB;F=Blri}`;orA}fsVxUcP-sTJLKSJgm2^`{rrZu0E{Jv!_ zs!7@kcQmBOd1G$wZQ3Be&j&I8c?HhnCjSLx{dr3yx%_WQ%761l5kOUi=E{x5Bm5gN z(YdnSD(z79U){|I;_x`kKgz!~U`fgq=`L;>xZFSA3p}3x>Rt}Tryb#>eDgfJ{%!FK zQbYgCL%xJ~Jzrnhv zPFz3p!Gi}2qt{U4RlyY>73vLIZ%$iH0F=|rxIP&XfGjTB7dA&2FU$W>Oft>V4r2nd z!}Q?b_>~*^h{?zJqTOQrQm?({d4T__qU5uq$!8P2a;?jBth&$h6c!WcfCGxY_0oIx z4ERrQ23VO??$QjfRg9wgRmfZeFH5!vqOmt2TLvh_Q&G!+Z&Z4!jOakoL9G z;idD;U5Uh(&6YQXy5@`%rPC3ay0TcWhq5rqwI4Rxz{+Z%W!Jnh5d&^;YOpu}M-K*J zvPsl>Y?Y`yeB{XEC95|1L0+sxHuR%%jPl1oscR`;D;+z^c_GvqqqndRLbCURChZUV znY=l3jlaOq$DJX>3GxHae2js>+~GgkRjmWTj=c+#EKsok1JQUKTinxv5os;$j5{VL5TvL2-W)tYIu$hzqgxP1lSb9=rGNCyFs_KvMf9kU-H9A=kr|;YNm2e zcbhqv5rYM%nvN8(B6xTL7a0oF)AY#S@yZG9z(b$LGkIu;Y^8PRH0u{)nU#R(>!jt< zoN)b?BqsrFL33h3@6yKUY)<>R3T|v zw{OXkC5Cw}3sg0A4wO4gja?z&3@)circL+II~MIW9H^~?uMrA&kGUpeJ2_<(qm~%) z$yXo&&{$}DF*VrFJEcQQ;*o4t&s)qEfO77>F7Bs~YX+8pEQt1SwOeGb~n84HVn z3ZFj??)t!3LdiLwT1&FAn{~+f1a03(1hSFCocKl`(hbFZ-+ebfPKS^C91^-59jB&Z z;e5^+YtSkMK4*rJ1S0f_60&%x58|PdXdck=F{T6319YVFXCM(l1R8&SukfHr>i7mf&

TjfPZ3H32UC zo}5{VY9s*?lH~48$c-oP9t%jaY{Vfp0O631u4Z|^tIcuNK)4+K8LC!3y&(A(32?@M2JpGZQ?L3Q@A7!NDp^ziW0FKr@Fm}~5tfEOiywez; zJ4&_aIM?~(vNqD12!4cfTUAbN5<&UrO7_g;kaNL)K?K0XAK z&o#ecI5_l+t;|D)<0Qrs?c_;O37am#*|GOBCm?!?L%kO&@PkZMC5e1{(Fk0%y;u=F ztfd~Nf*vS!dP6+t)~zN;p&R5(_DGaLOLa)sYz(m0*VFR{&VLNoJOFR#4<~4!^PW9> zR_Yd}_m5~Ajw=lA3~{&!0l5&?jWLdSnxKbWLddod1-8n%9%f1e&PVD&L}@_+dV$5ToVBkK#^Uvq{UEN&Tr z$tKhzn<>4{W9ltx`vh>oNi4EqUD`_=%QXuuhR))L7Re z?(%sM$JADHO4oV8o4I-GmOqI@;hb`;JR=)%Z7yC$2qKlJP0Ob4^IqDbxiHEifVy|= z+VurlrT4Jl^I}C?kJaNCgAlS@5gO?h-MGVP%amFSIMC;vI1bQ6mp`fS$0^nceaHiO< zXOYY6n;cveXACPF62K?Fh@e<{@&q~h34B=bQs)>#RNz|K(l|*s?oW>Jm8PTQh$mESzYLphe`hm3N=VZdE(%8`Dw}ke^lkyzWynvEd;rdMAE)D{>P89! z#gzcFp-BQEKjJ27VXPwg9RXNo9124=i5#c{l;*eBggPv0H*g6Ob_cf08H`Ahg&A%y zJ4WUyLYlGY-%)c>LENf@^KBduh{bti`|)PqpveX(MZ^Rk-%BQSLXIzG&u{)LdlY0Zt zk>Juz*W%8x?bUK!XC8!K($QCiq&pnN?Vj4skiSURCI?-wQFrVpNY_LWdup+O1P%n^ zzTbR*!0mSX_N=Z6u^)j4TSqkTf&$~}6b6-Cp#u(>kT(^D-Q?-1fZ8lX;)39eOP4O? z9`c&ps!hAhIdtY& z6M$Jee#wI>wlwkRN&Vp9gL6fq{%Ku({cBSai+JjwuFsSb2@)fZ4@YvbgUj&8A$WTR z-(R~?8GRbjI1kc>!AVNhx>#y73Ym9%cnKg=>2f2B?Itqr68V^<%*pwuc2WXh07H0H zSvsC~B>9aR5)$WNjVU-dWC2l!!QE;N^P$Ac%xezlP;LumyTEMzuOqI1*USDPY7ERS Zxcq$WP`83NvLqA=?Z~Oa@dwYl{y)t6_5}a{ diff --git a/docs/source/digits_perf.png b/docs/source/digits_perf.png new file mode 100644 index 0000000000000000000000000000000000000000..08ce001ff0312fddcee26b7fa582e5bc936811f2 GIT binary patch literal 20400 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 from sklearn.svm import LinearSVC >>> from sklearn.naive_bayes import GaussianNB @@ -49,45 +49,52 @@ Once the predictions are available, it is time to measure the algorithm's perfor >>> score = f1_score(y_val, hy, average='macro') >>> score - -Statistic with its standard error (se) -statistic (se) -0.9332 (0.0113) <= alg-1 + -The previous code shows the macro-f1 score and, in parenthesis, its standard error. The actual performance value is stored in the :py:func:`~CompStats.interface.Perf.statistic` function. +The previous code shows the macro-f1 score and, in parenthesis, its standard error. The actual performance value is stored in the attributes :py:func:`~CompStats.interface.Perf.statistic` and :py:func:`~CompStats.interface.Perf.se` ->>> score.statistic -{'alg-1': 0.9332035615949114} +>>> score.statistic, score.se +(0.9521479775366307, 0.009717884979482313) Continuing with the example, let us assume that one wants to test another classifier on the same problem, in this case, a random forest, as can be seen in the following two lines. The second line predicts the validation set and sets it to the analysis. >>> ens = RandomForestClassifier().fit(X_train, y_train) >>> score(ens.predict(X_val), name='Random Forest') - + Statistic with its standard error (se) statistic (se) -0.9756 (0.0061) <= Random Forest -0.9332 (0.0113) <= alg-1 +0.9720 (0.0076) <= Random Forest +0.9521 (0.0097) <= alg-1 -Let us incorporate another prediction, now with the Naive Bayes classifier, as seen below. +Let us incorporate another predictions, now with Naive Bayes classifier, and Histogram Gradient Boosting as seen below. >>> nb = GaussianNB().fit(X_train, y_train) >>> score(nb.predict(X_val), name='Naive Bayes') - +>>> hist = HistGradientBoostingClassifier().fit(X_train, y_train) +>>> score(hist.predict(X_val), name='Hist. Grad. Boost. Tree') + Statistic with its standard error (se) statistic (se) -0.9756 (0.0061) <= Random Forest -0.9332 (0.0113) <= alg-1 -0.8198 (0.0144) <= Naive Bayes +0.9759 (0.0068) <= Hist. Grad. Boost. Tree +0.9720 (0.0076) <= Random Forest +0.9521 (0.0097) <= alg-1 +0.8266 (0.0159) <= Naive Bayes + +The performance, its confidence interval (5%), and a statistical comparison (5%) between the best performing system with the rest of the algorithms is depicted in the following figure. + +>>> score.plot() + +.. image:: digits_perf.png -The final step is to compare the performance of the three classifiers, which can be done with the :py:func:`~CompStats.interface.Perf.difference` method, as seen next. +The final step is to compare the performance of the four classifiers, which can be done with the :py:func:`~CompStats.interface.Perf.difference` method, as seen next. >>> diff = score.difference() >>> diff -difference p-values w.r.t Random Forest -0.0000 <= alg-1 +difference p-values w.r.t Hist. Grad. Boost. Tree 0.0000 <= Naive Bayes +0.0100 <= alg-1 +0.3240 <= Random Forest The class :py:class:`~CompStats.Difference` has the :py:class:`~CompStats.Difference.plot` method that can be used to depict the difference with respectto the best. From 2bf538bf508b2a6f367b7856925bae9c83a53432 Mon Sep 17 00:00:00 2001 From: Mario Graff Date: Fri, 28 Feb 2025 18:18:04 +0000 Subject: [PATCH 4/4] missing image --- README.rst | 2 ++ 1 file changed, 2 insertions(+) diff --git a/README.rst b/README.rst index f71d132..4ac5f92 100644 --- a/README.rst +++ b/README.rst @@ -82,6 +82,8 @@ The performance, its confidence interval (5%), and a statistical comparison (5%) >>> score.plot() +.. image:: https://github.com/INGEOTEC/CompStats/raw/docs/docs/source/digits_perf.png + The final step is to compare the performance of the four classifiers, which can be done with the `difference` method, as seen next. >>> diff = score.difference()