diff --git a/CompStats/__init__.py b/CompStats/__init__.py index fbebf90..2e65c6d 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.6' +__version__ = '0.1.7' 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/bootstrap.py b/CompStats/bootstrap.py index 6b6968e..22b1994 100644 --- a/CompStats/bootstrap.py +++ b/CompStats/bootstrap.py @@ -142,6 +142,10 @@ def inner(N): return inner(N) except AttributeError: return inner(N) + + def keys(self): + """calls keys""" + return self.calls.keys() def __getitem__(self, key): return self.calls[key] diff --git a/CompStats/interface.py b/CompStats/interface.py index 6f07c67..6e0b8b4 100644 --- a/CompStats/interface.py +++ b/CompStats/interface.py @@ -18,8 +18,10 @@ import numpy as np from CompStats.bootstrap import StatisticSamples 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 class Perf(object): @@ -239,6 +241,13 @@ def best(self): """System with best performance""" if hasattr(self, '_best') and self._best is not None: return self._best + if not isinstance(self.statistic, dict): + key, value = list(self.statistic_samples.calls.items())[0] + if value.ndim == 1: + self._best = key + else: + self._best = np.array([key] * value.shape[1]) + return self._best BiB = True if self.statistic_samples.BiB else False keys = np.array(list(self.statistic.keys())) data = np.asanyarray([self.statistic[k] @@ -322,7 +331,14 @@ def se(self): return list(output.values())[0] return output - def plot(self, **kwargs): + def plot(self, value_name:str=None, + var_name:str='Performance', + alg_legend:str='Algorithm', + perf_names:list=None, + CI:float=0.05, + kind:str='point', linestyle:str='none', + col_wrap:int=3, capsize:float=0.2, + **kwargs): """plot with seaborn >>> from sklearn.svm import LinearSVC @@ -341,13 +357,37 @@ def plot(self, **kwargs): forest=ens.predict(X_val)) >>> perf.plot() """ + import seaborn as sns if self.score_func is not None: value_name = 'Score' else: value_name = 'Error' - _ = dict(value_name=value_name) - _.update(kwargs) - return plot_performance(self.statistic_samples, **_) + df = self.dataframe(value_name=value_name, var_name=var_name, + alg_legend=alg_legend, perf_names=perf_names) + if var_name not in df.columns: + var_name = None + col_wrap = None + ci = lambda x: measurements.CI(x, alpha=CI) + 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', + var_name:str='Performance', + alg_legend:str='Algorithm', + 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) @property def n_jobs(self): @@ -561,7 +601,28 @@ def p_value(self, right:bool=True): values.sort(key=lambda x: self.sorting_func(x[1])) return dict(values) - def plot(self, **kwargs): + def dataframe(self, value_name:str='Score', + var_name:str='Best', + alg_legend:str='Algorithm', + perf_names:str=None): + """Dataframe""" + if perf_names is None and isinstance(self.best, np.ndarray): + perf_names = [f'{alg}({k})' + for k, alg in enumerate(self.best)] + return dataframe(self, value_name=value_name, + var_name=var_name, + alg_legend=alg_legend, + perf_names=perf_names) + + def plot(self, value_name:str='Difference', + var_name:str='Best', + alg_legend:str='Algorithm', + perf_names:list=None, + CI:float=0.05, + kind:str='point', linestyle:str='none', + col_wrap:int=3, capsize:float=0.2, + set_refline:bool=True, + **kwargs): """Plot >>> from sklearn.svm import LinearSVC @@ -580,5 +641,21 @@ def plot(self, **kwargs): >>> diff = perf.difference() >>> diff.plot() """ - - return plot_difference(self.statistic_samples, **kwargs) + import seaborn as sns + df = self.dataframe(value_name=value_name, + var_name=var_name, + alg_legend=alg_legend, perf_names=perf_names) + title = var_name + if var_name not in df.columns: + var_name = None + col_wrap = None + ci = lambda x: measurements.CI(x, alpha=CI) + 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) + if set_refline: + f_grid.refline(x=0) + if isinstance(self.best, str): + f_grid.facet_axis(0, 0).set_title(f'{title} = {self.best}') + return f_grid diff --git a/CompStats/tests/test_interface.py b/CompStats/tests/test_interface.py index 6591aa4..feebee9 100644 --- a/CompStats/tests/test_interface.py +++ b/CompStats/tests/test_interface.py @@ -23,6 +23,79 @@ from CompStats.tests.test_performance import DATA +def test_Difference_dataframe(): + """Test Difference dataframe""" + from CompStats.metrics import f1_score + + X, y = load_digits(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)) + diff = score.difference() + df = diff.dataframe() + assert 'Best' in df.columns + score = f1_score(y_val, ens.predict(X_val), + average='macro', + num_samples=50) + score(nb.predict(X_val)) + score(svm.predict(X_val)) + diff = score.difference() + df = diff.dataframe() + assert 'Best' not in df.columns + + +def test_Perf_dataframe(): + """Test Perf dataframe""" + from CompStats.metrics import f1_score + + X, y = load_digits(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) + df = score.dataframe() + score(nb.predict(X_val)) + score(svm.predict(X_val)) + df = score.dataframe() + assert 'Performance' in df.columns + score = f1_score(y_val, ens.predict(X_val), + average='macro', + num_samples=50) + score(nb.predict(X_val)) + score(svm.predict(X_val)) + df = score.dataframe() + assert 'Performance' not in df.columns + + +def test_Perf_plot_multi(): + """Test Perf plot multiple""" + from CompStats.metrics import f1_score + + X, y = load_digits(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)) + f_grid = score.plot() + assert f_grid is not None + def test_Perf_statistic_one(): """Test Perf statistic one alg""" from CompStats.metrics import f1_score @@ -208,7 +281,7 @@ def test_Difference_plot(): diff.plot() -def test_Perf_dataframe(): +def test_Perf_input_dataframe(): """Test Perf with dataframe""" from CompStats.interface import Perf diff --git a/CompStats/utils.py b/CompStats/utils.py index c40edd7..0eac043 100644 --- a/CompStats/utils.py +++ b/CompStats/utils.py @@ -54,4 +54,29 @@ def inner(*args, **kwargs): return func(*args, **kwargs) return inner - return perf_docs \ No newline at end of file + return perf_docs + + +def dataframe(instance, value_name:str='Score', + var_name:str='Performance', + alg_legend:str='Algorithm', + perf_names:list=None): + """Dataframe""" + import pandas as pd + if isinstance(instance.best, str): + df = pd.DataFrame(dict(instance.statistic_samples.calls.items())) + return df.melt(var_name=alg_legend, + value_name=value_name) + df = pd.DataFrame() + if not isinstance(instance.statistic, dict): + iter = instance.statistic_samples.keys() + else: + iter = instance.statistic + for key in iter: + data = instance.statistic_samples[key] + _df = pd.DataFrame(data, + columns=perf_names).melt(value_name=value_name, + var_name=var_name) + _df[alg_legend] = key + df = pd.concat((df, _df)) + return df \ No newline at end of file diff --git a/README.rst b/README.rst index a5bc0d8..7e124c8 100644 --- a/README.rst +++ b/README.rst @@ -49,15 +49,12 @@ 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 `statistic` function. >>> score.statistic -{'alg-1': 0.9332035615949114} +0.9434834454375508 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. @@ -66,8 +63,8 @@ Continuing with the example, let us assume that one wants to test another classi Statistic with its standard error (se) statistic (se) -0.9756 (0.0061) <= Random Forest -0.9332 (0.0113) <= alg-1 +0.9655 (0.0077) <= Random Forest +0.9435 (0.0099) <= alg-1 Let us incorporate another prediction, now with the Naive Bayes classifier, as seen below. @@ -76,18 +73,18 @@ Let us incorporate another prediction, now with the Naive Bayes classifier, as s 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.9655 (0.0077) <= Random Forest +0.9435 (0.0099) <= alg-1 +0.8549 (0.0153) <= 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. >>> diff = score.difference() >>> diff -difference p-values w.r.t Random Forest -0.0000 <= alg-1 +difference p-values w.r.t Random Forest 0.0000 <= Naive Bayes +0.0120 <= alg-1 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 ad74cbb..2527d84 100644 --- a/docs/CompStats_metrics.ipynb +++ b/docs/CompStats_metrics.ipynb @@ -54,7 +54,7 @@ "colab": { "base_uri": "https://localhost:8080/" }, - "outputId": "f9fcdc39-dd55-4fb5-f296-8e16542da8ee" + "outputId": "b37f28d5-90d9-4d94-c28c-27f9054f1a23" }, "outputs": [ { @@ -62,41 +62,41 @@ "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-0jzcmk2h\n", - " Running command git clone --filter=blob:none --quiet https://github.com/INGEOTEC/CompStats /tmp/pip-req-build-0jzcmk2h\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 ee9d6cd168b6c944722150afd5d6277ef60f8dd6\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.6) (1.26.4)\n", - "Requirement already satisfied: scikit-learn>=1.3.0 in /usr/local/lib/python3.11/dist-packages (from CompStats==0.1.6) (1.6.1)\n", - "Requirement already satisfied: pandas in /usr/local/lib/python3.11/dist-packages (from CompStats==0.1.6) (2.2.2)\n", - "Requirement already satisfied: seaborn>=0.13.0 in /usr/local/lib/python3.11/dist-packages (from CompStats==0.1.6) (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.6) (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.6) (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.6) (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.6) (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.6) (2.8.2)\n", - "Requirement already satisfied: pytz>=2020.1 in /usr/local/lib/python3.11/dist-packages (from pandas->CompStats==0.1.6) (2025.1)\n", - "Requirement already satisfied: tzdata>=2022.7 in /usr/local/lib/python3.11/dist-packages (from pandas->CompStats==0.1.6) (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.6) (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.6) (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.6) (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.6) (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.6) (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.6) (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.6) (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.6) (1.17.0)\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.6-py3-none-any.whl size=39606 sha256=9b0e0dcda958e7607006de68d599ef7ffbf692e8bf78c5da32dbf19cdacb2bab\n", - " Stored in directory: /tmp/pip-ephem-wheel-cache-auggsg4k/wheels/4f/d2/a1/8d1d30289bd99417ea947fc1e1f4587404d4e3a043b41f0289\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.6\n" + "Successfully installed CompStats-0.1.7\n" ] } ], @@ -142,7 +142,7 @@ "metadata": { "id": "jEpd52Kq214r" }, - "execution_count": 4, + "execution_count": 2, "outputs": [] }, { @@ -166,7 +166,7 @@ "metadata": { "id": "JGJczaOW3WeK" }, - "execution_count": 5, + "execution_count": 3, "outputs": [] }, { @@ -189,29 +189,26 @@ "base_uri": "https://localhost:8080/" }, "id": "Al0u9ZPB3cSj", - "outputId": "51c345bd-bb03-4469-f4f6-ed6399569539" + "outputId": "33d3dc5e-d7c7-4a2e-a3af-284a99935733" }, - "execution_count": 6, + "execution_count": 4, "outputs": [ { "output_type": "stream", "name": "stderr", "text": [ - "100%|██████████| 1/1 [00:11<00:00, 11.50s/it]\n" + "100%|██████████| 1/1 [00:05<00:00, 5.46s/it]\n" ] }, { "output_type": "execute_result", "data": { "text/plain": [ - "\n", - "Statistic with its standard error (se)\n", - "statistic (se)\n", - "0.9332 (0.0113) <= alg-1" + "" ] }, "metadata": {}, - "execution_count": 6 + "execution_count": 4 } ] }, @@ -234,19 +231,19 @@ "base_uri": "https://localhost:8080/" }, "id": "Ye1HH4pn3jde", - "outputId": "501c48e9-86fa-4095-85d8-9e68c8ebf39d" + "outputId": "a0f19b8f-eeb4-46ba-d0a1-8f3d59b67527" }, - "execution_count": 7, + "execution_count": 5, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ - "{'alg-1': 0.9332035615949114}" + "0.9434834454375508" ] }, "metadata": {}, - "execution_count": 7 + "execution_count": 5 } ] }, @@ -270,15 +267,15 @@ "base_uri": "https://localhost:8080/" }, "id": "vboh7N9B3pDr", - "outputId": "d7449f7e-d9c1-43aa-abe0-826806df4281" + "outputId": "980e3a62-1577-425d-ed59-69fbb93c4945" }, - "execution_count": 8, + "execution_count": 6, "outputs": [ { "output_type": "stream", "name": "stderr", "text": [ - "100%|██████████| 1/1 [00:01<00:00, 1.86s/it]\n" + "100%|██████████| 1/1 [00:01<00:00, 1.04s/it]\n" ] }, { @@ -288,12 +285,12 @@ "\n", "Statistic with its standard error (se)\n", "statistic (se)\n", - "0.9756 (0.0061) <= Random Forest\n", - "0.9332 (0.0113) <= alg-1" + "0.9655 (0.0077) <= Random Forest\n", + "0.9435 (0.0099) <= alg-1" ] }, "metadata": {}, - "execution_count": 8 + "execution_count": 6 } ] }, @@ -317,15 +314,15 @@ "base_uri": "https://localhost:8080/" }, "id": "pVOaQb0T3tyN", - "outputId": "15fbb215-d4e7-49c4-e56c-275aa1d59c1e" + "outputId": "258373fc-4afb-4442-9e5f-e9fb75d743ef" }, - "execution_count": 9, + "execution_count": 7, "outputs": [ { "output_type": "stream", "name": "stderr", "text": [ - "100%|██████████| 1/1 [00:02<00:00, 2.00s/it]\n" + "100%|██████████| 1/1 [00:01<00:00, 1.48s/it]\n" ] }, { @@ -335,13 +332,13 @@ "\n", "Statistic with its standard error (se)\n", "statistic (se)\n", - "0.9756 (0.0061) <= Random Forest\n", - "0.9332 (0.0113) <= alg-1\n", - "0.8198 (0.0144) <= Naive Bayes" + "0.9655 (0.0077) <= Random Forest\n", + "0.9435 (0.0099) <= alg-1\n", + "0.8549 (0.0153) <= Naive Bayes" ] }, "metadata": {}, - "execution_count": 9 + "execution_count": 7 } ] }, @@ -365,22 +362,22 @@ "base_uri": "https://localhost:8080/" }, "id": "XWAqUpYE3za2", - "outputId": "d92c436a-6aa9-41f3-cb9d-582ba2068b98" + "outputId": "3f108864-6a1f-41bf-dda3-ccab294444e5" }, - "execution_count": 10, + "execution_count": 8, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "\n", - "difference p-values w.r.t Random Forest\n", - "0.0000 <= alg-1\n", - "0.0000 <= Naive Bayes" + "difference p-values w.r.t Random Forest\n", + "0.0000 <= Naive Bayes\n", + "0.0120 <= alg-1" ] }, "metadata": {}, - "execution_count": 10 + "execution_count": 8 } ] }, @@ -401,22 +398,22 @@ "metadata": { "colab": { "base_uri": "https://localhost:8080/", - "height": 547 + "height": 546 }, "id": "Fai01O3q3-SN", - "outputId": "e7e89ba8-ab89-4ab7-d518-ae284dca35d3" + "outputId": "eae94c83-bac5-473d-b708-23f549b27b07" }, - "execution_count": 11, + "execution_count": 9, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ - "" + "" ] }, "metadata": {}, - "execution_count": 11 + "execution_count": 9 }, { "output_type": "display_data", @@ -424,20 +421,11 @@ "text/plain": [ "
" ], - "image/png": "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\n" + "image/png": "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\n" }, "metadata": {} } ] - }, - { - "cell_type": "code", - "source": [], - "metadata": { - "id": "ol6Yo4k_4FdR" - }, - "execution_count": 11, - "outputs": [] } ] } \ No newline at end of file diff --git a/docs/source/digits_difference.png b/docs/source/digits_difference.png index f0c40d8..608e0b6 100644 Binary files a/docs/source/digits_difference.png and b/docs/source/digits_difference.png differ