diff --git a/.github/workflows/pip.yaml b/.github/workflows/pip.yaml deleted file mode 100644 index e4b58a7..0000000 --- a/.github/workflows/pip.yaml +++ /dev/null @@ -1,48 +0,0 @@ -name: Pip - -on: - workflow_dispatch: - push: - tags: - - v* - -jobs: - build: - runs-on: ${{ matrix.os }} - defaults: - run: - shell: bash -l {0} - strategy: - matrix: - os: [ubuntu-latest, windows-latest] - python-version: ["3.9", "3.10", "3.11"] - steps: - - uses: actions/checkout@v2 - - name: Set up Python - uses: conda-incubator/setup-miniconda@v3 - with: - activate-environment: test - auto-update-conda: true - python-version: ${{ matrix.python-version }} - channels: conda-forge - allow-softlinks: true - channel-priority: flexible - show-channel-urls: true - - name: Install dependencies - run: | - conda install --yes pip - pip install twine build - conda install --yes numpy scipy scikit-learn nose pandas seaborn - python -m build - - name: Pip - if: ${{ runner.os == 'Linux' }} - env: - TWINE: ${{ secrets.TWINE }} - run: | - twine upload --skip-existing -u __token__ -p $TWINE dist/*.tar.gz; - - name: Wheel - if: ${{ runner.os != 'Linux' }} - env: - TWINE: ${{ secrets.TWINE }} - run: | - twine upload --skip-existing -u __token__ -p $TWINE dist/*.whl; diff --git a/.github/workflows/publish-pypi.yml b/.github/workflows/publish-pypi.yml new file mode 100644 index 0000000..460a043 --- /dev/null +++ b/.github/workflows/publish-pypi.yml @@ -0,0 +1,56 @@ +name: Publish to PyPI + +on: + push: + tags: + - "v*" + workflow_dispatch: + +concurrency: + group: publish-${{ github.ref_name }} + cancel-in-progress: false + +jobs: + publish: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + + - uses: actions/setup-python@v5 + with: + python-version: "3.12" + + - name: Install version-check dependencies + if: github.event_name != 'workflow_dispatch' + run: pip install packaging + + # Tags are the release trigger, so a stale tag (forgot to bump + # __version__) must fail loudly instead of publishing the wrong + # version. `version` is declared `dynamic` in pyproject.toml, so it is + # read the same way scripts/check_package_versions.py reads it. + - name: Verify tag matches the package version + if: github.event_name != 'workflow_dispatch' + run: | + tag_version="${GITHUB_REF_NAME#v}" + pkg_version=$(python -c "import sys; sys.path.insert(0, 'scripts'); from check_package_versions import local_version; print(local_version())") + if [ "$tag_version" != "$pkg_version" ]; then + echo "Tag version $tag_version does not match CompStats.__version__ $pkg_version" >&2 + exit 1 + fi + + - name: Install build tooling + run: pip install build twine + + # CompStats is pure Python: one sdist and one universal wheel, built once. + - name: Build sdist and wheel + run: python -m build + + - name: Check package metadata + run: twine check dist/* + + # `TWINE` is a repository secret holding a PyPI API token. + - name: Upload to PyPI + env: + TWINE_USERNAME: __token__ + TWINE_PASSWORD: ${{ secrets.TWINE }} + run: twine upload dist/* diff --git a/.github/workflows/publish.yml b/.github/workflows/publish.yml deleted file mode 100644 index d321c1b..0000000 --- a/.github/workflows/publish.yml +++ /dev/null @@ -1,42 +0,0 @@ -on: - workflow_dispatch: - -name: Quarto Publish - -jobs: - build-deploy: - runs-on: ubuntu-latest - defaults: - run: - shell: bash -el {0} - permissions: - contents: write - steps: - - name: Check out repository - uses: actions/checkout@v3 - - name: Set up Quarto - uses: quarto-dev/quarto-actions/setup@v2 - with: - tinytex: true - # version: "pre-release" - - name: Set up Python - uses: conda-incubator/setup-miniconda@v3 - with: - activate-environment: test - auto-update-conda: true - python-version: "3.10" - channels: conda-forge - allow-softlinks: true - channel-priority: flexible - show-channel-urls: true - - name: Install dependencies - run: | - conda install --yes -c numpy scipy scikit-learn statsmodels pandas seaborn jupyter tabulate - - name: Render and Publish - run: | - git config --global user.email "mgraffg@ieee.org" - git config --global user.name "mgraffg" - cd quarto - quarto publish gh-pages CompStats.qmd --no-browser - env: - GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} \ No newline at end of file diff --git a/.github/workflows/test.yaml b/.github/workflows/test.yaml deleted file mode 100644 index 6ccc466..0000000 --- a/.github/workflows/test.yaml +++ /dev/null @@ -1,53 +0,0 @@ -name: Tests - -on: - push: - branches: - - develop - -jobs: - build: - runs-on: ${{ matrix.os }} - defaults: - run: - shell: bash -l {0} - strategy: - matrix: - os: [ubuntu-latest, windows-latest] - python-version: ["3.9", "3.10", "3.11"] - steps: - - uses: actions/checkout@v2 - - name: Set up Python - uses: conda-incubator/setup-miniconda@v3 - with: - activate-environment: test - auto-update-conda: true - python-version: ${{ matrix.python-version }} - channels: conda-forge - allow-softlinks: true - channel-priority: flexible - show-channel-urls: true - - name: Install dependencies - run: | - conda install --yes pip - pip install coverage - pip install coveralls - conda install --yes numpy scipy scikit-learn nose pandas seaborn - python setup.py build_ext --inplace - - name: Tests on Linux - if: ${{ runner.os == 'Linux' }} - run: | - which python - python --version - which coverage - nosetests --verbose --with-coverage --cover-package=CompStats CompStats/tests - - name: Tests on macOS and Windows - if: ${{ runner.os != 'Linux' }} - run: | - nosetests --verbose CompStats/tests - - name: coveralls - if: ${{ runner.os == 'Linux' }} - env: - GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} - run: | - coveralls --service=github \ No newline at end of file diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml new file mode 100644 index 0000000..7ebd846 --- /dev/null +++ b/.github/workflows/test.yml @@ -0,0 +1,81 @@ +name: test + +on: + push: + branches: [main, develop] + pull_request: + +env: + # The suite draws seaborn figures; the runner has no display. + MPLBACKEND: Agg + +jobs: + # The whole suite: no test touches the network. + test: + runs-on: ubuntu-latest + strategy: + fail-fast: false + matrix: + python-version: ["3.10", "3.11", "3.12"] + steps: + - uses: actions/checkout@v4 + - uses: actions/setup-python@v5 + with: + python-version: ${{ matrix.python-version }} + - name: Install package and test dependencies + run: pip install -e ".[test]" + - name: Run tests + run: pytest CompStats + + # Coverage is collected once (not per matrix cell) and sent to Coveralls, + # which the README badge reads. `.coveragerc` omits the tests package. + coverage: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + - uses: actions/setup-python@v5 + with: + python-version: "3.12" + - name: Install package, test and coverage dependencies + run: | + pip install -e ".[test]" + pip install coverage coveralls + - name: Run tests with coverage + run: coverage run -m pytest CompStats + - name: Report + run: coverage report + - name: Coveralls + env: + GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} + run: coveralls --service=github + + # Hard gate on the single-step-ahead rule: __version__ may not be behind, + # equal to, or more than one release past what is published on PyPI. + check-package-versions: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + - uses: actions/setup-python@v5 + with: + python-version: "3.12" + - name: Install checker dependencies + run: pip install packaging + - name: Check package versions against PyPI + run: python scripts/check_package_versions.py + + # Sphinx gate: a strict HTML build of the developer reference. Any broken + # cross-reference or other warning fails it. The docstring examples are not + # run (their outputs depend on random bootstrap samples). + docs: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + - uses: actions/setup-python@v5 + with: + python-version: "3.12" + - name: Install docs and package dependencies + run: | + pip install -r docs/requirements.txt + pip install -e . + - name: Build the docs strictly + run: python -m sphinx -n -W --keep-going -b html docs/source docs/build/html diff --git a/.github/workflows/website.yml b/.github/workflows/website.yml new file mode 100644 index 0000000..ef5db51 --- /dev/null +++ b/.github/workflows/website.yml @@ -0,0 +1,75 @@ +name: Publish website + +# One GitHub Pages site, two sources: the Quarto user site (quarto/) at the +# root and the Sphinx developer reference (docs/) under /dev/. Pull requests +# and pushes to develop only build both; pushes to main also deploy them. +# +# The Quarto pages that are notebooks are never executed here: Quarto reads +# their results from the committed quarto/_freeze/ cache. If a notebook was +# changed without refreshing the cache, the render step fails ("Jupyter is +# not available"); the fix is to render locally and commit quarto/_freeze/. +on: + pull_request: + paths: + - "quarto/**" + - "docs/**" + - "CompStats/**" + - "pyproject.toml" + - ".github/workflows/website.yml" + push: + branches: [main, develop] + paths: + - "quarto/**" + - "docs/**" + - "CompStats/**" + - "pyproject.toml" + - ".github/workflows/website.yml" + workflow_dispatch: + +jobs: + build: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + + - uses: quarto-dev/quarto-actions/setup@v2 + with: + # Keep equal to the version used to produce quarto/_freeze/. + version: 1.10.20 + + - run: quarto render quarto + + - uses: actions/setup-python@v5 + with: + python-version: "3.12" + + - name: Install docs and package dependencies + run: | + pip install -r docs/requirements.txt + # Not --no-deps: conf.py imports CompStats, and autodoc imports its + # dependencies with it. + pip install -e . + + - name: Build the developer docs strictly into the site + run: python -m sphinx -n -W --keep-going -b html docs/source quarto/_site/dev + + - uses: actions/upload-pages-artifact@v3 + with: + path: quarto/_site + + deploy: + if: github.ref == 'refs/heads/main' && github.event_name != 'pull_request' + needs: build + runs-on: ubuntu-latest + permissions: + pages: write + id-token: write + environment: + name: github-pages + url: ${{ steps.deployment.outputs.page_url }} + concurrency: + group: website + cancel-in-progress: true + steps: + - id: deployment + uses: actions/deploy-pages@v4 diff --git a/.gitignore b/.gitignore index e7b7a71..eac9e58 100644 --- a/.gitignore +++ b/.gitignore @@ -43,7 +43,6 @@ htmlcov/ .coverage .coverage.* .cache -nosetests.xml coverage.xml *.cover *.py,cover @@ -70,6 +69,7 @@ instance/ # Sphinx documentation docs/_build/ +docs/build/ # PyBuilder .pybuilder/ @@ -160,5 +160,11 @@ cython_debug/ #.idea/ .vscode/settings.json -quarto/CompStats_files/ -quarto/ \ No newline at end of file + +# Quarto build artifacts (source files under quarto/ are tracked) +quarto/_site/ +quarto/.quarto/ +quarto/*_files/ +quarto/*.html +quarto/pages/*_files/ +quarto/pages/*.html \ No newline at end of file diff --git a/.issue-pilot.json b/.issue-pilot.json new file mode 100644 index 0000000..4749075 --- /dev/null +++ b/.issue-pilot.json @@ -0,0 +1,6 @@ +{ + "test_command": ".venv/bin/python -m pytest CompStats", + "base_branch": "develop", + "model": "sonnet", + "effort": "high" +} diff --git a/.readthedocs.yaml b/.readthedocs.yaml deleted file mode 100644 index 63c3a31..0000000 --- a/.readthedocs.yaml +++ /dev/null @@ -1,12 +0,0 @@ -version: 2 - -build: - os: "ubuntu-22.04" - tools: - python: "miniconda3-4.7" - -sphinx: - configuration: docs/source/conf.py - -conda: - environment: environment.yml \ No newline at end of file diff --git a/CLAUDE.md b/CLAUDE.md index eb5b063..553d13c 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -44,7 +44,7 @@ pip install -r requirements.txt ``` Run the full test suite (this is what VS Code's test explorer and `.vscode/settings.json` are -configured to use — despite CI still invoking `nosetests`, day-to-day development here uses pytest): +configured to use, and what CI runs): ```bash pytest CompStats @@ -64,15 +64,64 @@ coverage run -m pytest CompStats coverage report ``` -Build the Sphinx docs: +Build the Sphinx developer reference (strict: `-n` reports every unresolved cross-reference and +`-W` turns warnings into errors; this is the same command CI runs, so a warning fails the build): ```bash -cd docs && make html +python -m sphinx -n -W --keep-going -b html docs/source docs/build/html ``` -Note: `.github/workflows/test.yaml` (CI) builds the environment with conda and runs `nosetests`, -not pytest — this is legacy and inconsistent with local/devcontainer tooling. Don't be surprised if -CI config and local dev commands diverge; prefer `pytest` locally. +CI (`.github/workflows/test.yml`) runs `pytest CompStats` on Python 3.10-3.12, collects coverage for +Coveralls, and runs `scripts/check_package_versions.py` (the version gate described below). + +## Releasing + +- The version lives in one place: `__version__` in `CompStats/__init__.py`. +- `scripts/check_package_versions.py` (run by CI on every push and pull request) fails unless + `__version__` is exactly one patch or one minor release ahead of the latest version on PyPI. +- To release: make sure `__version__` is the version to publish, merge to `main`, then create and + push the tag `v<__version__>` (for example `git tag v0.2.0 && git push origin v0.2.0`). + `.github/workflows/publish-pypi.yml` verifies that the tag equals `__version__`, builds the + sdist and the wheel, runs `twine check` and uploads with the `TWINE` repository secret. +- After a release, bump `__version__` before the next change is merged, otherwise the version gate + fails ("local is not ahead of PyPI"). + +## Documentation + +The documentation has two halves that share one GitHub Pages site, both deployed by +`.github/workflows/website.yml` on pushes to `main` (pull requests and pushes to `develop` only +build them): + +- the **user site** (Quarto, source in `quarto/`), at `https://ingeotec.github.io/CompStats/`; +- the **developer reference** (Sphinx, source in `docs/source/`), published under `/dev/`, + `https://ingeotec.github.io/CompStats/dev/`. + +Rules: + +- User-facing examples (site and README) use the `Perf`-based API only + (`CompStats.metrics.(y_true, y_pred, name=...)`, calling the instance to add a system, + `.difference()`, `.p_value(correction=...)`, `.plot()`), never the DataFrame functions of + `CompStats.performance`. +- Preview the user site with live reload, or render it statically into `quarto/_site/`: + + ```bash + QUARTO_PYTHON="$PWD/.venv/bin/python" quarto preview quarto + QUARTO_PYTHON="$PWD/.venv/bin/python" quarto render quarto + ``` + +- Freeze rule: CI never executes notebooks; it renders from the committed `quarto/_freeze/` cache. + After changing any `quarto/**/*.ipynb`, render locally and commit `quarto/_freeze/` with + `git add -A quarto/_freeze` in the same commit. `CompStats/tests/test_docs.py` fails when a + notebook and its freeze entry disagree. +- Prose follows the style of the published article: one idea per sentence, relations expressed + with sentence-initial connectors (However, Therefore, Furthermore, ...) or subordination, a + colon only before an enumeration or a piece of code, at most a couple of semicolons per page, + and no dashes as punctuation. `CompStats/tests/test_docs.py::test_site_prose_style` enforces + the punctuation limits on the user site. +- Notebooks are edited through `nbformat` (or Jupyter), never by hand-editing the JSON. +- The Colab-only install cell (a `try`/`except ImportError` block that runs + `uv pip install -q --system CompStats`, with `pip` as the fallback) keeps `#| eval: false` as its + first line, so it is shown but not executed when the site is rendered. ## Architecture @@ -113,6 +162,9 @@ statistic → derived comparisons/plots. each wrapper automatically — when adding a new metric wrapper, follow this same `@metrics_docs(hy_name=..., bib=...)` + inner-function-closure pattern rather than duplicating docstrings. + In docstrings, parameter names and `.measure` factories are written as inline literals (double + backticks), not as `:py:attr:`/`:py:func:` cross-references, because the strict Sphinx build + rejects references that do not resolve. - **`measurements.py`**: stateless helpers — `CI` (percentile bootstrap confidence interval), `SE` (bootstrap standard error), `difference_p_value`. Each accepts either a raw ndarray of bootstrap diff --git a/CompStats/bootstrap.py b/CompStats/bootstrap.py index 5b9ff5f..0383620 100644 --- a/CompStats/bootstrap.py +++ b/CompStats/bootstrap.py @@ -27,8 +27,8 @@ class StatisticSamples: :type num_samples: int :param n_jobs: Number of jobs to run in parallel, default=1. :type n_jobs: int - :param BiB: Bigger is Better; a single bool for a scalar/vector statistic, or one bool per column when :py:attr:`statistic` returns the concatenation of several measures (see :py:class:`~CompStats.interface.Perf`'s multi-measure support). - :type BiB: bool or numpy.ndarray[bool] + :param BiB: Bigger is Better; a single bool for a scalar/vector statistic, or one bool per column when ``statistic`` returns the concatenation of several measures (see :py:class:`~CompStats.interface.Perf`'s multi-measure support). + :type BiB: bool or numpy.ndarray of bool >>> from CompStats import StatisticSamples @@ -128,10 +128,15 @@ def statistic_samples(self, value): self._statistic_samples = value def samples(self, N): - """Samples. + """Indices of the bootstrap samples for a population of size `N`. The + indices are drawn once per population size and cached, so every system + evaluated on a population of the same size uses the same resamples + (this is what makes the comparisons paired). :param N: Population size. :type N: int + :return: Array of shape (``num_samples``, `N`) with indices drawn with replacement. + :rtype: numpy.ndarray """ def inner(N): _ = np.random.randint(N, size=(self.num_samples, N)) @@ -146,17 +151,21 @@ def inner(N): return inner(N) def keys(self): - """calls keys""" + """Names of the systems whose bootstrap samples are stored. + + :return: Keys of ``calls``. + """ return self.calls.keys() def __getitem__(self, key): + """Bootstrap samples of a system by name""" return self.calls[key] def __call__(self, *args: np.ndarray, name=None) -> np.ndarray: """Population where the bootstrap process will be performed. :param *args: Population - :type *args: np.ndarray + :type args: numpy.ndarray """ def inner(s): _ = [arg[s] for arg in args] diff --git a/CompStats/interface.py b/CompStats/interface.py index fba6691..0d993b1 100644 --- a/CompStats/interface.py +++ b/CompStats/interface.py @@ -29,13 +29,13 @@ class Perf(object): :param y_true: True measurement or could be a pandas.DataFrame where column label 'y' corresponds to the true measurement. :type y_true: numpy.ndarray or pandas.DataFrame - :param func: Function (or list of functions) to measure the performance. Whether the best algorithm has the highest or the lowest value is given by :py:attr:`BiB` -- either the constructor's default, or, when a callable already carries its own :py:attr:`BiB` attribute (e.g. built by a :py:mod:`CompStats.metrics` wrapper's ``.measure`` factory), that tag takes precedence. A list of functions combines them into a single, multi-measure :py:class:`Perf.` + :param func: Function (or list of functions) to measure the performance. Whether the best algorithm has the highest or the lowest value is given by ``BiB`` -- either the constructor's default, or, when a callable already carries its own ``BiB`` attribute (e.g. built by a :py:mod:`CompStats.metrics` wrapper's ``.measure`` factory), that tag takes precedence. A list of functions combines them into a single, multi-measure :py:class:`~CompStats.interface.Perf`. :type func: Function, or list of functions, where the first argument is :math:`y` and the second is :math:`\\hat{y}.` - :param BiB: Bigger is Better; the default direction used for any measure in :py:attr:`func` that doesn't already carry its own :py:attr:`BiB` attribute. A single bool applies to every measure; a list applies element-wise, one entry per measure in :py:attr:`func`. + :param BiB: Bigger is Better; the default direction used for any measure in ``func`` that doesn't already carry its own ``BiB`` attribute. A single bool applies to every measure; a list applies element-wise, one entry per measure in ``func``. :type BiB: bool or list of bool :param measure_names: Display name for each measure, only relevant when more than one measure is given; defaults to each function's ``__name__``. :type measure_names: list - :param y_pred: Predictions, the algorithms will be identified with alg-k where k=1 is the first argument included in :py:attr:`args.` + :param y_pred: Predictions, the algorithms will be identified with alg-k where k=1 is the first argument included in ``args``. :type y_pred: numpy.ndarray :param kwargs: Predictions, the algorithms will be identified using the keyword :type kwargs: numpy.ndarray @@ -69,7 +69,7 @@ class Perf(object): 0.9792 (0.0221) <= LinearSVC 0.9744 (0.0246) <= forest - If an algorithm's prediction is missing, this can be included by calling the instance, as can be seen in the following instruction. Note that the algorithm's name can also be given with the keyword :py:attr:`name.` + If an algorithm's prediction is missing, this can be included by calling the instance, as can be seen in the following instruction. Note that the algorithm's name can also be given with the keyword ``name``. >>> lr = LogisticRegression().fit(X_train, y_train) >>> perf(lr.predict(X_val), name='Log. Reg.') @@ -96,7 +96,7 @@ class Perf(object): When several algorithms are compared, :py:meth:`difference`'s p-values can be adjusted for multiple comparisons by passing a :py:func:`statsmodels.stats.multitest.multipletests` method name (e.g. - ``'bonferroni'``, ``'holm'``, ``'fdr_bh'``) as :py:attr:`correction` -- + ``'bonferroni'``, ``'holm'``, ``'fdr_bh'``) as ``correction`` -- both to :py:meth:`Difference.p_value` directly and, so that plots reflect the same adjusted significance, to :py:meth:`plot`/:py:meth:`dataframe`. @@ -109,8 +109,8 @@ class Perf(object): Two or more measures can be combined into a single :py:class:`Perf` instance (e.g. macro-F1 together with macro-recall) by passing a list of functions - to :py:attr:`func` -- see :py:mod:`CompStats.metrics`'s - ``.measure`` factories (e.g. :py:func:`~CompStats.metrics.f1_score.measure`). Every + to ``func`` -- see :py:mod:`CompStats.metrics`'s + ``.measure`` factories (e.g. ``f1_score.measure``). Every measure is evaluated on the same bootstrap resamples, so comparisons across algorithms remain paired for each measure. @@ -119,7 +119,7 @@ class Perf(object): ... func=[f1_score.measure(average='macro'), ... recall_score.measure(average='macro')]) - With multiple measures, :py:attr:`correction` is applied independently + With multiple measures, ``correction`` is applied independently per measure (i.e. per column), so one metric's correction never mixes with another's. @@ -173,9 +173,9 @@ def _as_list(value): def _measures(self): """List of (callable, BiB) pairs, one per measure being evaluated - Each callable's own :py:attr:`BiB` attribute (set by, e.g., a + Each callable's own ``BiB`` attribute (set by, e.g., a :py:meth:`metrics.py ` wrapper's ``.measure`` factory) - takes precedence over :py:attr:`BiB`, the constructor's default direction. + takes precedence over ``BiB``, the constructor's default direction. """ funcs = self._as_list(self.func) default = self.BiB @@ -278,7 +278,18 @@ def __call__(self, y_pred, name=None): return self def difference(self, wrt: str = None): - """Compute the difference w.r.t any algorithm by default is the best + """Create the :py:class:`~CompStats.interface.Difference` between a + reference system and every other system, computed on the bootstrap + samples already stored in this instance (so the comparison is paired). + By default the reference is the best system. + + :param wrt: Name of the reference system; ``None`` (default) uses + :py:attr:`~CompStats.interface.Perf.best`. + :type wrt: str + :return: Instance holding the bootstrap distribution of the paired + differences, signed so that a positive value means the reference is better. + :rtype: CompStats.interface.Difference + >>> from sklearn.svm import LinearSVC >>> from sklearn.ensemble import RandomForestClassifier @@ -604,8 +615,8 @@ def n_jobs(self, value): def statistic_func(self): """Statistic function - A single :py:attr:`func` callable is returned as-is; when more than - one measure is given (a list passed to :py:attr:`func`), a composite + A single ``func`` callable is returned as-is; when more than + one measure is given (a list passed to ``func``), a composite callable is returned that concatenates every measure's output into a single vector, evaluated on the same bootstrap samples. """ @@ -707,7 +718,7 @@ def func(self, value): @property def BiB(self): - """Bigger is Better; default direction for measures without their own :py:attr:`BiB` tag""" + """Bigger is Better; default direction for measures without their own ``BiB`` tag""" return self._BiB @BiB.setter @@ -719,7 +730,11 @@ def BiB(self, value): @dataclass class Difference: - """Difference + """Bootstrap distribution of the paired differences between a reference + system (by default the best one) and every other system. It is built by + :py:meth:`~CompStats.interface.Perf.difference` and provides the p-values + (:py:meth:`~CompStats.interface.Difference.p_value`) and the plot of the + differences. >>> from sklearn.svm import LinearSVC >>> from sklearn.ensemble import RandomForestClassifier @@ -795,7 +810,7 @@ def p_value(self, right: bool = True, correction: str = None): :param right: Estimate the p-value using :math:`\\text{sample} \\geq 2\\delta` :type right: bool - :param correction: Method to adjust for multiple comparisons, passed to :py:func:`statsmodels.stats.multitest.multipletests` (e.g. ``'bonferroni'``, ``'holm'``, ``'fdr_bh'``); ``None`` (default) leaves the p-values uncorrected. With a single measure, the family of comparisons is every other system against :py:attr:`best`; with multiple measures, each measure is corrected as its own family (i.e. per column) so metrics do not contaminate each other's correction. + :param correction: Method to adjust for multiple comparisons, passed to :py:func:`statsmodels.stats.multitest.multipletests` (e.g. ``'bonferroni'``, ``'holm'``, ``'fdr_bh'``); ``None`` (default) leaves the p-values uncorrected. With a single measure, the family of comparisons is every other system against :py:attr:`~CompStats.interface.Perf.best`; with multiple measures, each measure is corrected as its own family (i.e. per column) so metrics do not contaminate each other's correction. :type correction: str >>> from sklearn.svm import LinearSVC diff --git a/CompStats/measurements.py b/CompStats/measurements.py index db52e4b..fe1b0d6 100644 --- a/CompStats/measurements.py +++ b/CompStats/measurements.py @@ -41,7 +41,13 @@ def CI(samples: np.ndarray, alpha=0.05): def SE(samples: np.ndarray): - """Compute the Standard Error of a statistic using bootstrap. + """Compute the Standard Error of a statistic using bootstrap: the standard + deviation of the bootstrap samples. + + :param samples: Bootstrap samples, or a :py:class:`~CompStats.bootstrap.StatisticSamples` + instance, in which case a dictionary with one value per system is returned. + :type samples: numpy.ndarray or CompStats.bootstrap.StatisticSamples + :return: Standard error (one value per measure when the samples have several columns). >>> from CompStats import StatisticSamples, SE >>> from sklearn.metrics import accuracy_score @@ -51,6 +57,7 @@ def SE(samples: np.ndarray): >>> bootstrap = StatisticSamples(statistic=accuracy_score) >>> samples = bootstrap(labels, pred) >>> SE(samples) + 0.1459 """ if isinstance(samples, StatisticSamples): return {k: SE(v) for k, v in samples.calls.items()} @@ -58,7 +65,19 @@ def SE(samples: np.ndarray): def difference_p_value(samples: np.ndarray, BiB: bool = True): - """Compute the difference p-value""" + """Estimate the p-value of the paired differences, as the fraction of + bootstrap differences that are at least twice the mean difference (the + bootstrap distribution is centred on the observed difference rather than + on zero). With ``BiB`` false the comparison is reversed. + + :param samples: Bootstrap samples of the paired differences, or a + :py:class:`~CompStats.bootstrap.StatisticSamples` instance, in which + case a dictionary with one p-value per system is returned. + :type samples: numpy.ndarray or CompStats.bootstrap.StatisticSamples + :param BiB: Bigger is Better, default=True. + :type BiB: bool + :return: Estimated p-value. + """ if isinstance(samples, StatisticSamples): if samples.BiB: return {k: (v > 2 * np.mean(v)).mean() for k, v in samples.calls.items()} diff --git a/CompStats/metrics.py b/CompStats/metrics.py index 26f0033..7486b6f 100644 --- a/CompStats/metrics.py +++ b/CompStats/metrics.py @@ -477,11 +477,11 @@ def macro_f1(y_true, *y_pred, labels=None, sample_weight=None, zero_division='warn', num_samples: int = 500, n_jobs: int = -1, use_tqdm=True, **kwargs): - """:py:class:`~CompStats.interface.Perf` with :py:func:`~sklearn.metrics.f1_score` (as :py:attr:`func`) with the parameteres needed to compute the macro score. The parameters not described can be found in :py:func:`~sklearn.metrics.f1_score` + """:py:class:`~CompStats.interface.Perf` with :py:func:`~sklearn.metrics.f1_score` (as ``func``) with the parameteres needed to compute the macro score. The parameters not described can be found in :py:func:`~sklearn.metrics.f1_score` :param y_true: True measurement or could be a pandas.DataFrame where column label 'y' corresponds to the true measurement. :type y_true: numpy.ndarray or pandas.DataFrame - :param y_pred: Predictions, the algorithms will be identified with alg-k where k=1 is the first argument included in :py:attr:`y_pred.` + :param y_pred: Predictions, the algorithms will be identified with alg-k where k=1 is the first argument included in ``y_pred``. :type y_pred: numpy.ndarray :param kwargs: Predictions, the algorithms will be identified using the keyword :type kwargs: numpy.ndarray @@ -513,11 +513,11 @@ def macro_recall(y_true, *y_pred, labels=None, sample_weight=None, zero_division='warn', num_samples: int = 500, n_jobs: int = -1, use_tqdm=True, **kwargs): - """:py:class:`~CompStats.interface.Perf` with :py:func:`~sklearn.metrics.recall_score` (as :py:attr:`func`) with the parameteres needed to compute the macro score. The parameters not described can be found in :py:func:`~sklearn.metrics.recall_score` + """:py:class:`~CompStats.interface.Perf` with :py:func:`~sklearn.metrics.recall_score` (as ``func``) with the parameteres needed to compute the macro score. The parameters not described can be found in :py:func:`~sklearn.metrics.recall_score` :param y_true: True measurement or could be a pandas.DataFrame where column label 'y' corresponds to the true measurement. :type y_true: numpy.ndarray or pandas.DataFrame - :param y_pred: Predictions, the algorithms will be identified with alg-k where k=1 is the first argument included in :py:attr:`y_pred.` + :param y_pred: Predictions, the algorithms will be identified with alg-k where k=1 is the first argument included in ``y_pred``. :type y_pred: numpy.ndarray :param kwargs: Predictions, the algorithms will be identified using the keyword :type kwargs: numpy.ndarray @@ -549,11 +549,11 @@ def macro_precision(y_true, *y_pred, labels=None, sample_weight=None, zero_division='warn', num_samples: int = 500, n_jobs: int = -1, use_tqdm=True, **kwargs): - """:py:class:`~CompStats.interface.Perf` with :py:func:`~sklearn.metrics.precision_score` (as :py:attr:`func`) with the parameteres needed to compute the macro score. The parameters not described can be found in :py:func:`~sklearn.metrics.precision_score` + """:py:class:`~CompStats.interface.Perf` with :py:func:`~sklearn.metrics.precision_score` (as ``func``) with the parameteres needed to compute the macro score. The parameters not described can be found in :py:func:`~sklearn.metrics.precision_score` :param y_true: True measurement or could be a pandas.DataFrame where column label 'y' corresponds to the true measurement. :type y_true: numpy.ndarray or pandas.DataFrame - :param y_pred: Predictions, the algorithms will be identified with alg-k where k=1 is the first argument included in :py:attr:`y_pred.` + :param y_pred: Predictions, the algorithms will be identified with alg-k where k=1 is the first argument included in ``y_pred``. :type y_pred: numpy.ndarray :param kwargs: Predictions, the algorithms will be identified using the keyword :type kwargs: numpy.ndarray @@ -1032,11 +1032,11 @@ def pearsonr(y_true, *y_pred, n_jobs: int = -1, use_tqdm=True, **kwargs): - """:py:class:`~CompStats.interface.Perf` with :py:func:`~scipy.stats.pearsonr` as :py:attr:`func.` + """:py:class:`~CompStats.interface.Perf` with :py:func:`~scipy.stats.pearsonr` as ``func``. :param y_true: True measurement or could be a pandas.DataFrame where column label 'y' corresponds to the true measurement. :type y_true: numpy.ndarray or pandas.DataFrame - :param y_pred: Predictions, the algorithms will be identified with alg-k where k=1 is the first argument included in :py:attr:`y_pred.` + :param y_pred: Predictions, the algorithms will be identified with alg-k where k=1 is the first argument included in ``y_pred``. :type y_pred: numpy.ndarray :param kwargs: Predictions, the algorithms will be identified using the keyword :type kwargs: numpy.ndarray diff --git a/CompStats/performance.py b/CompStats/performance.py index 10ae471..e2c5281 100644 --- a/CompStats/performance.py +++ b/CompStats/performance.py @@ -35,7 +35,7 @@ def performance(data: pd.DataFrame, """Calculate bootstrap samples of a performance score for a given dataset. Parameters: - data (pd.DataFrame): Input dataset. + data (pandas.DataFrame): Input dataset. gold (str, optional): Column name of the ground truth or target variable. Defaults to 'y'. score (Callable, optional): Performance score function. Defaults to accuracy_score. num_samples (int, optional): Number of bootstrap samples. Defaults to 500. @@ -78,6 +78,7 @@ def difference(statistic_samples: StatisticSamples): # , best_index: int=-1): StatisticSamples: A new instance of StatisticSamples with the computed differences and information about the best algorithm. The function works as follows: + 1. Determines the index of the best performing algorithm based on the BiB attribute. 2. Extracts and calculates the mean performance for each algorithm. 3. Sorts the algorithms by their mean performance. @@ -123,6 +124,7 @@ def all_differences(statistic_samples: StatisticSamples): StatisticSamples: A new instance of StatisticSamples with the computed performance differences among all algorithms. The function works as follows: + 1. Extracts the performance data for each algorithm. 2. Calculates the mean performance for each algorithm and sorts the algorithms based on their mean performance. 3. Iterates over all possible pairs of algorithms. @@ -168,7 +170,7 @@ def plot_performance(statistic_samples: StatisticSamples, CI: float = 0.05, """Plots the performance of algorithms with confidence intervals. :param statistic_samples: An instance of StatisticSamples containing the performance data, or a DataFrame in long format. - :type statistic_samples: StatisticSamples or pd.DataFrame + :type statistic_samples: CompStats.bootstrap.StatisticSamples or pandas.DataFrame :param CI: Confidence interval level (default is 0.05). :type CI: float :param var_name: Variable name for algorithms (default is 'Algorithm'). @@ -186,9 +188,10 @@ def plot_performance(statistic_samples: StatisticSamples, CI: float = 0.05, :param kwargs: Additional keyword arguments passed to seaborn's catplot function. :returns: A seaborn FacetGrid object containing the plot. - :rtype: sns.axisgrid.FacetGrid + :rtype: seaborn.FacetGrid The function works as follows: + 1. If statistic_samples is an instance of StatisticSamples, it extracts and sorts the performance data. 2. Converts the data into a long format DataFrame. 3. Computes the confidence intervals if CI is provided as a float. @@ -236,12 +239,13 @@ def plot_difference(statistic_samples: StatisticSamples, CI: float = 0.05, set_title (bool, optional): Whether to set the title of the plot with the best performing algorithm. Defaults to True. hue (str or None, optional): Column name for hue encoding. Defaults to 'Significant'. palette (list or None, optional): Colors to use for different hue levels. Defaults to None. - **kwargs: Additional keyword arguments passed to the plot_performance function. + ``**kwargs``: Additional keyword arguments passed to the plot_performance function. Returns: - sns.axisgrid.FacetGrid: A seaborn FacetGrid object containing the plot. + seaborn.FacetGrid: A seaborn FacetGrid object containing the plot. The function works as follows: + 1. Converts the differences stored in statistic_samples into a long format DataFrame. 2. Adds a 'Significant' column to indicate whether the confidence interval includes zero. 3. Plots the differences with confidence intervals using the plot_performance function. @@ -293,28 +297,29 @@ def performance_multiple_metrics(data: pd.DataFrame, gold: str, Calculate bootstrap samples of multiple performance metrics for a given dataset. Parameters: - data (pd.DataFrame): Input dataset. + data (pandas.DataFrame): Input dataset. gold (str): Column name of the ground truth or target variable. scores (List[dict]): A list of dictionaries, each containing: + - "func": The performance score function. - "args" (optional): Arguments to pass to the score function. - "BiB": Whether the metric is Bigger is Better. + num_samples (int, optional): Number of bootstrap samples. Defaults to 500. n_jobs (int, optional): Number of jobs to run in parallel. Defaults to -1. Returns: dict: A dictionary containing the results for each metric, including: + - 'samples': Bootstrap samples of the performance scores. - 'performance': Calculated performance scores for each algorithm. - - 'compg': General performance comparison metrics, including: - - 'n': Number of samples. - - 'm': Number of algorithms. - - 'cv': Coefficient of variation for each metric. - - 'dist': Distance metric for each metric. - - 'PPI': Performance potential index for each metric. + - 'compg': General performance comparison metrics ('n': number of samples, + 'm': number of algorithms, 'cv': coefficient of variation, 'dist': distance + metric and 'PPI': performance potential index, each one per metric). - 'BiB': Whether each metric is Bigger is Better. The function works as follows: + 1. Defines auxiliary functions for calculating additional performance metrics. 2. Iterates over the list of score functions and their respective arguments. 3. Initializes a StatisticSamples object for each score function. @@ -389,12 +394,13 @@ def plot_performance2(results: dict, CI: float = 0.05, linestyle (str, optional): Line style for the plot. Defaults to 'none'. kind (str, optional): Type of the plot, e.g., 'point', 'bar'. Defaults to 'point'. sharex (bool, optional): Whether to share the x-axis among subplots. Defaults to False. - **kwargs: Additional keyword arguments for seaborn.catplot. + ``**kwargs``: Additional keyword arguments for seaborn.catplot. Returns: - sns.axisgrid.FacetGrid: A seaborn FacetGrid object containing the plot. + seaborn.FacetGrid: A seaborn FacetGrid object containing the plot. The function works as follows: + 1. If results is a dictionary, it sorts the algorithms by their mean performance scores. 2. Converts the sorted data into a long format DataFrame. 3. Computes the confidence intervals if CI is provided as a float. @@ -420,17 +426,14 @@ def difference_multiple(results_dict, CI: float = 0.05,): with itself. Additionally, identify the best performing algorithm for each metric. Parameters: - results_dict (dict): A dictionary where keys are metric names and values are dictionaries. - Each sub-dictionary has algorithm names as keys and lists of performance scores as values. + results_dict (dict): A dictionary where keys are metric names and values are dictionaries. Each sub-dictionary has algorithm names as keys and lists of performance scores as values. CI (float, optional): Confidence interval level. Defaults to 0.05. Returns: - dict: A dictionary with the same structure, but where the scores for each algorithm are replaced - by their differences to the scores of the best performing algorithm for that metric, - excluding the best performing algorithm comparing with itself. - Also includes the best algorithm name for each metric. + dict: A dictionary with the same structure, but where the scores for each algorithm are replaced by their differences to the scores of the best performing algorithm for that metric, excluding the best performing algorithm comparing with itself. Also includes the best algorithm name for each metric. The function works as follows: + 1. Iterates over each metric in the results dictionary. 2. Converts performance scores to numpy arrays for efficient computations. 3. Identifies the best performing algorithm for each metric based on the mean performance scores. @@ -533,18 +536,18 @@ def plot_performance_multiple(results_dict: dict, CI: float = 0.05, capsize: flo Create multiple performance plots, one for each performance metric in the results dictionary. Parameters: - results_dict (dict): A dictionary where keys are metric names and values are dictionaries - with algorithm names as keys and lists of performance scores as values. + results_dict (dict): A dictionary where keys are metric names and values are dictionaries with algorithm names as keys and lists of performance scores as values. CI (float, optional): Confidence interval level for error bars. Defaults to 0.05. capsize (float, optional): Cap size for error bars. Defaults to 0.2. linestyle (str, optional): Line style for the plot. Defaults to 'none'. kind (str, optional): Type of the plot, e.g., 'point', 'bar'. Defaults to 'point'. - **kwargs: Additional keyword arguments for seaborn.catplot. + ``**kwargs``: Additional keyword arguments for seaborn.catplot. Returns: None: The function creates and displays plots. The function works as follows: + 1. Iterates over each metric in the results dictionary. 2. Uses the plot_performance2 function to create and display the plot for each metric. 3. Sets the title of each plot to the metric name and the best performing algorithm. diff --git a/CompStats/tests/test_docs.py b/CompStats/tests/test_docs.py new file mode 100644 index 0000000..9b1223d --- /dev/null +++ b/CompStats/tests/test_docs.py @@ -0,0 +1,363 @@ +import hashlib +import importlib +import inspect +import json +import re +import subprocess +from pathlib import Path + +import pytest + +ROOT = Path(__file__).resolve().parents[2] +DOCS = ROOT / "docs" / "source" + +pytestmark = pytest.mark.skipif( + not DOCS.is_dir(), reason="needs the repository checkout (docs/source)") + +SITE = ROOT / "quarto" +_SKIPPED_DIRS = {"_site", "_freeze", ".quarto", ".ipynb_checkpoints"} +needs_site = pytest.mark.skipif( + not SITE.is_dir(), reason="needs the repository checkout (quarto/)") + +_AUTOMODULE_RE = re.compile(r"^\.\.\s+automodule::\s+(\S+)\s*$", re.MULTILINE) + + + +def _site_files(suffix): + """Source pages of the Quarto site with the given suffix""" + return sorted(p for p in SITE.rglob(f"*{suffix}") + if not _SKIPPED_DIRS & set(p.relative_to(SITE).parts)) + + +MODULES = ["bootstrap", "interface", "measurements", "metrics", + "performance", "utils"] + + +def test_every_module_is_documented_exactly_once(): + """Each CompStats module appears in exactly one automodule directive""" + stems = sorted(path.stem for path in (ROOT / "CompStats").glob("*.py") + if path.name != "__init__.py") + documented = [] + for rst in DOCS.glob("*.rst"): + documented += _AUTOMODULE_RE.findall(rst.read_text(encoding="utf-8")) + for stem in stems: + assert documented.count(f"CompStats.{stem}") == 1, stem + + +def test_public_api_has_docstrings(): + """Every public function, class, method and property has a docstring""" + missing = [] + for name in MODULES: + module = importlib.import_module(f"CompStats.{name}") + for obj_name, obj in vars(module).items(): + if obj_name.startswith("_"): + continue + if not (inspect.isfunction(obj) or inspect.isclass(obj)): + continue + if getattr(obj, "__module__", None) != module.__name__: + continue + if not (inspect.getdoc(obj) or "").strip(): + missing.append(f"{name}.{obj_name}") + if not inspect.isclass(obj): + continue + for member_name, member in vars(obj).items(): + if member_name.startswith("_"): + continue + if isinstance(member, (staticmethod, classmethod)): + member = member.__func__ + if not (inspect.isfunction(member) + or isinstance(member, property)): + continue + if not (member.__doc__ or "").strip(): + missing.append(f"{name}.{obj_name}.{member_name}") + assert not missing, missing + + +def test_index_sections_in_order(): + """The landing page has the expected sections, in order""" + text = (DOCS / "index.rst").read_text(encoding="utf-8") + position = -1 + for title in ["Statistical background", "Architecture", + "Invariants to preserve", "Development", "Citing", "API"]: + found = text.find(f"\n{title}\n", position + 1) + assert found > position, title + position = found + + +def test_index_cites_both_papers(): + """Both papers are cited with a well-formed DOI""" + text = (DOCS / "index.rst").read_text(encoding="utf-8") + assert "10.1016/j.patrec.2024.03.010" in text + assert "10.1007/978-3-031-33783-3_9" in text + assert "/COVER" not in text + + +def test_no_legacy_hosting_in_developer_docs(): + """The previous hosting service is not referenced any more""" + word = "readthe" + "docs" + files = list(DOCS.glob("*.rst")) + [DOCS / "conf.py"] + for path in files: + assert word not in path.read_text(encoding="utf-8").lower(), path.name + assert not (ROOT / (".read" + "thedocs.yaml")).exists() + + +def test_conf_uses_furo_and_intersphinx(): + """The theme is furo and the external inventories are mapped""" + text = (DOCS / "conf.py").read_text(encoding="utf-8") + assert "html_theme = 'furo'" in text + assert "sys.path" not in text + mapping = text[text.index("intersphinx_mapping"):] + for name in ["numpy", "pandas", "scipy", "sklearn", "statsmodels", + "seaborn"]: + assert f"'{name}'" in mapping, name + + +def test_docs_job_in_ci(): + """CI runs the strict Sphinx build""" + workflow = ROOT / ".github" / "workflows" / "test.yml" + if not workflow.is_file(): + pytest.skip("needs the repository checkout (.github/workflows)") + command = "python -m sphinx -n -W --keep-going -b html docs/source docs/build/html" + assert command in workflow.read_text(encoding="utf-8") + + +@needs_site +def test_freeze_matches_notebooks(): + """The freeze entry of every notebook is up to date""" + notebooks = _site_files(".ipynb") + assert notebooks + for notebook in notebooks: + relative = notebook.relative_to(SITE).with_suffix("") + entry = SITE / "_freeze" / relative / "execute-results" / "html.json" + fix = ('render locally with QUARTO_PYTHON="$PWD/.venv/bin/python" ' + 'quarto render quarto and commit quarto/_freeze/') + assert entry.is_file(), f"{entry} is missing: {fix}" + digest = hashlib.md5(notebook.read_bytes()).hexdigest() + stored = json.loads(entry.read_text(encoding="utf-8"))["hash"] + assert stored == digest, f"{notebook.name} and its freeze differ: {fix}" + + +@needs_site +def test_no_orphan_freeze_entries(): + """Every freeze entry belongs to an existing notebook""" + freeze = SITE / "_freeze" + if not freeze.is_dir(): + pytest.skip("no freeze directory") + for entry in freeze.rglob("execute-results/html.json"): + page = entry.parent.parent.relative_to(freeze) + assert (SITE / page).with_suffix(".ipynb").is_file(), page + + +@needs_site +def test_install_cells_are_not_executed(): + """The Colab-only install cell is shown but not executed""" + for notebook in _site_files(".ipynb"): + cells = json.loads(notebook.read_text(encoding="utf-8"))["cells"] + cells = ["".join(c["source"]) for c in cells + if c["cell_type"] == "code"] + cells = [c for c in cells if "pip install -q" in c and "CompStats" in c] + assert len(cells) == 1, notebook.name + assert cells[0].startswith("#| eval: false"), notebook.name + assert "except ImportError" in cells[0], notebook.name + assert "uv pip install" in cells[0], notebook.name + + +@needs_site +def test_navbar_pages_exist(): + """Every local link of the navbar names an existing page""" + text = (SITE / "_quarto.yml").read_text(encoding="utf-8") + hrefs = re.findall(r"^\s*-?\s*href:\s*(\S+)\s*$", text, re.MULTILINE) + local = [h for h in hrefs if not h.startswith("http")] + for href in local: + assert (SITE / href).is_file(), href + for page in ["index.qmd", "pages/install.qmd", "pages/methodology.qmd", + "pages/citing.qmd", "pages/sklearn_users.ipynb", + "pages/competition_organizers.ipynb", + "pages/multiple_testing.ipynb"]: + assert page in local, page + + +@needs_site +def test_user_docs_use_the_perf_api(): + """User-facing examples do not use the DataFrame-based functions""" + forbidden = ["from CompStats.performance", "from CompStats import performance"] + texts = [p.read_text(encoding="utf-8") for p in _site_files(".qmd")] + for notebook in _site_files(".ipynb"): + cells = json.loads(notebook.read_text(encoding="utf-8"))["cells"] + texts += ["".join(c["source"]) for c in cells + if c["cell_type"] == "code"] + readme = ROOT / "README.rst" + if readme.is_file(): + texts.append(readme.read_text(encoding="utf-8")) + for text in texts: + for item in forbidden: + assert item not in text, item + + +@needs_site +def test_methodology_page_content(): + """The methodology page covers the published methodology""" + text = (SITE / "pages" / "methodology.qmd").read_text(encoding="utf-8") + lower = text.lower() + for word in ["bootstrap", "confidence interval", "paired", "p-value", + "Bonferroni", "Holm", "Benjamini", "Berg-Kirkpatrick", + "coefficient of variation", "PPI"]: + assert word.lower() in lower, word + assert "@Nava-Munoz2024" in text + assert "{#refs}" in text + + +def test_no_legacy_hosting_anywhere(): + """No tracked text file refers to the previous hosting service""" + word = "readthe" + "docs" + try: + output = subprocess.run(["git", "ls-files", "-z"], cwd=ROOT, + capture_output=True, check=True).stdout + except (OSError, subprocess.CalledProcessError): + pytest.skip("needs a git checkout") + for name in output.decode("utf-8").split("\0"): + path = ROOT / name + if not name or not path.is_file(): + continue + try: + text = path.read_text(encoding="utf-8") + except UnicodeDecodeError: + continue + assert word not in text.lower(), name + + +def test_readme(): + """The README links both sites and is valid reStructuredText""" + readme = ROOT / "README.rst" + if not readme.is_file(): + pytest.skip("needs the repository checkout (README.rst)") + text = readme.read_text(encoding="utf-8") + assert "https://ingeotec.github.io/CompStats/" in text + assert "https://ingeotec.github.io/CompStats/dev/" in text + assert "10.1016/j.patrec.2024.03.010" in text + assert "raw/docs/docs" not in text + core = pytest.importorskip("docutils.core") + core.publish_string(text, writer_name="html", + settings_overrides={"halt_level": 2, + "report_level": 2}) + + +def test_site_workflow(): + """The site is published by one workflow that deploys to GitHub Pages""" + workflows = ROOT / ".github" / "workflows" + if not workflows.is_dir(): + pytest.skip("needs the repository checkout (.github/workflows)") + website = workflows / "website.yml" + assert website.is_file() + assert not (workflows / "publish.yml").exists() + text = website.read_text(encoding="utf-8") + assert "quarto render quarto" in text + assert ("python -m sphinx -n -W --keep-going -b html docs/source " + "quarto/_site/dev") in text + assert "actions/deploy-pages" in text + assert "conda" not in text + assert "gh-pages" not in text + + +def test_project_urls(): + """The project URLs point at the GitHub Pages site""" + tomllib = pytest.importorskip("tomllib") + pyproject = ROOT / "pyproject.toml" + if not pyproject.is_file(): + pytest.skip("needs the repository checkout (pyproject.toml)") + with open(pyproject, "rb") as fpt: + urls = tomllib.load(fpt)["project"]["urls"] + assert urls["Homepage"] == "https://ingeotec.github.io/CompStats/" + assert urls["Documentation"] == "https://ingeotec.github.io/CompStats/" + + +@needs_site +def test_site_follows_the_article(): + """The wording of the site agrees with the published article""" + index = (SITE / "index.qmd").read_text(encoding="utf-8").lower() + assert "developed" + " by" not in index + assert "validated" not in index + lines = (SITE / "_quarto.yml").read_text(encoding="utf-8").splitlines() + marker = next(i for i, line in enumerate(lines) + if "Code under the Apache 2.0 license" in line) + assert "INGEOTEC" not in "\n".join(lines[max(marker - 1, 0):marker + 1]) + methodology = (SITE / "pages" / "methodology.qmd").read_text(encoding="utf-8") + assert "m(m-1)/2" in methodology.replace(" ", "") + assert "four" + " indicators" not in methodology + + +@needs_site +def test_site_bibliography(): + """Every citation of the site links to a complete entry of references.bib""" + bib = SITE / "references.bib" + assert bib.is_file() + assert "bibliography: references.bib" in (SITE / "_quarto.yml").read_text( + encoding="utf-8") + content = bib.read_text(encoding="utf-8") + csl = SITE / "compstats.csl" + assert csl.is_file() + assert "csl: compstats.csl" in (SITE / "_quarto.yml").read_text(encoding="utf-8") + assert 'variable="note"' in csl.read_text(encoding="utf-8") + assert "https://arxiv.org/abs/2403.04693" in content + assert "arxiv.org" not in (SITE / "index.qmd").read_text(encoding="utf-8") + keys = set(re.findall(r"^@\w+\{([^,]+),", content, re.MULTILINE)) + pages = [SITE / "index.qmd", SITE / "pages" / "methodology.qmd"] + for page in pages: + text = page.read_text(encoding="utf-8") + for key in re.findall(r"@([A-Za-z][A-Za-z0-9-]*[0-9]{4})", text): + assert key in keys, f"{key} cited in {page.name} is not in references.bib" + assert not re.search(r"\((?:[^()]*, )?(?:19|20)\d{2}\)", text), page.name + for entry in re.split(r"^(?=@)", content, flags=re.MULTILINE): + if entry.strip(): + assert re.search(r"^\s*(doi|url)\s*=", entry, re.MULTILINE), entry[:40] + + +@needs_site +def test_site_code_is_visible(): + """No code of the site is folded behind a link""" + word = "code-" + "fold" + config = SITE / "_quarto.yml" + assert word not in config.read_text(encoding="utf-8") + for page in _site_files(".qmd"): + assert word not in page.read_text(encoding="utf-8"), page.name + for notebook in _site_files(".ipynb"): + cells = json.loads(notebook.read_text(encoding="utf-8"))["cells"] + for cell in cells: + assert word not in "".join(cell["source"]), notebook.name + + +@needs_site +def test_sklearn_users_covers_regression(): + """The scikit-learn tutorial also shows a regression problem""" + path = SITE / "pages" / "sklearn_users.ipynb" + cells = json.loads(path.read_text(encoding="utf-8"))["cells"] + code = ["".join(c["source"]) for c in cells if c["cell_type"] == "code"] + text = ["".join(c["source"]) for c in cells if c["cell_type"] == "markdown"] + assert any("mean_absolute_error" in c for c in code) + assert any(c.startswith("## Regression") for c in text) + + +@needs_site +def test_site_prose_style(): + """The punctuation of the prose of the site follows the published article""" + pages = {} + for name in ["index.qmd", "pages/install.qmd", "pages/methodology.qmd"]: + pages[name] = (SITE / name).read_text(encoding="utf-8") + for name in ["sklearn_users", "competition_organizers", "multiple_testing"]: + path = SITE / "pages" / f"{name}.ipynb" + cells = json.loads(path.read_text(encoding="utf-8"))["cells"] + pages[name] = "\n\n".join("".join(c["source"]) for c in cells + if c["cell_type"] == "markdown") + for name, text in pages.items(): + text = re.sub(r"\A---\n.*?\n---\n", "", text, flags=re.S) + text = re.sub(r"```.*?```", "", text, flags=re.S) + text = re.sub(r"\$\$.*?\$\$", "", text, flags=re.S) + text = re.sub(r"`[^`]*`", "CODE", text) + text = re.sub(r"\$[^$]*\$", "MATH", text) + text = re.sub(r"\[@[^\]]*\]", "CITE", text) + text = re.sub(r"\]\([^)]*\)", "]", text) + text = re.sub(r"^:::.*$", "", text, flags=re.M) + text = re.sub(r"https?://\S+", "URL", text) + assert "--" not in text and "—" not in text, name + assert text.count(";") <= 2, name + assert len(re.findall(r":(?=\s|$)", text, flags=re.M)) <= 3, name diff --git a/CompStats/tests/test_packaging.py b/CompStats/tests/test_packaging.py new file mode 100644 index 0000000..a6c987a --- /dev/null +++ b/CompStats/tests/test_packaging.py @@ -0,0 +1,107 @@ +import importlib.util +from pathlib import Path + +import pytest + +ROOT = Path(__file__).resolve().parents[2] +SCRIPT = ROOT / "scripts" / "check_package_versions.py" +WORKFLOWS = ROOT / ".github" / "workflows" +# Built from fragments so that this file does not contain the legacy names it checks for. +LEGACY_RUNNER = "nose" + "tests" +LEGACY_WORKFLOW = "test" + ".yaml" + +pytest.importorskip("tomllib") # Python 3.11+ +pytest.importorskip("packaging") +pytestmark = pytest.mark.skipif( + not SCRIPT.is_file(), reason="needs the repository checkout (scripts/)") + +from packaging.version import Version # noqa: E402 + + +def _load_script(): + """Import scripts/check_package_versions.py as a module""" + spec = importlib.util.spec_from_file_location("check_package_versions", SCRIPT) + module = importlib.util.module_from_spec(spec) + spec.loader.exec_module(module) + return module + + +def test_local_version_matches_package(): + """The version read from the source equals the imported one""" + import CompStats + module = _load_script() + assert module.local_version() == CompStats.__version__ + + +def test_next_versions(): + """Next patch and next minor""" + module = _load_script() + assert module.next_versions(Version("0.1.15")) == (Version("0.1.16"), + Version("0.2.0")) + + +def test_check_package_never_published(monkeypatch): + """A package PyPI does not know always passes""" + module = _load_script() + monkeypatch.setattr(module, "pypi_latest_version", lambda package=None: None) + assert module.check_package()[3] is True + + +def test_check_package_single_step(monkeypatch): + """Next minor and next patch are accepted""" + module = _load_script() + monkeypatch.setattr(module, "local_version", lambda package_dir=None: "1.4.0") + monkeypatch.setattr(module, "pypi_latest_version", + lambda package=None: "1.3.7") + assert module.check_package()[3] is True + monkeypatch.setattr(module, "local_version", + lambda package_dir=None: "1.3.10") + monkeypatch.setattr(module, "pypi_latest_version", + lambda package=None: "1.3.9") + assert module.check_package()[3] is True + + +def test_check_package_not_ahead(monkeypatch): + """Equal or greater PyPI version fails""" + module = _load_script() + monkeypatch.setattr(module, "local_version", lambda package_dir=None: "1.4.0") + for pypi in ("1.4.0", "1.5.0"): + monkeypatch.setattr(module, "pypi_latest_version", + lambda package=None, pypi=pypi: pypi) + assert module.check_package()[3] is False + + +def test_check_package_jump(monkeypatch): + """Jumping more than one release fails and reports the expectation""" + module = _load_script() + monkeypatch.setattr(module, "local_version", lambda package_dir=None: "1.5.0") + monkeypatch.setattr(module, "pypi_latest_version", + lambda package=None: "1.3.7") + _, _, _, ok, detail = module.check_package() + assert ok is False + assert "1.3.8" in detail and "1.4.0" in detail + + +def test_workflows(): + """Legacy workflows are gone and the new ones have the key steps""" + assert (WORKFLOWS / "test.yml").is_file() + assert (WORKFLOWS / "publish-pypi.yml").is_file() + assert not (WORKFLOWS / LEGACY_WORKFLOW).exists() + assert not (WORKFLOWS / "pip.yaml").exists() + test = (WORKFLOWS / "test.yml").read_text(encoding="utf-8") + assert "pytest CompStats" in test + assert "scripts/check_package_versions.py" in test + assert LEGACY_RUNNER not in test + publish = (WORKFLOWS / "publish-pypi.yml").read_text(encoding="utf-8") + assert "secrets.TWINE" in publish + assert "twine check" in publish + + +def test_pyproject_build_system_and_test_extra(): + """pyproject declares the build backend and a pytest test extra""" + import tomllib + with open(ROOT / "pyproject.toml", "rb") as fpt: + data = tomllib.load(fpt) + assert data["build-system"]["build-backend"] == "setuptools.build_meta" + extra = data["project"]["optional-dependencies"]["test"] + assert any(item.startswith("pytest") for item in extra) diff --git a/CompStats/utils.py b/CompStats/utils.py index e5d9b56..78acd26 100644 --- a/CompStats/utils.py +++ b/CompStats/utils.py @@ -20,17 +20,17 @@ def progress_bar(arg, use_tqdm: bool = True, **kwargs): - """Wrap `arg` in a :py:class:`tqdm.tqdm` progress bar. + """Wrap `arg` in a ``tqdm.tqdm`` progress bar. - Returns `arg` unchanged when tqdm is not installed or :py:attr:`use_tqdm` is + Returns `arg` unchanged when tqdm is not installed or ``use_tqdm`` is `False`, so callers can iterate over the result the same way regardless of whether a progress bar is actually shown. :param arg: Iterable to wrap. :param use_tqdm: Whether to show the progress bar, default=True. :type use_tqdm: bool - :param kwargs: Extra keyword arguments passed to :py:class:`tqdm.tqdm`. - :return: `arg`, optionally wrapped in a :py:class:`tqdm.tqdm` iterator. + :param kwargs: Extra keyword arguments passed to ``tqdm.tqdm``. + :return: `arg`, optionally wrapped in a ``tqdm.tqdm`` iterator. """ if not USE_TQDM or not use_tqdm: return arg @@ -57,11 +57,11 @@ def perf_docs(func): """Decorator to Perf to write :py:class:`~sklearn.metrics` documentation""" direction = 'score-type (bigger is better)' if bib else 'error-type (smaller is better)' - func.__doc__ = f""":py:class:`~CompStats.interface.Perf` with :py:func:`~sklearn.metrics.{func.__name__}` as a {direction} :py:attr:`func.` The parameters not described can be found in :py:func:`~sklearn.metrics.{func.__name__}`. + func.__doc__ = f""":py:class:`~CompStats.interface.Perf` with :py:func:`~sklearn.metrics.{func.__name__}` as a {direction} ``func``. The parameters not described can be found in :py:func:`~sklearn.metrics.{func.__name__}`. :param y_true: True measurement or could be a pandas.DataFrame where column label 'y' corresponds to the true measurement. :type y_true: numpy.ndarray or pandas.DataFrame - :param {hy_name}: Predictions, the algorithms will be identified with alg-k where k=1 is the first argument included in :py:attr:`y_pred.` + :param {hy_name}: Predictions, the algorithms will be identified with alg-k where k=1 is the first argument included in ``{hy_name}``. :type {hy_name}: numpy.ndarray :param kwargs: Predictions, the algorithms will be identified using the keyword :type kwargs: numpy.ndarray @@ -72,7 +72,7 @@ def perf_docs(func): :param use_tqdm: Whether to use tqdm.tqdm to visualize the progress, default=True :type use_tqdm: bool - :py:func:`~CompStats.metrics.{func.__name__}.measure` builds the tagged callable used internally as :py:attr:`func`; call it directly (e.g. ``{func.__name__}.measure(...)``) to combine this metric with others into a single, multi-measure :py:class:`~CompStats.interface.Perf` -- see :py:class:`~CompStats.interface.Perf`'s class docstring for a worked example. + ``{func.__name__}.measure`` builds the tagged callable used internally as ``func``; call it directly (e.g. ``{func.__name__}.measure(...)``) to combine this metric with others into a single, multi-measure :py:class:`~CompStats.interface.Perf` -- see :py:class:`~CompStats.interface.Perf`'s class docstring for a worked example. """ + func.__doc__ diff --git a/README.rst b/README.rst index 58231b9..03da242 100644 --- a/README.rst +++ b/README.rst @@ -1,8 +1,8 @@ ==================================== CompStats ==================================== -.. image:: https://github.com/INGEOTEC/CompStats/actions/workflows/test.yaml/badge.svg - :target: https://github.com/INGEOTEC/CompStats/actions/workflows/test.yaml +.. image:: https://github.com/INGEOTEC/CompStats/actions/workflows/test.yml/badge.svg + :target: https://github.com/INGEOTEC/CompStats/actions/workflows/test.yml .. image:: https://coveralls.io/repos/github/INGEOTEC/CompStats/badge.svg?branch=develop :target: https://coveralls.io/github/INGEOTEC/CompStats?branch=develop @@ -19,85 +19,107 @@ CompStats .. image:: https://img.shields.io/conda/pn/conda-forge/compstats.svg :target: https://anaconda.org/conda-forge/compstats -.. image:: https://readthedocs.org/projects/compstats/badge/?version=latest - :target: https://compstats.readthedocs.io/en/latest/?badge=latest - -.. image:: https://colab.research.google.com/assets/colab-badge.svg - :target: https://colab.research.google.com/github/INGEOTEC/CompStats/blob/docs/docs/CompStats_metrics.ipynb - -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), four different classifiers, and the last line is the score used to measure the performance and compare the algorithm. +CompStats is an open-source Python package for the statistical analysis of the results of +supervised-learning systems evaluated on a shared held-out test set, the setting of collaborative +competitions (also called challenges). From the gold standard and the predictions of each system, +it estimates by bootstrap the standard error and the confidence interval of every performance +measure, tests whether the difference between the best system and each of the others is +statistically significant, and corrects those tests for multiple comparisons. It implements the +methodology of the article `Analysis of systems' performance in natural language processing +competitions `_ (Pattern Recognition Letters, 2024), +which complements the standard selection of a winner, usually based only on the ranking of the +scores. + +Documentation +==================================== ->>> from sklearn.svm import LinearSVC ->>> from sklearn.naive_bayes import GaussianNB ->>> from sklearn.ensemble import RandomForestClassifier ->>> from sklearn.datasets import load_digits ->>> from sklearn.model_selection import train_test_split ->>> from sklearn.base import clone ->>> from CompStats.metrics import f1_score +- Using the package: https://ingeotec.github.io/CompStats/ +- Extending the package (developer reference): https://ingeotec.github.io/CompStats/dev/ -The first step is to load the digits problem and split the dataset into training and validation sets. The second step is to estimate the parameters of a linear Support Vector Machine and predict the validation set's classes. The predictions are stored in the variable `hy`. +Installation +==================================== ->>> 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 = _ ->>> m = LinearSVC().fit(X_train, y_train) ->>> hy = m.predict(X_val) +The package is installed from PyPI with -Once the predictions are available, it is time to measure the algorithm's performance, as seen in the following code. It is essential to note that the API used in `sklearn.metrics` is followed; the difference is that the function returns an instance with different methods that can be used to estimate different performance statistics and compare algorithms. +.. code:: bash ->>> score = f1_score(y_val, hy, average='macro') ->>> score - + pip install CompStats -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` +or from conda-forge with ->>> score.statistic, score.se -(0.9521479775366307, 0.009717884979482313) +.. code:: bash -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. + conda install --channel conda-forge CompStats ->>> ens = RandomForestClassifier().fit(X_train, y_train) ->>> score(ens.predict(X_val), name='Random Forest') - -Statistic with its standard error (se) -statistic (se) -0.9720 (0.0076) <= Random Forest -0.9521 (0.0097) <= alg-1 +Quickstart +==================================== -Let us incorporate another predictions, now with Naive Bayes classifier, and Histogram Gradient Boosting as seen below. +The following example compares three classifiers on the digits problem. ->>> 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.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 +.. code:: python -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. + from sklearn.datasets import load_digits + from sklearn.ensemble import RandomForestClassifier + from sklearn.model_selection import train_test_split + from sklearn.naive_bayes import GaussianNB + from sklearn.svm import LinearSVC + from CompStats.metrics import f1_score ->>> score.plot() + X, y = load_digits(return_X_y=True) + X_train, X_val, y_train, y_val = train_test_split(X, y, test_size=0.3, random_state=0) -.. image:: https://github.com/INGEOTEC/CompStats/raw/docs/docs/source/digits_perf.png + svm = LinearSVC(random_state=0).fit(X_train, y_train) + score = f1_score(y_val, svm.predict(X_val), average='macro', name='Linear SVM') + score(RandomForestClassifier(random_state=0).fit(X_train, y_train).predict(X_val), + name='Random Forest') + score(GaussianNB().fit(X_train, y_train).predict(X_val), name='Naive Bayes') -The final step is to compare the performance of the four classifiers, which can be done with the `difference` method, as seen next. + score # point estimate and standard error of every system + score.ci # 95% percentile bootstrap confidence intervals + diff = score.difference() # paired differences against the best system + diff.p_value(correction='holm') # p-values adjusted for multiple comparisons + score.plot() # performance with confidence intervals ->>> diff = score.difference() ->>> diff - -difference p-values w.r.t Hist. Grad. Boost. Tree -0.0000 <= Naive Bayes -0.0100 <= alg-1 -0.3240 <= Random Forest +The variable ``score`` holds the point estimate and the standard error of every system, and +``score.ci`` returns the percentile confidence intervals obtained from the bootstrap +distribution. The call ``score.difference()`` computes the paired differences between the best +system and each of the others, and ``diff.p_value(correction='holm')`` returns the p-values of +those differences adjusted for multiple comparisons with Holm's method. Finally, +``score.plot()`` draws the performance of the systems together with their confidence intervals. -The class `Difference` has the `plot` method that can be used to depict the difference with respect to the best. +Citing +==================================== ->>> diff.plot() +When CompStats is used in academic work, the first reference below, which describes the +methodology, should be cited. The second is the work it extends. + +.. code:: bibtex + + @article{Nava-Munoz2024, + author = {Nava-Mu{\~n}oz, Sergio and Graff, Mario and Escalante, Hugo Jair}, + title = {Analysis of systems' performance in natural language processing competitions}, + journal = {Pattern Recognition Letters}, + volume = {186}, + pages = {346--353}, + year = {2024}, + doi = {10.1016/j.patrec.2024.03.010}, + url = {https://doi.org/10.1016/j.patrec.2024.03.010} + } + + @inproceedings{Nava-Munoz2023, + author = {Nava-Mu{\~n}oz, Sergio and Graff Guerrero, Mario and Escalante, Hugo Jair}, + title = {Comparison of Classifiers in Challenge Scheme}, + booktitle = {Pattern Recognition}, + series = {Lecture Notes in Computer Science}, + volume = {13902}, + pages = {89--98}, + year = {2023}, + publisher = {Springer Nature Switzerland}, + doi = {10.1007/978-3-031-33783-3_9}, + url = {https://doi.org/10.1007/978-3-031-33783-3_9} + } + +License +==================================== -.. image:: https://github.com/INGEOTEC/CompStats/raw/docs/docs/source/digits_difference.png +CompStats is distributed under the Apache License 2.0. See the ``LICENSE`` file. diff --git a/docs/CompStats.ipynb b/docs/CompStats.ipynb deleted file mode 100644 index a2f8c8a..0000000 --- a/docs/CompStats.ipynb +++ /dev/null @@ -1,1066 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": { - "id": "wGizC3XikMtk" - }, - "source": [ - "

\"Colaboratory

\n", - "\n", - "# CompStats\n", - "## Quickstart Guide\n", - "\n", - "### \n", - "\n" - ] - }, - { - "cell_type": "markdown", - "source": [ - "## Installing CompStats" - ], - "metadata": { - "id": "u-QV6DJYaQjg" - } - }, - { - "cell_type": "markdown", - "source": [ - "First, we need to install CompStats. This can be quickly done through pip, the Python package manager." - ], - "metadata": { - "id": "2sFWAgM0H3La" - } - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "k2UzLxhkkMtp", - "colab": { - "base_uri": "https://localhost:8080/" - }, - "outputId": "dbadd757-1706-49ed-b866-539afbe92f71" - }, - "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-_6bq9cgz\n", - " Running command git clone --filter=blob:none --quiet https://github.com/INGEOTEC/CompStats /tmp/pip-req-build-_6bq9cgz\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 324ed5d0dd10f1f92e0bc1718dca86b7f20aa7e3\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.10/dist-packages (from CompStats==0.0.6) (1.25.2)\n", - "Collecting scikit-learn>=1.3.0 (from CompStats==0.0.6)\n", - " Downloading scikit_learn-1.4.1.post1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (12.1 MB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m12.1/12.1 MB\u001b[0m \u001b[31m52.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hRequirement already satisfied: pandas in /usr/local/lib/python3.10/dist-packages (from CompStats==0.0.6) (1.5.3)\n", - "Requirement already satisfied: seaborn>=0.13.0 in /usr/local/lib/python3.10/dist-packages (from CompStats==0.0.6) (0.13.1)\n", - "Requirement already satisfied: scipy>=1.6.0 in /usr/local/lib/python3.10/dist-packages (from scikit-learn>=1.3.0->CompStats==0.0.6) (1.11.4)\n", - "Requirement already satisfied: joblib>=1.2.0 in /usr/local/lib/python3.10/dist-packages (from scikit-learn>=1.3.0->CompStats==0.0.6) (1.3.2)\n", - "Requirement already satisfied: threadpoolctl>=2.0.0 in /usr/local/lib/python3.10/dist-packages (from scikit-learn>=1.3.0->CompStats==0.0.6) (3.3.0)\n", - "Requirement already satisfied: matplotlib!=3.6.1,>=3.4 in /usr/local/lib/python3.10/dist-packages (from seaborn>=0.13.0->CompStats==0.0.6) (3.7.1)\n", - "Requirement already satisfied: python-dateutil>=2.8.1 in /usr/local/lib/python3.10/dist-packages (from pandas->CompStats==0.0.6) (2.8.2)\n", - "Requirement already satisfied: pytz>=2020.1 in /usr/local/lib/python3.10/dist-packages (from pandas->CompStats==0.0.6) (2023.4)\n", - "Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib!=3.6.1,>=3.4->seaborn>=0.13.0->CompStats==0.0.6) (1.2.0)\n", - "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.10/dist-packages (from matplotlib!=3.6.1,>=3.4->seaborn>=0.13.0->CompStats==0.0.6) (0.12.1)\n", - "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.10/dist-packages (from matplotlib!=3.6.1,>=3.4->seaborn>=0.13.0->CompStats==0.0.6) (4.49.0)\n", - "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib!=3.6.1,>=3.4->seaborn>=0.13.0->CompStats==0.0.6) (1.4.5)\n", - "Requirement already satisfied: packaging>=20.0 in /usr/local/lib/python3.10/dist-packages (from matplotlib!=3.6.1,>=3.4->seaborn>=0.13.0->CompStats==0.0.6) (23.2)\n", - "Requirement already satisfied: pillow>=6.2.0 in /usr/local/lib/python3.10/dist-packages (from matplotlib!=3.6.1,>=3.4->seaborn>=0.13.0->CompStats==0.0.6) (9.4.0)\n", - "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib!=3.6.1,>=3.4->seaborn>=0.13.0->CompStats==0.0.6) (3.1.1)\n", - "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.10/dist-packages (from python-dateutil>=2.8.1->pandas->CompStats==0.0.6) (1.16.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.0.6-py3-none-any.whl size=21031 sha256=02f09e33c6f2564d0ce77a53f833d3ce4f7848b84dfa1db8a704ec5623c640b8\n", - " Stored in directory: /tmp/pip-ephem-wheel-cache-9rlm_esy/wheels/2d/c3/e8/ce2bf346e25be45e3832a89624230b020953c537189f03f932\n", - "Successfully built CompStats\n", - "Installing collected packages: scikit-learn, CompStats\n", - " Attempting uninstall: scikit-learn\n", - " Found existing installation: scikit-learn 1.2.2\n", - " Uninstalling scikit-learn-1.2.2:\n", - " Successfully uninstalled scikit-learn-1.2.2\n", - "Successfully installed CompStats-0.0.6 scikit-learn-1.4.1.post1\n" - ] - } - ], - "source": [ - "try:\n", - " import CompStats\n", - "except ImportError:\n", - " !pip install Compstats\n", - " # !pip install -U git+https://github.com/INGEOTEC/CompStats@develop" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "pqJKAfenkMtr" - }, - "source": [ - "## Libraries" - ] - }, - { - "cell_type": "markdown", - "source": [ - "After installing `CompStats`, we must import the necessary libraries for our analysis. `CompStats` relies on several Python libraries for data analysis and scientific computing.\n", - "\n", - "The first line of the following code loads two functions from the `CompStats` library. The `performance` function is used to calculate and analyze the performance of machine learning models. On the other hand, the `plot_performance` function visualizes the performance metrics calculated by `performance`, such as accuracy or F1 score, along with confidence intervals to help understand the variability and reliability of the performance metrics.\n", - "\n", - "The second line imports two functions: `difference` and `plot_difference`; `difference` assesses the differences in performance between models in comparison to the best system, and `plot_difference` visually represents these differences relative to the best system.\n", - "\n", - "The third line imports two functions: `all_differences` and `difference_p_value`. `all_differences` evaluates the differences in performance between all models, and `difference_p_value` estimates the p-value of the hypothesis that the difference is significantly greater than zero.\n", - "\n", - "The fourth line imports the function `multipletests`that is used for adjusting p-values when multiple hypothesis tests are performed, to control for the false discovery rate or family-wise error rate.\n", - "\n", - "The rest of the lines load commonly used Python libraries." - ], - "metadata": { - "id": "ifWsyR9mH7-o" - } - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "rUVyzgMokMts" - }, - "outputs": [], - "source": [ - "from CompStats import performance, plot_performance\n", - "from CompStats import difference, plot_difference\n", - "from CompStats import all_differences, difference_p_value\n", - "from statsmodels.stats.multitest import multipletests\n", - "from sklearn.metrics import f1_score\n", - "import pandas as pd" - ] - }, - { - "cell_type": "markdown", - "source": [ - "# Dataset" - ], - "metadata": { - "id": "DWcPnzA2HI-Y" - } - }, - { - "cell_type": "markdown", - "source": [ - "Once we have set up our environment, we can explore what CompStats offers. Let's begin with a basic example of how to use CompStats for a simple statistical analysis.\n", - "\n", - "To illustrate the use of CompStats, we will use a dataset included in the CompStats package. The path of the dataset is found with the following instructions. The variable `DATA` contains the path as shown below. " - ], - "metadata": { - "id": "eKbW9vf-IASa" - } - }, - { - "cell_type": "code", - "source": [ - "from CompStats.tests.test_performance import DATA\n", - "DATA" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 36 - }, - "id": "8TGr5Jh6HIPR", - "outputId": "b16c1843-a520-4b42-b653-84aee799f963" - }, - "execution_count": null, - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "'/usr/local/lib/python3.10/dist-packages/CompStats/tests/data.csv'" - ], - "application/vnd.google.colaboratory.intrinsic+json": { - "type": "string" - } - }, - "metadata": {}, - "execution_count": 5 - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "seBE-afbkMts" - }, - "source": [ - "`DATA` contains the information to compare six systems for a multiclass classification task. The next instruction loads the data into a dataframe." - ] - }, - { - "cell_type": "code", - "source": [ - "df = pd.read_csv(DATA)" - ], - "metadata": { - "id": "WFo5qGVGI5fg" - }, - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "markdown", - "source": [ - "The first five rows of `df` are shown below. It can be observed that the first column contains the gold standard, identified with `y`, and the rest of the columns are the predictions performed by different systems." - ], - "metadata": { - "id": "CnOx0jOAJw6H" - } - }, - { - "cell_type": "code", - "source": [ - "df.head(5)" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 206 - }, - "id": "PxDOXB8QJ2yT", - "outputId": "08dad3e6-bdf9-4c72-848f-5576ccd383cc" - }, - "execution_count": null, - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": [ - " y BoW (Corpus) BoW INGEOTEC BoW (Class Weight) Dense StackBoW\n", - "0 0 2 2 2 2 2 2\n", - "1 6 6 6 6 6 5 6\n", - "2 7 5 5 5 5 5 5\n", - "3 5 4 4 4 4 5 4\n", - "4 4 7 5 4 6 6 6" - ], - "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", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
yBoW (Corpus)BoWINGEOTECBoW (Class Weight)DenseStackBoW
00222222
16666656
27555555
35444454
44754666
\n", - "
\n", - "
\n", - "\n", - "
\n", - " \n", - "\n", - " \n", - "\n", - " \n", - "
\n", - "\n", - "\n", - "
\n", - " \n", - "\n", - "\n", - "\n", - " \n", - "
\n", - "\n", - "
\n", - "
\n" - ], - "application/vnd.google.colaboratory.intrinsic+json": { - "type": "dataframe", - "variable_name": "df", - "summary": "{\n \"name\": \"df\",\n \"rows\": 1580,\n \"fields\": [\n {\n \"column\": \"y\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 1,\n \"min\": 0,\n \"max\": 7,\n \"num_unique_values\": 8,\n \"samples\": [\n 6,\n 1,\n 0\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"BoW (Corpus)\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 1,\n \"min\": 0,\n \"max\": 7,\n \"num_unique_values\": 8,\n \"samples\": [\n 6,\n 1,\n 2\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"BoW\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 1,\n \"min\": 0,\n \"max\": 7,\n \"num_unique_values\": 8,\n \"samples\": [\n 6,\n 0,\n 2\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"INGEOTEC\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 1,\n \"min\": 0,\n \"max\": 7,\n \"num_unique_values\": 8,\n \"samples\": [\n 6,\n 7,\n 2\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"BoW (Class Weight)\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 1,\n \"min\": 0,\n \"max\": 7,\n \"num_unique_values\": 8,\n \"samples\": [\n 6,\n 3,\n 2\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Dense\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 2,\n \"min\": 0,\n \"max\": 7,\n \"num_unique_values\": 8,\n \"samples\": [\n 5,\n 7,\n 2\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"StackBoW\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 1,\n \"min\": 0,\n \"max\": 7,\n \"num_unique_values\": 8,\n \"samples\": [\n 6,\n 7,\n 2\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}" - } - }, - "metadata": {}, - "execution_count": 7 - } - ] - }, - { - "cell_type": "markdown", - "source": [ - "# Performance Anaylisis" - ], - "metadata": { - "id": "sqI3FxmCI_pM" - } - }, - { - "cell_type": "markdown", - "source": [ - "Let us start with the performance analysis of the different systems. The performance metric used is the weighted average F1 score. This performance is coded in the variable `score` as observed in the next instruction." - ], - "metadata": { - "id": "JR1B0lg4K85m" - } - }, - { - "cell_type": "code", - "source": [ - "score = lambda y, hy: f1_score(y, hy, average='weighted')" - ], - "metadata": { - "id": "IXHA4HRkLA9q" - }, - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "markdown", - "source": [ - "The next step is to compute the performance on the bootstrap samples; this is done with the function `performance`. The function has a few parameters; one is the `score`, which receives the metric used to measure the performance." - ], - "metadata": { - "id": "xYCMtk-1LZtL" - } - }, - { - "cell_type": "code", - "source": [ - "perf = performance(df, score=score, num_samples=1000)" - ], - "metadata": { - "id": "-96k0EbaLadL", - "colab": { - "base_uri": "https://localhost:8080/" - }, - "outputId": "cba38610-383b-402e-e8e2-f0fcdea5908e" - }, - "execution_count": null, - "outputs": [ - { - "output_type": "stream", - "name": "stderr", - "text": [ - "100%|██████████| 7/7 [00:45<00:00, 6.49s/it]\n" - ] - } - ] - }, - { - "cell_type": "markdown", - "source": [ - "`perf` is an instance of `StatisticSamples`, the bootstrap samples can be seen on the property `calls`. The first five bootstrap samples of the performance of INGEOTEC are shown below. -- It verifies that the key is in the dictionary in case the dataset has been changed. --" - ], - "metadata": { - "id": "sEfBLwenQpND" - } - }, - { - "cell_type": "code", - "source": [ - "if 'INGEOTEC' in perf.calls:\n", - " print(f\"{perf.calls['INGEOTEC'][:5]}\")" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "IrbRfFuCQsGf", - "outputId": "995bf6f7-02d8-4526-de25-4e56151d7f3b" - }, - "execution_count": null, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "[0.3874702 0.39732444 0.37726143 0.39129092 0.39357105]\n" - ] - } - ] - }, - { - "cell_type": "markdown", - "source": [ - "The performance of the systems, along with their confidence intervals, can be seen using the next instruction." - ], - "metadata": { - "id": "SaUGXqEVJE6A" - } - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 506 - }, - "id": "djiadR9dkMts", - "outputId": "fbd0675c-0933-4d6e-e142-633394526b61" - }, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": {} - } - ], - "source": [ - "face_grid = plot_performance(perf)" - ] - }, - { - "cell_type": "markdown", - "source": [ - "It can be observed that the best system is INGEOTEC. Although the confidence intervals provide information that helps to assess the difference in the performance of the systems, in this case, the intervals intersect. Therefore, one needs another statistical tool to determine if the difference in performance is significant." - ], - "metadata": { - "id": "eBmUNHXWR2pL" - } - }, - { - "cell_type": "markdown", - "metadata": { - "id": "hJ1gAxzkkMts" - }, - "source": [ - "# Performance Comparison against the Winner" - ] - }, - { - "cell_type": "markdown", - "source": [ - "The difference in their performance compared to the best-performing system can be used to compare the algorithms analyzed. The function `difference` computes the difference as shown below." - ], - "metadata": { - "id": "peFwDTsNdRiz" - } - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "0FXWINpdkMtt" - }, - "outputs": [], - "source": [ - "diff = difference(perf)" - ] - }, - { - "cell_type": "markdown", - "source": [ - "`diff` is an instance of `StatisticSamples`; one can find the best system on the property `info`, as the following instruction shows." - ], - "metadata": { - "id": "2p_ppDE9dV0F" - } - }, - { - "cell_type": "code", - "source": [ - "diff.info" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "7oz3wbr6dr_m", - "outputId": "a4b5e252-dcbe-4345-c5e5-e84acd3edce7" - }, - "execution_count": null, - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "{'best': 'INGEOTEC'}" - ] - }, - "metadata": {}, - "execution_count": 13 - } - ] - }, - { - "cell_type": "markdown", - "source": [ - "The difference in performance can be visualized with the following instruction." - ], - "metadata": { - "id": "iD_jAdwmd5QZ" - } - }, - { - "cell_type": "code", - "source": [ - "face_grid_diff = plot_difference(diff)" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 529 - }, - "id": "obO7DOUWdW52", - "outputId": "38b7de59-4aea-43b7-d3dc-eae94c6f19d6" - }, - "execution_count": null, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": {} - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "aHlFz543kMtt" - }, - "source": [ - "From the performance graphs, for this example, we can observe that the ranking is *INGEOTEC*, *BoW*, *StackBoW*, *BoW (Corpus)*, *Dense*, *Bow (Class Weight)*. Hence, in the last graph, we analyze the performance difference against the winner (INGEOTEC). From this graph, we can conclude that *BoW* and *StackBoW*, might perform similarly to INGEOTEC. As can be seen, *Dense* is practically on the border between being significant and not significant.\n", - "\n", - "Should we test the hypothesis of equality versus difference, considering that one system outperforms the other in the test? To address this question, we compare the performance of two systems, $A$ and $B$, to determine whether $A$ is superior to $B$ in a larger data population, represented as $\\theta_A > \\theta_B$. We can estimate the p-value associated with the hypothesis test $H_0: \\theta_A \\le \\theta_B$ vs $H_1: \\theta_A > \\theta_B$ given the data, equivalently $H_0: \\theta_A< - \\theta_B\\le 0$ vs $H_1: \\theta_A - \\theta_B > 0$. The p-values for these differences can be estimated using the following instruction, comparing them against the winner (INGEOTEC) to determine the probability that $a$ (INGEOTEC) is better than $b$.\n", - "\n", - "The `difference_p_value` function estimates the p-value for each difference in comparison to the best system, as illustrated below.\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "83DAxZ18kMtt" - }, - "outputs": [], - "source": [ - "p_values = difference_p_value(diff)" - ] - }, - { - "cell_type": "markdown", - "source": [ - "For a given $\\alpha$ level, p-values smaller than $\\alpha$ are significant, meaning the observed difference is unlikely to be due to chance. An $\\alpha$ level of 0.05 is commonly used." - ], - "metadata": { - "id": "WEEPzr4l2BMn" - } - }, - { - "cell_type": "code", - "source": [ - "p_values" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "p2VtUMvS0Z4k", - "outputId": "6a3cf917-98da-46ed-a103-4faf13725e53" - }, - "execution_count": null, - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "{'BoW (Class Weight)': 0.001,\n", - " 'Dense': 0.032,\n", - " 'BoW (Corpus)': 0.006,\n", - " 'StackBoW': 0.091,\n", - " 'BoW': 0.265}" - ] - }, - "metadata": {}, - "execution_count": 16 - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "rt21qMcDkMtu" - }, - "source": [ - "# Performance comparison between all models\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "6ehkDIH_kMtu" - }, - "outputs": [], - "source": [ - "all_diff = all_differences(perf)" - ] - }, - { - "cell_type": "markdown", - "source": [ - "Once again, we use the function `difference_p_value` to estimate the p-value." - ], - "metadata": { - "id": "CC2hR4w_4IzC" - } - }, - { - "cell_type": "code", - "source": [ - "p_values = difference_p_value(all_diff)" - ], - "metadata": { - "id": "x2vlIMNc3h5W" - }, - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "markdown", - "source": [ - "And we can analyze from all pairs of systems individually which ones have significantly different performances by comparing their p-value with $\\alpha$." - ], - "metadata": { - "id": "192xc-_24chZ" - } - }, - { - "cell_type": "code", - "source": [ - "p_values" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "l5hRhylS3jh2", - "outputId": "b06cbf00-2d24-4714-e749-6210b2d96001" - }, - "execution_count": null, - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "{'INGEOTEC - BoW': 0.265,\n", - " 'INGEOTEC - StackBoW': 0.091,\n", - " 'INGEOTEC - BoW (Corpus)': 0.006,\n", - " 'INGEOTEC - Dense': 0.032,\n", - " 'INGEOTEC - BoW (Class Weight)': 0.001,\n", - " 'BoW - StackBoW': 0.374,\n", - " 'BoW - BoW (Corpus)': 0.099,\n", - " 'BoW - Dense': 0.14,\n", - " 'BoW - BoW (Class Weight)': 0.04,\n", - " 'StackBoW - BoW (Corpus)': 0.11,\n", - " 'StackBoW - Dense': 0.148,\n", - " 'StackBoW - BoW (Class Weight)': 0.024,\n", - " 'BoW (Corpus) - Dense': 0.451,\n", - " 'BoW (Corpus) - BoW (Class Weight)': 0.204,\n", - " 'Dense - BoW (Class Weight)': 0.38}" - ] - }, - "metadata": {}, - "execution_count": 19 - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "NS3RHI9SkMtu" - }, - "source": [ - "When conducting numerous comparisons or hypothesis tests on a dataset, the risk of incurring Type I errors (incorrectly dismissing a valid null hypothesis) increases. This happens because more tests performed increase the probability of randomly identifying statistically significant outcomes. Implementing adjustments for multiple comparisons is critical for several reasons: (1) To manage the risk of Type I Error, (2) To prevent erroneous conclusions, and (3) To uphold the integrity of the research.\n", - "\n", - "The following code illustrates the effect of these methods for multiple comparison corrections. The function `multipletests` makes the p-value correction by selecting the parameter `method`. In this example, the Bonferroni correction method is used." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "V1J_cqfdkMtu" - }, - "outputs": [], - "source": [ - "result = multipletests(list(p_values.values()), method='bonferroni')" - ] - }, - { - "cell_type": "markdown", - "source": [ - "`result` is an array; next, we convert it back into a dictionary." - ], - "metadata": { - "id": "e2myRaBo6mPf" - } - }, - { - "cell_type": "code", - "source": [ - "p_valuesC = dict(zip(p_values.keys(),result[1]))" - ], - "metadata": { - "id": "MSaGBndz6G6t" - }, - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "markdown", - "source": [ - "And we can analyze from all pairs of systems simunstally which ones have significantly different performances by comparing their p-value with $\\alpha$." - ], - "metadata": { - "id": "FY-9W45Q7nId" - } - }, - { - "cell_type": "code", - "source": [ - "p_valuesC" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "SKiKx3GU6IlN", - "outputId": "94dd212d-dcae-4ec3-92f0-7397f5bd91a7" - }, - "execution_count": null, - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "{'INGEOTEC - BoW': 1.0,\n", - " 'INGEOTEC - StackBoW': 1.0,\n", - " 'INGEOTEC - BoW (Corpus)': 0.09,\n", - " 'INGEOTEC - Dense': 0.48,\n", - " 'INGEOTEC - BoW (Class Weight)': 0.015,\n", - " 'BoW - StackBoW': 1.0,\n", - " 'BoW - BoW (Corpus)': 1.0,\n", - " 'BoW - Dense': 1.0,\n", - " 'BoW - BoW (Class Weight)': 0.6,\n", - " 'StackBoW - BoW (Corpus)': 1.0,\n", - " 'StackBoW - Dense': 1.0,\n", - " 'StackBoW - BoW (Class Weight)': 0.36,\n", - " 'BoW (Corpus) - Dense': 1.0,\n", - " 'BoW (Corpus) - BoW (Class Weight)': 1.0,\n", - " 'Dense - BoW (Class Weight)': 1.0}" - ] - }, - "metadata": {}, - "execution_count": 22 - } - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "py311", - "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.11.7" - }, - "colab": { - "provenance": [] - } - }, - "nbformat": 4, - "nbformat_minor": 0 -} \ No newline at end of file diff --git a/docs/CompStats_metrics.ipynb b/docs/CompStats_metrics.ipynb deleted file mode 100644 index ef3556f..0000000 --- a/docs/CompStats_metrics.ipynb +++ /dev/null @@ -1,433 +0,0 @@ -{ - "nbformat": 4, - "nbformat_minor": 0, - "metadata": { - "colab": { - "provenance": [] - }, - "kernelspec": { - "name": "python3", - "display_name": "Python 3" - }, - "language_info": { - "name": "python" - } - }, - "cells": [ - { - "cell_type": "markdown", - "source": [ - "

\"Colaboratory

\n", - "\n", - "# CompStats.metrics\n", - "## Quickstart Guide\n", - "\n", - "### \n" - ], - "metadata": { - "id": "9tXZR4hZ2jdf" - } - }, - { - "cell_type": "markdown", - "source": [ - "## Installing CompStats" - ], - "metadata": { - "id": "FZ57oNPm2qLs" - } - }, - { - "cell_type": "markdown", - "source": [ - "First, we need to install CompStats. This can be quickly done through pip, the Python package manager." - ], - "metadata": { - "id": "W53AmtM423gh" - } - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "I1B4Ktin2VfE" - }, - "outputs": [], - "source": [ - "try:\n", - " import CompStats\n", - "except ImportError:\n", - " !pip install Compstats\n", - " # !pip install -U git+https://github.com/INGEOTEC/CompStats@develop" - ] - }, - { - "cell_type": "markdown", - "source": [ - "# CompStats.metrics" - ], - "metadata": { - "id": "uN4SNyGE3Fmh" - } - }, - { - "cell_type": "markdown", - "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), four different classifiers, and the last line is the score used to measure the performance and compare the algorithm." - ], - "metadata": { - "id": "ZyRCAFoJ3LzP" - } - }, - { - "cell_type": "code", - "source": [ - "from sklearn.svm import LinearSVC\n", - "from sklearn.naive_bayes import GaussianNB\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", - "from CompStats.metrics import f1_score" - ], - "metadata": { - "id": "jEpd52Kq214r" - }, - "execution_count": 12, - "outputs": [] - }, - { - "cell_type": "markdown", - "source": [ - "The first step is to load the digits problem and split the dataset into training and validation sets. The second step is to estimate the parameters of a linear Support Vector Machine and predict the validation set's classes. The predictions are stored in the variable `hy`." - ], - "metadata": { - "id": "TxaP-fJ23YvG" - } - }, - { - "cell_type": "code", - "source": [ - "X, y = load_digits(return_X_y=True)\n", - "_ = train_test_split(X, y, test_size=0.3)\n", - "X_train, X_val, y_train, y_val = _\n", - "m = LinearSVC().fit(X_train, y_train)\n", - "hy = m.predict(X_val)" - ], - "metadata": { - "id": "JGJczaOW3WeK" - }, - "execution_count": 13, - "outputs": [] - }, - { - "cell_type": "markdown", - "source": [ - "Once the predictions are available, it is time to measure the algorithm's performance, as seen in the following code. It is essential to note that the API used in `metrics` is followed; the difference is that the function returns an instance with different methods that can be used to estimate different performance statistics and compare algorithms." - ], - "metadata": { - "id": "wmFDblVe3eLm" - } - }, - { - "cell_type": "code", - "source": [ - "score = f1_score(y_val, hy, average='macro')\n", - "score" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "Al0u9ZPB3cSj", - "outputId": "6eb7e800-b835-46af-84d8-16c3ad214d58" - }, - "execution_count": 14, - "outputs": [ - { - "output_type": "stream", - "name": "stderr", - "text": [ - "100%|██████████| 1/1 [00:00<00:00, 1.03it/s]\n" - ] - }, - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "" - ] - }, - "metadata": {}, - "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 attributes `statistic` function, and `se`." - ], - "metadata": { - "id": "OV5-SrTh3loq" - } - }, - { - "cell_type": "code", - "source": [ - "score.statistic, score.se" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "Ye1HH4pn3jde", - "outputId": "3c7c9e30-06fa-4e62-b0ea-6eb53012af01" - }, - "execution_count": 15, - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "(0.9521479775366307, 0.009717884979482313)" - ] - }, - "metadata": {}, - "execution_count": 15 - } - ] - }, - { - "cell_type": "markdown", - "source": [ - "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." - ], - "metadata": { - "id": "BZho0vEB3q9G" - } - }, - { - "cell_type": "code", - "source": [ - "ens = RandomForestClassifier().fit(X_train, y_train)\n", - "score(ens.predict(X_val), name='Random Forest')" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "vboh7N9B3pDr", - "outputId": "73b9de04-f3b7-4a17-d2a7-09dc453c8f4e" - }, - "execution_count": 16, - "outputs": [ - { - "output_type": "stream", - "name": "stderr", - "text": [ - "100%|██████████| 1/1 [00:00<00:00, 1.03it/s]\n" - ] - }, - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "\n", - "Statistic with its standard error (se)\n", - "statistic (se)\n", - "0.9720 (0.0076) <= Random Forest\n", - "0.9521 (0.0097) <= alg-1" - ] - }, - "metadata": {}, - "execution_count": 16 - } - ] - }, - { - "cell_type": "markdown", - "source": [ - "Let us incorporate another predictions, now with Naive Bayes classifier, and Histogram Gradient Boosting as seen below." - ], - "metadata": { - "id": "v2R8F5H73vuc" - } - }, - { - "cell_type": "code", - "source": [ - "nb = GaussianNB().fit(X_train, y_train)\n", - "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": "a38ce6fe-cadd-4f85-d127-423d66c2947b" - }, - "execution_count": 17, - "outputs": [ - { - "output_type": "stream", - "name": "stderr", - "text": [ - "100%|██████████| 2/2 [00:02<00:00, 1.00s/it]\n" - ] - }, - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "\n", - "Statistic with its standard error (se)\n", - "statistic (se)\n", - "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": 17 - } - ] - }, - { - "cell_type": "markdown", - "source": [ - "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" - } - }, - { - "cell_type": "code", - "source": [ - "diff = score.difference()\n", - "diff" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "XWAqUpYE3za2", - "outputId": "2804fcd4-d766-4de5-ee27-276d4d7f3324" - }, - "execution_count": 22, - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "\n", - "difference p-values w.r.t Hist. Grad. Boost. Tree\n", - "0.0000 <= Naive Bayes\n", - "0.0100 <= alg-1\n", - "0.3240 <= Random Forest" - ] - }, - "metadata": {}, - "execution_count": 22 - } - ] - }, - { - "cell_type": "markdown", - "source": [ - "The class `CompStats.Difference` has the `CompStats.Difference.plot` method that can be used to depict the difference with respectto the best." - ], - "metadata": { - "id": "NnFumtpc4BBC" - } - }, - { - "cell_type": "code", - "source": [ - "diff.plot()" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 529 - }, - "id": "Fai01O3q3-SN", - "outputId": "a5aaacce-74fc-42dc-86dc-09512421ffbe" - }, - "execution_count": 23, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "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/requirements.txt b/docs/requirements.txt new file mode 100644 index 0000000..2b4971b --- /dev/null +++ b/docs/requirements.txt @@ -0,0 +1,5 @@ +# Build-time dependencies for the Sphinx developer reference. CompStats itself is +# installed normally (pip install -e .) by the workflows that build these docs. +sphinx>=7 +furo +sphinxcontrib-mermaid diff --git a/docs/source/conf.py b/docs/source/conf.py index 89222ca..a151430 100644 --- a/docs/source/conf.py +++ b/docs/source/conf.py @@ -1,179 +1,63 @@ -# -*- coding: utf-8 -*- -# # Configuration file for the Sphinx documentation builder. # -# This file does only contain a selection of the most common options. For a -# full list see the documentation: -# http://www.sphinx-doc.org/en/master/config - -# -- Path setup -------------------------------------------------------------- +# For a full list of options see: +# https://www.sphinx-doc.org/en/master/usage/configuration.html -# If extensions (or modules to document with autodoc) are in another directory, -# add these directories to sys.path here. If the directory is relative to the -# documentation root, use os.path.abspath to make it absolute, like shown here. +# -- Path setup --------------------------------------------------------- # -import os -import sys -sys.path.insert(0, os.path.abspath('../..')) -import CompStats +# CompStats is installed (editable) by the builds that render these docs +# (.github/workflows/test.yml and website.yml), so conf.py only imports the +# installed package to read its __version__. +import CompStats -# -- Project information ----------------------------------------------------- +# -- Project information ------------------------------------------------- project = 'CompStats' -copyright = '2024, Sergio Nava, Mario Graff, Hugo Jair Escalante' +copyright = '2024, Sergio Nava-Muñoz, Mario Graff, Hugo Jair Escalante' author = 'Sergio Nava-Muñoz, Mario Graff, Hugo Jair Escalante' - -# The short X.Y version version = CompStats.__version__ -# The full version, including alpha/beta/rc tags release = version +rst_epilog = f""" +.. |compstats_version| replace:: {CompStats.__version__} +""" -# -- General configuration --------------------------------------------------- - -# If your documentation needs a minimal Sphinx version, state it here. -# -# needs_sphinx = '1.0' +# -- General configuration ------------------------------------------------ -# Add any Sphinx extension module names here, as strings. They can be -# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom -# ones. extensions = [ 'sphinx.ext.autodoc', - 'sphinx.ext.doctest', - 'sphinx.ext.coverage', 'sphinx.ext.mathjax', 'sphinx.ext.viewcode', - 'sphinx.ext.intersphinx' + 'sphinx.ext.intersphinx', + 'sphinxcontrib.mermaid', ] -#  intersphinx_mapping = {} -intersphinx_mapping = {'sklearn': ('https://scikit-learn.org/stable/', None)} - -# Add any paths that contain templates here, relative to this directory. -templates_path = ['_templates'] +intersphinx_mapping = { + 'python': ('https://docs.python.org/3', None), + 'numpy': ('https://numpy.org/doc/stable/', None), + 'pandas': ('https://pandas.pydata.org/docs/', None), + 'scipy': ('https://docs.scipy.org/doc/scipy/', None), + 'sklearn': ('https://scikit-learn.org/stable/', None), + 'statsmodels': ('https://www.statsmodels.org/stable/', None), + 'seaborn': ('https://seaborn.pydata.org/', None), + 'matplotlib': ('https://matplotlib.org/stable/', None), +} -# The suffix(es) of source filenames. -# You can specify multiple suffix as a list of string: -# -# source_suffix = ['.rst', '.md'] source_suffix = '.rst' - -# The master toctree document. master_doc = 'index' - -# The language for content autogenerated by Sphinx. Refer to documentation -# for a list of supported languages. -# -# This is also used if you do content translation via gettext catalogs. -# Usually you set "language" from the command line for these cases. language = 'en' - -# List of patterns, relative to source directory, that match files and -# directories to ignore when looking for source files. -# This pattern also affects html_static_path and html_extra_path . exclude_patterns = [] -# The name of the Pygments (syntax highlighting) style to use. pygments_style = 'sphinx' highlight_language = 'python' -# autoclass_content = 'both' autodoc_member_order = 'bysource' autodoc_class_signature = 'separated' add_function_parentheses = False add_module_names = False -# -- Options for HTML output ------------------------------------------------- - -# The theme to use for HTML and HTML Help pages. See the documentation for -# a list of builtin themes. -# -html_theme = 'classic' - -# Theme options are theme-specific and customize the look and feel of a theme -# further. For a list of options available for each theme, see the -# documentation. -# -html_theme_options = { - "rightsidebar": "false", - "relbarbgcolor": "black", - "sidebarbgcolor": "white", - "sidebartextcolor": "black" -} - -# Add any paths that contain custom static files (such as style sheets) here, -# relative to this directory. They are copied after the builtin static files, -# so a file named "default.css" will overwrite the builtin "default.css". -#  html_static_path = ['_static'] - -# Custom sidebar templates, must be a dictionary that maps document names -# to template names. -# -# The default sidebars (for documents that don't match any pattern) are -# defined by theme itself. Builtin themes are using these templates by -# default: ``['localtoc.html', 'relations.html', 'sourcelink.html', -# 'searchbox.html']``. -# -# html_sidebars = {} - - -# -- Options for HTMLHelp output --------------------------------------------- +# -- Options for HTML output ---------------------------------------------- -# Output file base name for HTML help builder. -htmlhelp_basename = 'CompStatsdoc' +html_theme = 'furo' html_logo = 'ingeotec.png' - - -# -- Options for LaTeX output ------------------------------------------------ - -latex_elements = { - # The paper size ('letterpaper' or 'a4paper'). - # - # 'papersize': 'letterpaper', - - # The font size ('10pt', '11pt' or '12pt'). - # - # 'pointsize': '10pt', - - # Additional stuff for the LaTeX preamble. - # - # 'preamble': '', - - # Latex figure (float) alignment - # - # 'figure_align': 'htbp', -} - -# Grouping the document tree into LaTeX files. List of tuples -# (source start file, target name, title, -# author, documentclass [howto, manual, or own class]). -latex_documents = [ - (master_doc, 'CompStats.tex', 'CompStats Documentation', - 'Sergio Nava-Muñoz, Mario Graff, Hugo Jair Escalante', 'manual'), -] - - -# -- Options for manual page output ------------------------------------------ - -# One entry per manual page. List of tuples -# (source start file, name, description, authors, manual section). -man_pages = [ - (master_doc, 'CompStats', 'CompStats Documentation', - [author], 1) -] - - -# -- Options for Texinfo output ---------------------------------------------- - -# Grouping the document tree into Texinfo files. List of tuples -# (source start file, target name, title, author, -# dir menu entry, description, category) -texinfo_documents = [ - (master_doc, 'CompStats', 'CompStats Documentation', - author, 'CompStats', 'One line description of project.', - 'Miscellaneous'), -] - - -# -- Extension configuration ------------------------------------------------- +htmlhelp_basename = 'CompStatsdoc' diff --git a/docs/source/index.rst b/docs/source/index.rst index bd494de..e844d6e 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -3,11 +3,12 @@ ==================================== CompStats ==================================== + .. image:: https://img.shields.io/badge/GitHub-CompStats-black?logo=github :target: https://github.com/INGEOTEC/CompStats -.. image:: https://github.com/INGEOTEC/CompStats/actions/workflows/test.yaml/badge.svg - :target: https://github.com/INGEOTEC/CompStats/actions/workflows/test.yaml +.. image:: https://github.com/INGEOTEC/CompStats/actions/workflows/test.yml/badge.svg + :target: https://github.com/INGEOTEC/CompStats/actions/workflows/test.yml .. image:: https://coveralls.io/repos/github/INGEOTEC/CompStats/badge.svg?branch=develop :target: https://coveralls.io/github/INGEOTEC/CompStats?branch=develop @@ -24,260 +25,343 @@ CompStats .. image:: https://img.shields.io/conda/pn/conda-forge/compstats.svg :target: https://anaconda.org/conda-forge/compstats -.. image:: https://readthedocs.org/projects/compstats/badge/?version=latest - :target: https://compstats.readthedocs.io/en/latest/?badge=latest - -.. image:: https://colab.research.google.com/assets/colab-badge.svg - :target: https://colab.research.google.com/github/INGEOTEC/CompStats/blob/docs/docs/CompStats.ipynb +Version |compstats_version|. +.. note:: -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. :py:class:`CompStats` implements an evaluation methodology for statistically analyzing competition results and competition. :py:class:`CompStats` offers several advantages, including off-the-shell comparisons with correction mechanisms and the inclusion of confidence intervals. + This is the **developer reference** of **CompStats**: the architecture of the package and the + complete API. Installation, tutorials and the description of the methodology for users are + published on the project site, https://ingeotec.github.io/CompStats/. -Quickstart Guide +Introduction ==================================== -The first step is to install CompStats, which is described below. - -Installing CompStats -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - -The first step is to install the library, which can be done using the `conda package manager `_ with the following instruction. - -.. code:: bash - - conda install -c conda-forge CompStats - -A more general approach to installing CompStats is through the use of the command pip, as illustrated in the following instruction. - -.. code:: bash - - pip install CompStats - -Libraries used -^^^^^^^^^^^^^^^^^^^^^ - -After installing :py:class:`CompStats`, we must import the necessary libraries for our analysis. :py:class:`CompStats` relies on several Python libraries for data analysis and scientific computing. - -The first line of the following code loads two functions from the :py:class:`CompStats` library. The :py:func:`~CompStats.performance.performance` function is used to calculate and analyze the performance of machine learning models. On the other hand, the :py:func:`~CompStats.performance.plot_performance` function visualizes the performance metrics calculated by :py:func:`~CompStats.performance.performance`, such as accuracy or F1 score, along with confidence intervals to help understand the variability and reliability of the performance metrics. - -The second line imports two functions: :py:func:`~CompStats.performance.difference` and :py:func:`~CompStats.performance.plot_difference`; :py:func:`~CompStats.performance.difference` assesses the differences in performance between models in comparison to the best system, and :py:func:`~CompStats.performance.plot_difference` visually represents these differences relative to the best system. - -The third line imports two functions: :py:func:`~CompStats.performance.all_differences` and :py:func:`~CompStats.measurements.difference_p_value`. :py:func:`~CompStats.performance.all_differences` evaluates the differences in performance between all models, and :py:func:`~CompStats.measurements.difference_p_value` estimates the p-value of the hypothesis that the difference is significantly greater than zero. - -The fourth line imports the function :py:func:`multipletests` that is used for adjusting p-values when multiple hypothesis tests are performed, to control for the false discovery rate or family-wise error rate. - -The rest of the lines load commonly used Python libraries. - -.. code-block:: python - - >>> from CompStats import performance, plot_performance - >>> from CompStats import difference, plot_difference - >>> from CompStats import all_differences, difference_p_value - >>> from statsmodels.stats.multitest import multipletests - >>> from sklearn.metrics import f1_score - >>> import pandas as pd - -Dataset -^^^^^^^^^^^^^^^^^^^^^ - -Once we have set up our environment, we can explore what CompStats offers. Let's begin with a basic example of how to use CompStats for a simple statistical analysis. - -To illustrate the use of CompStats, we will use a dataset included in the CompStats package. The path of the dataset is found with the following instructions. The variable :py:attr:`DATA` contains the path as shown below. - -.. code-block:: python - - >>> from CompStats.tests.test_performance import DATA - >>> DATA - '/usr/local/lib/python3.10/dist-packages/CompStats/tests/data.csv' - - -:py:attr:`DATA` contains the information to compare six systems for a multiclass classification task. The next instruction loads the data into a dataframe. - -.. code-block:: python - - >>> df = pd.read_csv(DATA) - -It can be observed that the first column contains the gold standard, identified with :py:attr:`y`, and the rest of the columns are the predictions performed by different systems. - -.. code-block:: python - - >>> df.columns - Index(['y', 'BoW (Corpus)', 'BoW', 'INGEOTEC', - 'BoW (Class Weight)', 'Dense', 'StackBoW'], - dtype='object') - -Performance Analysis -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - -Let us start with the performance analysis of the different systems. The performance metric used is the weighted average F1 score. This performance is coded in the variable :py:attr:`score` as observed in the next instruction. - -.. code-block:: python - - >>> score = lambda y, hy: f1_score(y, hy, average='weighted') - -The next step is to compute the performance on the bootstrap samples; this is done with the function :py:func:`~CompStats.performance.performance`. The function has a few parameters; one is the :py:attr:`score`, which receives the metric used to measure the performance. - -.. code-block:: python - - >>> perf = performance(df, score=score, num_samples=1000) - -:py:attr:`perf` is an instance of :py:class:`~CompStats.bootstrap.StatisticSamples`, the bootstrap samples can be seen on the property :py:attr:`calls`. The first five bootstrap samples of the performance of INGEOTEC are shown below. - -.. code-block:: python - - >>> perf.calls['INGEOTEC'][:5] - [0.37056471 0.38665852 0.36580968 0.39611708 0.39422416] +Collaborative competitions (challenges) evaluate systems on a single held-out test set whose gold +standard is kept by the organizers. The systems are ranked by a performance measure computed on that +set. The organizers have access only to the predictions, to a fixed dataset size and to a small +number of submissions; consequently, the classical statistical tests that require access to the +algorithm, or that require performance estimates on several datasets, do not apply. + +**CompStats** implements a bootstrap-based methodology that complements the ranking with standard +errors, confidence intervals, significance tests of paired differences and corrections for multiple +comparisons. The same setting covers any comparison of supervised-learning systems on a shared +test set, whether the task is classification or regression. The methodology is described in +*Analysis of systems' performance in natural language processing competitions* +(`doi:10.1016/j.patrec.2024.03.010 `_), which extends +*Comparison of Classifiers in Challenge Scheme* +(`doi:10.1007/978-3-031-33783-3_9 `_). + +Statistical background +==================================== -The performance of the systems, along with their confidence intervals, can be seen using the next instruction. +Each concept below is stated with its formula and the symbol of the package that computes it. -.. code-block:: python +**Setting.** Let :math:`y` be a gold standard of size :math:`n`, let +:math:`\hat{y}_1, \ldots, \hat{y}_m` be the predictions of :math:`m` systems, and let +:math:`s(y, \hat{y})` be a performance measure. A measure is either bigger-is-better (a score) or +smaller-is-better (an error); the flag ``BiB`` carries that direction. - >>> face_grid = plot_performance(perf) +**Bootstrap.** :math:`B` samples (``num_samples``, default 500) of :math:`n` indices are drawn with +replacement from :math:`\{1, \ldots, n\}`. The measure is evaluated on every sample for every +system, which gives the bootstrap distribution :math:`s_j^{*1}, \ldots, s_j^{*B}` of system +:math:`j` (:py:class:`~CompStats.bootstrap.StatisticSamples`). The **same** index samples are used +for all the systems, which is what makes the comparisons paired. -.. image:: performance.png +**Standard error.** The standard deviation of the bootstrap distribution, +.. math:: -It can be observed that the best system is INGEOTEC. Although the confidence intervals provide information that helps to assess the difference in the performance of the systems, in this case, the intervals intersect. Therefore, one needs another statistical tool to determine if the difference in performance is significant. + \widehat{\mathrm{SE}}_j = \sqrt{\frac{1}{B} \sum_{b=1}^{B} \left(s_j^{*b} - \bar{s}_j^{*}\right)^2}, + \qquad \bar{s}_j^{*} = \frac{1}{B} \sum_{b=1}^{B} s_j^{*b}, -Performance Comparison against the Winner -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +computed by :py:func:`~CompStats.measurements.SE` and exposed as the ``se`` property of +:py:class:`~CompStats.interface.Perf`. -The difference in their performance compared to the best-performing system can be used to compare the algorithms analyzed. The function :py:func:`~CompStats.performance.difference` computes the difference as shown below. +**Confidence interval.** The percentile interval -.. code-block:: python - - >>> diff = difference(perf) +.. math:: -:py:attr:`diff` is an instance of :py:class:`~CompStats.bootstrap.StatisticSamples`; one can find the best system on the property :py:attr:`info`, as the following instruction shows. + \left[ q_{\alpha/2}(s_j^{*}),\; q_{1-\alpha/2}(s_j^{*}) \right], -.. code-block:: python +where :math:`q_p` is the :math:`p`-th quantile of the bootstrap distribution and +:math:`\alpha = 0.05` by default. It is computed by :py:func:`~CompStats.measurements.CI` and +exposed as the ``ci`` property of :py:class:`~CompStats.interface.Perf`. - >>> diff.info - {'best': 'INGEOTEC'} +**Paired difference.** For a reference system :math:`A` (by default the best one) and another +system :math:`B`, the bootstrap distribution of -The difference in performance can be visualized with the following instruction. +.. math:: -.. code-block:: python + \delta^{*} = s^{*}(y, \hat{y}_A) - s^{*}(y, \hat{y}_B) - >>> face_grid_diff = plot_difference(diff) +is computed on the same samples. The sign is flipped for smaller-is-better measures, so that a +positive difference always means that the reference is better. It is built by +:py:meth:`~CompStats.interface.Perf.difference`, which returns a +:py:class:`~CompStats.interface.Difference`. -.. image:: difference.png +**Significance.** Let :math:`\delta(x)` be the difference observed on the test set. The p-value of +the null hypothesis :math:`H_0`: "the reference is not better" is estimated as the fraction of +bootstrap differences that are at least :math:`2\delta(x)`, -From the performance graphs, for this example, we can observe that the ranking is *INGEOTEC*, *BoW*, *StackBoW*, *BoW (Corpus)*, *Dense*, *Bow (Class Weight)*. Hence, in the last graph, we analyze the performance difference against the winner (INGEOTEC). From this graph, we can conclude that *BoW* and *StackBoW*, might perform similarly to INGEOTEC. As can be seen, *Dense* is practically on the border between being significant and not significant. +.. math:: -Should we test the hypothesis of equality versus difference, considering that one system outperforms the other in the test? To address this question, we compare the performance of two systems, :math:`A` and :math:`B`, to determine whether :math:`A` is superior to :math:`B` in a larger data population, represented as :math:`\theta_A > \theta_B`. We can estimate the p-value associated with the hypothesis test :math:`H_0: \theta_A \le \theta_B` vs :math:`H_1: \theta_A > \theta_B` given the data, equivalently :math:`H_0: \theta_A< - \theta_B\le 0` vs :math:`H_1: \theta_A - \theta_B > 0`. The p-values for these differences can be estimated using the following instruction, comparing them against the winner (INGEOTEC) to determine the probability that :math:`a` (INGEOTEC) is better than :math:`b`. + \hat{p} = \frac{1}{B} \sum_{b=1}^{B} \mathbb{1}\left[\delta^{*b} \geq 2\delta(x)\right], -The :py:func:`~CompStats.measurements.difference_p_value` function estimates the p-value for each difference in comparison to the best system, as illustrated below. +(:py:meth:`~CompStats.interface.Difference.p_value`), following Berg-Kirkpatrick, Burkett and +Klein (2012). The bootstrap distribution is centred on :math:`\delta(x)` rather than on zero, +hence the factor 2. -.. code-block:: python +**Multiple comparisons.** Comparing the best system against the other :math:`m - 1` systems tests +several hypotheses at once. The p-values can be adjusted with any method of +:py:func:`statsmodels.stats.multitest.multipletests` through the ``correction`` argument (for +example ``'bonferroni'``, ``'holm'`` or ``'fdr_bh'``). When several measures are evaluated, each +measure is corrected as its own family. - >>> p_values = difference_p_value(diff) +**Competitiveness of a competition.** The legacy functional API +(:py:func:`~CompStats.performance.performance_multiple_metrics`) summarizes the competitiveness of +a competition with the coefficient of variation of the systems' performance, -For a given :math:`\alpha` level, p-values smaller than :math:`\alpha` are significant, meaning the observed difference is unlikely to be due to chance. An :math:`\alpha` level of 0.05 is commonly used. +.. math:: -.. code-block:: python + CV = 100 \, \frac{s_x}{\bar{x}}, - >>> p_values - {'BoW (Class Weight)': 0.001, - 'Dense': 0.032, - 'BoW (Corpus)': 0.006, - 'StackBoW': 0.091, - 'BoW': 0.265} +where :math:`s_x` is the sample standard deviation and :math:`\bar{x}` the mean of the systems' +performance, and with the distance between the winner and the system in the middle of the table. +The potential for improvement of a task is assessed separately with the possible percentage +improvement, :math:`PPI = 100\,(1 - x_{best})`, for bigger-is-better scores bounded by 1. -Performance comparison between all models -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +Architecture +==================================== -Similarly, the differences for each pair of variables between all models can be estimated using the function :py:func:`~CompStats.performance.all_differences`, as illustrated in the following instructions. This approach allows for a comprehensive analysis of how each model compares to the others, providing a statistical basis to understand the significance of performance variations among them. This method extends the comparative analysis, offering a detailed view of the competitive landscape of model performance. +**CompStats** is organized around one core data flow: raw predictions from one or more +systems are turned into bootstrap-resampled statistics, from which derived comparisons and plots +are computed. This section gives a map of how the modules and classes relate to each other before +diving into the per-function API references that follow. -.. code-block:: python +Data flow +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - >>> all_diff = all_differences(perf) +Given a set of systems' predictions and a shared ground truth (:math:`y`), the same bootstrap +resample indices are drawn once per population size and reused across every system being compared +-- this pairing is what makes the pairwise comparisons statistically valid. A performance statistic +(e.g. accuracy, F1) is evaluated on each resample for each system, producing an empirical +distribution per system. Everything else -- standard errors, confidence intervals, and pairwise +significance testing between systems -- is derived from these bootstrap distributions rather than +from parametric assumptions. -Once again, we use the function :py:func:`~CompStats.measurements.difference_p_value` to estimate the p-value. +Module and class relationships +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -.. code-block:: python +.. mermaid:: + + classDiagram + class StatisticSamples { + statistic: Callable + num_samples: int + n_jobs: int + BiB: bool or ndarray[bool] + calls: dict~str, ndarray~ + __call__(*args, name) + __sklearn_clone__() + } + class Perf { + y_true: ndarray + predictions: dict~str, ndarray~ + func: Callable or list~Callable~ + BiB: bool or list~bool~ + statistic_samples: StatisticSamples + best + difference(wrt) + dataframe() + plot() + __call__(y_pred, name) + } + class Difference { + statistic_samples: StatisticSamples + statistic: dict + best: str or ndarray + p_value(right, correction) + dataframe() + plot() + } + class MetricsWrappers { + <> + accuracy_score(y_true, *y_pred) + balanced_accuracy_score(y_true, *y_pred) + f1_score(y_true, *y_pred) + ... + .measure(**kwargs) Callable + } + class PerformanceModule { + <> + performance(dataframe, score) + difference(statistic_samples) + all_differences(statistic_samples) + plot_performance(statistic_samples) + plot_difference(statistic_samples) + } + class Measurements { + <> + CI(samples, alpha) + SE(samples) + difference_p_value(samples, BiB) + } + + Perf "1" *-- "1" StatisticSamples : owns + Difference "1" *-- "1" StatisticSamples : owns (cloned) + Perf ..> Difference : difference() clones\nvia sklearn.base.clone + MetricsWrappers ..> Perf : constructs, tagging\nfunc.BiB + PerformanceModule ..> StatisticSamples : operates on directly + Measurements ..> StatisticSamples : reads .calls + +- **StatisticSamples** (:py:mod:`CompStats.bootstrap`) is the foundational primitive: given a + ``statistic`` callable, it draws ``num_samples`` bootstrap resamples of the population and + evaluates the statistic on each one, optionally in parallel via ``n_jobs``. Results for a named + system are cached in ``calls`` (name -> ndarray of bootstrap samples); resample *indices* are + cached per population size so every system sharing a population reuses the same resampling. + ``__sklearn_clone__`` lets :py:func:`sklearn.base.clone` produce a fresh instance that carries over + parameters -- used to build a :py:class:`~CompStats.interface.Difference` from a + :py:class:`~CompStats.interface.Perf` without recomputing bootstrap samples. + +- **Perf** (:py:mod:`CompStats.interface`) is the main user-facing entry point. It wraps one or more + systems' predictions against shared ground truth, holding one :py:class:`~CompStats.bootstrap.StatisticSamples` + instance keyed by system name. ``func`` is a single callable or a list of callables (a + multi-measure ``Perf``); direction (bigger-is-better vs. smaller-is-better) comes from each + callable's own ``BiB`` attribute when present (tagged by a :py:mod:`CompStats.metrics` wrapper's + ``.measure`` factory), falling back to the constructor's ``BiB`` default otherwise -- + ``BiB`` is the single source of truth for direction; there is no separate score/error split. + ``Perf.difference(wrt=...)`` produces a ``Difference`` comparing every system against the best (or + an explicit reference). + +- **Difference** (:py:mod:`CompStats.interface`) is created from ``Perf.difference()`` via + :py:func:`sklearn.base.clone`, reusing the already-computed bootstrap samples rather than + recomputing them. Its ``p_value()`` is computed directly from the bootstrap distribution of paired + differences, with no parametric test assumptions. + +- **CompStats.metrics** wrappers (``accuracy_score``, ``balanced_accuracy_score``, + ``top_k_accuracy_score``, ``f1_score``, ...) are factories that close over an + :py:mod:`sklearn.metrics` function (plus its metric-specific keyword arguments) and construct a + ``Perf`` with that closure as ``func``, tagging it with ``.BiB`` so direction travels with the + callable. The shared ``@metrics_docs`` decorator injects the common ``Perf``-style docstring into + each wrapper. + +- **CompStats.performance** is an alternative, more functional API operating directly on a + ``pandas.DataFrame`` (one gold column plus one column per system): ``performance()``, + ``difference()``/``all_differences()``, and the ``plot_performance*``/``plot_difference*`` family, + plus ``*_multiple`` variants for comparing several metrics at once. It predates ``Perf`` and is + intentionally not composed with ``Perf``/``Difference``. + +- **CompStats.measurements** provides stateless helpers -- ``CI`` (percentile bootstrap confidence + interval), ``SE`` (bootstrap standard error), and ``difference_p_value`` -- each accepting either a + raw ndarray of bootstrap samples or a ``StatisticSamples`` instance, in which case it maps itself + over ``.calls``. + +Invariants to preserve +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - >>> p_values = difference_p_value(all_diff) +.. note:: + **Bootstrap resampling must stay paired across systems.** + ``StatisticSamples`` caches resample indices by population size precisely so every system's + bootstrap replicate *i* uses the same resampled indices. Do not introduce per-system independent + resampling -- it would invalidate every pairwise comparison. + +.. note:: + **BiB (Bigger is Better) must be threaded consistently, never re-derived.** + A callable's own ``BiB`` attribute wins when present; otherwise ``Perf``'s ``BiB`` constructor + argument is the default. Sorting, ``best``, and p-value sign logic throughout + :py:mod:`CompStats.interface`/:py:mod:`CompStats.performance` read this flag rather than + re-deriving direction from which argument a function was passed as. + +.. note:: + **Bootstrap samples must be reused via** ``__sklearn_clone__``, **not re-instantiation.** + :py:func:`sklearn.base.clone` duplicates ``Perf``/``StatisticSamples`` instances while carrying + over already-computed bootstrap samples (e.g. ``Perf.difference()``, + ``CompStats.performance.difference``). Plain re-instantiation silently redraws new bootstrap + samples and breaks paired comparisons. + +Development +==================================== -And we can analyze from all pairs of systems individually which ones have significantly different performances by comparing their p-value with :math:`\alpha`. +Install the package with its test dependencies and the documentation dependencies: -.. code-block:: python +.. code:: bash - >>> p_values - {'INGEOTEC - BoW': 0.265, - 'INGEOTEC - StackBoW': 0.091, - 'INGEOTEC - BoW (Corpus)': 0.006, - 'INGEOTEC - Dense': 0.032, - 'INGEOTEC - BoW (Class Weight)': 0.001, - 'BoW - StackBoW': 0.374, - 'BoW - BoW (Corpus)': 0.099, - 'BoW - Dense': 0.14, - 'BoW - BoW (Class Weight)': 0.04, - 'StackBoW - BoW (Corpus)': 0.11, - 'StackBoW - Dense': 0.148, - 'StackBoW - BoW (Class Weight)': 0.024, - 'BoW (Corpus) - Dense': 0.451, - 'BoW (Corpus) - BoW (Class Weight)': 0.204, - 'Dense - BoW (Class Weight)': 0.38} + pip install -e ".[test]" + pip install -r docs/requirements.txt -When conducting numerous comparisons or hypothesis tests on a dataset, the risk of incurring Type I errors (incorrectly dismissing a valid null hypothesis) increases. This happens because more tests performed increase the probability of randomly identifying statistically significant outcomes. Implementing adjustments for multiple comparisons is critical for several reasons: (1) To manage the risk of Type I Error, (2) To prevent erroneous conclusions, and (3) To uphold the integrity of the research. +Run the test suite: -The following code illustrates the effect of these methods for multiple comparison corrections. The function :py:func:`multipletests` makes the p-value correction by selecting the parameter :py:attr:`method`. In this example, the Bonferroni correction method is used. +.. code:: bash -.. code-block:: python + pytest CompStats - >>> result = multipletests(list(p_values.values()), method='bonferroni') +Build the developer reference; the HTML is written to ``docs/build/html/index.html``: -:py:attr:`result` is an array; next, we convert it back into a dictionary. +.. code:: bash -.. code-block:: python + python -m sphinx -n -W --keep-going -b html docs/source docs/build/html - >>> p_valuesC = dict(zip(p_values.keys(),result[1])) +The same strict build runs in continuous integration, and any warning (for example, a +cross-reference that does not resolve) makes it fail. -And we can analyze from all pairs of systems simunstally which ones have significantly different performances by comparing their p-value with :math:`\alpha`. +Releases are published by pushing a ``v`` tag, which triggers the workflow +``.github/workflows/publish-pypi.yml``; the version gate ``scripts/check_package_versions.py`` +verifies that the version is a single step ahead of the one published on PyPI. -.. code-block:: python +User site +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - >>> p_valuesC - {'INGEOTEC - BoW': 1.0, - 'INGEOTEC - StackBoW': 1.0, - 'INGEOTEC - BoW (Corpus)': 0.09, - 'INGEOTEC - Dense': 0.48, - 'INGEOTEC - BoW (Class Weight)': 0.015, - 'BoW - StackBoW': 1.0, - 'BoW - BoW (Corpus)': 1.0, - 'BoW - Dense': 1.0, - 'BoW - BoW (Class Weight)': 0.6, - 'StackBoW - BoW (Corpus)': 1.0, - 'StackBoW - Dense': 1.0, - 'StackBoW - BoW (Class Weight)': 0.36, - 'BoW (Corpus) - Dense': 1.0, - 'BoW (Corpus) - BoW (Class Weight)': 1.0, - 'Dense - BoW (Class Weight)': 1.0} - +The user site is written with Quarto in ``quarto/`` and is previewed with +``QUARTO_PYTHON="$PWD/.venv/bin/python" quarto preview quarto`` (live reload) or rendered +statically into ``quarto/_site/`` with ``QUARTO_PYTHON="$PWD/.venv/bin/python" quarto render quarto``. +Continuous integration never executes the notebooks of the site: it renders them from the cache +committed in ``quarto/_freeze/``. After changing a notebook, the site must therefore be rendered +locally and ``quarto/_freeze/`` committed together with the notebook; a test fails when they +disagree. Citing -========== +==================================== + +The first reference below is the one to cite for the methodology; the second is the work it extends. -If you find CompStats useful for any academic/scientific purpose, we would appreciate citations to the following reference: - .. code:: bibtex - @article{Nava:2023, - title = {{Comparison of Classifiers in Challenge Scheme}}, - year = {2023}, - journal = {Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics)}, - author = {Nava-Mu{\~{n}}oz, Sergio and Graff Guerrero, Mario and Escalante, Hugo Jair}, - pages = {89--98}, - volume = {13902 LNCS}, - publisher = {Springer Science and Business Media Deutschland GmbH}, - url = {https://link.springer.com/chapter/10.1007/978-3-031-33783-3_9}, - isbn = {9783031337826}, - doi = {10.1007/978-3-031-33783-3{\_}9/COVER}, - issn = {16113349}, - keywords = {Bootstrap, Challenges, Performance} + @article{Nava-Munoz2024, + author = {Nava-Mu{\~n}oz, Sergio and Graff, Mario and Escalante, Hugo Jair}, + title = {Analysis of systems' performance in natural language processing competitions}, + journal = {Pattern Recognition Letters}, + year = {2024}, + doi = {10.1016/j.patrec.2024.03.010}, + url = {https://doi.org/10.1016/j.patrec.2024.03.010} } + @inproceedings{Nava-Munoz2023, + author = {Nava-Mu{\~n}oz, Sergio and Graff Guerrero, Mario and Escalante, Hugo Jair}, + title = {Comparison of Classifiers in Challenge Scheme}, + booktitle = {Pattern Recognition}, + series = {Lecture Notes in Computer Science}, + volume = {13902}, + pages = {89--98}, + year = {2023}, + publisher = {Springer Nature Switzerland}, + doi = {10.1007/978-3-031-33783-3_9}, + url = {https://doi.org/10.1007/978-3-031-33783-3_9} + } + +References +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +- Berg-Kirkpatrick, T., Burkett, D. and Klein, D. (2012). An empirical investigation of + statistical significance in NLP. *EMNLP-CoNLL 2012*. +- Chernick, M. R. and LaBudde, R. A. (2011). *An Introduction to Bootstrap Methods with + Applications to R*. Wiley. +- Efron, B. and Tibshirani, R. J. (1994). *An Introduction to the Bootstrap*. Chapman and + Hall/CRC. +- Holm, S. (1979). A simple sequentially rejective multiple test procedure. *Scandinavian + Journal of Statistics*, 6, 65-70. +- Benjamini, Y. and Hochberg, Y. (1995). Controlling the false discovery rate: a practical and + powerful approach to multiple testing. *Journal of the Royal Statistical Society, Series B*, + 57, 289-300. API ==================================== @@ -285,8 +369,9 @@ API .. toctree:: :maxdepth: 1 - metrics_api interface_api - performance_api + metrics_api measurements_api - bootstrap_api \ No newline at end of file + bootstrap_api + performance_api + utils_api diff --git a/docs/source/metrics_api.rst b/docs/source/metrics_api.rst index 39da543..0bcb421 100644 --- a/docs/source/metrics_api.rst +++ b/docs/source/metrics_api.rst @@ -1,43 +1,20 @@ :mod:`CompStats.metrics` ================================== -.. image:: https://github.com/INGEOTEC/CompStats/actions/workflows/test.yaml/badge.svg - :target: https://github.com/INGEOTEC/CompStats/actions/workflows/test.yaml - -.. image:: https://coveralls.io/repos/github/INGEOTEC/CompStats/badge.svg?branch=develop - :target: https://coveralls.io/github/INGEOTEC/CompStats?branch=develop - -.. image:: https://badge.fury.io/py/CompStats.svg - :target: https://badge.fury.io/py/CompStats - -.. image:: https://dev.azure.com/conda-forge/feedstock-builds/_apis/build/status/compstats-feedstock?branchName=main - :target: https://dev.azure.com/conda-forge/feedstock-builds/_build/latest?definitionId=20297&branchName=main - -.. image:: https://img.shields.io/conda/vn/conda-forge/compstats.svg - :target: https://anaconda.org/conda-forge/compstats - -.. image:: https://img.shields.io/conda/pn/conda-forge/compstats.svg - :target: https://anaconda.org/conda-forge/compstats - -.. image:: https://readthedocs.org/projects/compstats/badge/?version=latest - :target: https://compstats.readthedocs.io/en/latest/?badge=latest - -.. image:: https://colab.research.google.com/assets/colab-badge.svg - :target: https://colab.research.google.com/github/INGEOTEC/CompStats/blob/docs/docs/CompStats_metrics.ipynb - :py:mod:`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 :py:mod:`~sklearn.metrics`. To illustrate the use of :py:mod:`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. >>> from sklearn.svm import LinearSVC >>> from sklearn.naive_bayes import GaussianNB ->>> from sklearn.ensemble import RandomForestClassifier +>>> from sklearn.ensemble import RandomForestClassifier, HistGradientBoostingClassifier >>> from sklearn.datasets import load_digits >>> from sklearn.model_selection import train_test_split ->>> from sklearn.base import clone >>> from CompStats.metrics import f1_score -The first step is to load the digits problem and split the dataset into training and validation sets. The second step is to estimate the parameters of a linear Support Vector Machine and predict the validation set's classes. The predictions are stored in the variable :py:attr:`hy`. +The values printed in this page are illustrative: the train/validation split and the bootstrap samples are random, so the numbers differ from one execution to the next. + +The first step is to load the digits problem and split the dataset into training and validation sets. The second step is to estimate the parameters of a linear Support Vector Machine and predict the validation set's classes. The predictions are stored in the variable ``hy``. >>> X, y = load_digits(return_X_y=True) >>> _ = train_test_split(X, y, test_size=0.3) @@ -47,7 +24,7 @@ The first step is to load the digits problem and split the dataset into training Once the predictions are available, it is time to measure the algorithm's performance, as seen in the following code. It is essential to note that the API used in :py:mod:`~sklearn.metrics` is followed; the difference is that the function returns an instance with different methods that can be used to estimate different performance statistics and compare algorithms. ->>> score = f1_score(y_val, hy, average='macro') +>>> score = f1_score(y_val, hy, average='macro', name='Linear SVM') >>> score @@ -64,7 +41,7 @@ Continuing with the example, let us assume that one wants to test another classi Statistic with its standard error (se) statistic (se) 0.9720 (0.0076) <= Random Forest -0.9521 (0.0097) <= alg-1 +0.9521 (0.0097) <= Linear SVM Let us incorporate another predictions, now with Naive Bayes classifier, and Histogram Gradient Boosting as seen below. @@ -77,7 +54,7 @@ Statistic with its standard error (se) statistic (se) 0.9759 (0.0068) <= Hist. Grad. Boost. Tree 0.9720 (0.0076) <= Random Forest -0.9521 (0.0097) <= alg-1 +0.9521 (0.0097) <= Linear SVM 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. @@ -93,10 +70,10 @@ The final step is to compare the performance of the four classifiers, which can difference p-values w.r.t Hist. Grad. Boost. Tree 0.0000 <= Naive Bayes -0.0100 <= alg-1 +0.0100 <= Linear SVM 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. +The class :py:class:`~CompStats.interface.Difference` has the :py:meth:`~CompStats.interface.Difference.plot` method that can be used to depict the difference with respect to the best. >>> diff.plot() @@ -105,9 +82,9 @@ The class :py:class:`~CompStats.Difference` has the :py:class:`~CompStats.Differ Multi-measure Perf -------------------- -A single competition can also be evaluated with more than one measure at once (e.g., macro-F1 together with macro-recall) by passing a list of functions to :py:attr:`func`. Score-type and error-type measures, with different Bigger-is-Better (BiB) directions, can even be combined this way into a single :py:class:`~CompStats.interface.Perf` instance, as long as each callable is tagged with its own :py:attr:`BiB` (or a matching list is passed to :py:attr:`BiB`). Every measure is evaluated on the same bootstrap resamples, so comparisons across algorithms remain paired for each measure. +A single competition can also be evaluated with more than one measure at once (e.g., macro-F1 together with macro-recall) by passing a list of functions to ``func``. Score-type and error-type measures, with different Bigger-is-Better (BiB) directions, can even be combined this way into a single :py:class:`~CompStats.interface.Perf` instance, as long as each callable is tagged with its own ``BiB`` (or a matching list is passed to ``BiB``). Every measure is evaluated on the same bootstrap resamples, so comparisons across algorithms remain paired for each measure. -Every :py:mod:`CompStats.metrics` wrapper exposes a ``.measure`` factory (e.g. :py:func:`~CompStats.metrics.f1_score.measure`) that builds the tagged callable used internally as :py:attr:`func`; call it directly to compose several measures, as shown next. +Every :py:mod:`CompStats.metrics` wrapper exposes a ``.measure`` factory (e.g. ``f1_score.measure``) that builds the tagged callable used internally as ``func``; call it directly to compose several measures, as shown next. >>> from CompStats.interface import Perf >>> from CompStats.metrics import f1_score, recall_score @@ -120,9 +97,9 @@ Every :py:mod:`CompStats.metrics` wrapper exposes a ``.measure`` factory (e.g. : Statistic with its standard error (se) statistic (se) 0.9783 (0.0061), 0.9786 (0.0060) <= forest -0.9440 (0.0098), 0.9442 (0.0098) <= alg-1 +0.9440 (0.0098), 0.9442 (0.0098) <= Linear SVM -:py:attr:`measure_names` is optional; when omitted, each measure is labeled with its function's ``__name__`` (e.g. ``f1_score``, ``recall_score``). The properties :py:func:`~CompStats.interface.Perf.statistic`, :py:func:`~CompStats.interface.Perf.se`, and :py:func:`~CompStats.interface.Perf.ci` return one value per measure for every system. +``measure_names`` is optional; when omitted, each measure is labeled with its function's ``__name__`` (e.g. ``f1_score``, ``recall_score``). The properties :py:func:`~CompStats.interface.Perf.statistic`, :py:func:`~CompStats.interface.Perf.se`, and :py:func:`~CompStats.interface.Perf.ci` return one value per measure for every system. >>> mperf.statistic {'forest': array([0.97828319, 0.97855524]), 'alg-1': array([0.94399193, 0.94424915])} @@ -141,7 +118,7 @@ forest, forest <= Best 0.0000, 0.0000 <= alg-1 1.0000, 1.0000 <= forest -The convenience wrappers :py:func:`~CompStats.metrics.macro_f1`, :py:func:`~CompStats.metrics.macro_recall`, and :py:func:`~CompStats.metrics.macro_precision` are ready-made, multi-measure-friendly shortcuts for macro-averaged F1, recall, and precision; each also exposes its own ``.measure`` factory (e.g. :py:func:`~CompStats.metrics.macro_f1.measure`), so they can be combined the same way as any other :py:mod:`CompStats.metrics` wrapper. +The convenience wrappers :py:func:`~CompStats.metrics.macro_f1`, :py:func:`~CompStats.metrics.macro_recall`, and :py:func:`~CompStats.metrics.macro_precision` are ready-made, multi-measure-friendly shortcuts for macro-averaged F1, recall, and precision; each also exposes its own ``.measure`` factory (e.g. ``macro_f1.measure``), so they can be combined the same way as any other :py:mod:`CompStats.metrics` wrapper. >>> from CompStats.metrics import macro_f1, macro_recall >>> Perf(y_val, hy, forest=ens.predict(X_val), diff --git a/docs/source/performance_api.rst b/docs/source/performance_api.rst index 91f1f7d..55556d0 100644 --- a/docs/source/performance_api.rst +++ b/docs/source/performance_api.rst @@ -1,5 +1,11 @@ :mod:`CompStats.performance` ================================== +:mod:`CompStats.performance` is the earlier, functional API: it operates on a +:py:class:`pandas.DataFrame` with one gold column plus one column per system. It is kept for the +multi-metric competition reports of the paper (coefficient of variation, PPI and distance to the +best). New code should use :py:class:`~CompStats.interface.Perf` and +:py:class:`~CompStats.interface.Difference`. + .. automodule:: CompStats.performance - :members: \ No newline at end of file + :members: diff --git a/docs/source/utils_api.rst b/docs/source/utils_api.rst new file mode 100644 index 0000000..46e9c97 --- /dev/null +++ b/docs/source/utils_api.rst @@ -0,0 +1,5 @@ +:mod:`CompStats.utils` +================================== + +.. automodule:: CompStats.utils + :members: diff --git a/environment.yml b/environment.yml index 3e1ea8c..bac99f9 100644 --- a/environment.yml +++ b/environment.yml @@ -13,4 +13,5 @@ dependencies: - jupyter - pip: - pandas - - seaborn \ No newline at end of file + - seaborn + - sphinxcontrib-mermaid \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml index 3b58d20..29d9615 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,3 +1,9 @@ +[build-system] +# 77 is the first setuptools that accepts the SPDX string form `license = "Apache-2.0"` +# used below. +requires = ["setuptools>=77.0.3"] +build-backend = "setuptools.build_meta" + [project] name = 'CompStats' description = 'CompStats implements an evaluation methodology for statistically analyzing competition results and competition' @@ -24,6 +30,10 @@ classifiers = [ "Topic :: Scientific/Engineering :: Information Analysis" ] +[project.optional-dependencies] +# `packaging` is only needed by scripts/check_package_versions.py and its test. +test = ["pytest>=7.0", "packaging"] + [tool.setuptools.dynamic] version = {attr = 'CompStats.__version__'} @@ -31,6 +41,8 @@ version = {attr = 'CompStats.__version__'} packages = ['CompStats', 'CompStats.tests'] [project.urls] -Homepage = "https://compstats.readthedocs.io" +Homepage = "https://ingeotec.github.io/CompStats/" +Documentation = "https://ingeotec.github.io/CompStats/" +"Developer documentation" = "https://ingeotec.github.io/CompStats/dev/" Repository = "https://github.com/INGEOTEC/CompStats" -Issues = "https://github.com/INGEOTEC/CompStats/issues" \ No newline at end of file +Issues = "https://github.com/INGEOTEC/CompStats/issues" diff --git a/quarto/.gitignore b/quarto/.gitignore new file mode 100644 index 0000000..ad29309 --- /dev/null +++ b/quarto/.gitignore @@ -0,0 +1,2 @@ +/.quarto/ +**/*.quarto_ipynb diff --git a/quarto/CompStats.qmd b/quarto/CompStats.qmd deleted file mode 100644 index dde9f2a..0000000 --- a/quarto/CompStats.qmd +++ /dev/null @@ -1,171 +0,0 @@ ---- -title: "CompStats" -format: - dashboard: - logo: images/ingeotec.png - orientation: columns - nav-buttons: [github] - theme: cosmo -execute: - freeze: auto ---- - -# Introduction - -## Column - -::: {.card title='Introduction'} -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. -::: - -::: {.card title='Installing using conda' .flow} - -`CompStats` can be install using the conda package manager with the following instruction. - -```{sh} -conda install --channel conda-forge CompStats -``` -::: - -::: {.card title='Installing using pip' .flow} -A more general approach to installing `CompStats` is through the use of the command pip, as illustrated in the following instruction. - -```{sh} -pip install CompStats -``` -::: - -# scikit-learn Users - -## Column - -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. - -Belowe the imports, it is found the code to load the digits problem and split the dataset into training and validation sets. - -::: {.card title="Dataset and libraries" .flow} -```{python} -#| echo: true -#| code-fold: true - -from sklearn.svm import LinearSVC -from sklearn.naive_bayes import GaussianNB -from sklearn.ensemble import RandomForestClassifier -from sklearn.ensemble import HistGradientBoostingClassifier -from sklearn.datasets import load_digits -from sklearn.model_selection import train_test_split -from sklearn.base import clone -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 = _ -``` -::: - -The first line estimates the parameters of a linear Support Vector Machine and predict the validation set's classes. The predictions are stored in the variable `hy`. - -::: {.card title="Linear SVM" .flow} -```{python} -#| echo: true - -m = LinearSVC().fit(X_train, y_train) -hy = m.predict(X_val) -``` -::: - -Once the predictions are available, it is time to measure the algorithm's performance, as seen in the following code. It is essential to note that the API used in `sklearn.metrics` is followed; the difference is that the function returns an instance with different methods that can be used to estimate different performance statistics and compare algorithms. - -::: {.card title="Score" .flow} -```{python} -#| echo: true - -score = f1_score(y_val, hy, average='macro') -score -``` -::: - -## Column - -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. - -::: {.card title="Random Forest" .flow} -```{python} -#| echo: true - -ens = RandomForestClassifier().fit(X_train, y_train) -score(ens.predict(X_val), name='Random Forest') -``` -::: - -Let us incorporate another predictions, now with Naive Bayes classifier, and Histogram Gradient Boosting as seen below. - -::: {.card title="Rest of the classifiers" .flow} -```{python} -#| echo: true - -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') -score.plot() -``` -::: - -# Multi-measure Support - -## Column - -Sometimes a competition needs to be evaluated with more than one measure at once, e.g., macro-F1 together with macro-recall. `CompStats` supports this by passing a list of functions to `score_func`/`error_func`; the two can even be combined to mix score-type and error-type measures, with different Bigger-is-Better directions, into a single `Perf` instance. Every measure is evaluated on the same bootstrap resamples, so comparisons across algorithms remain paired for each measure. - -Every `CompStats.metrics` wrapper exposes a `.measure` factory (e.g. `f1_score.measure`) that builds the tagged callable used internally as `score_func`/`error_func`; call it directly to compose several measures, as shown next. - -::: {.card title="Combining two measures" .flow} -```{python} -#| echo: true - -from CompStats.interface import Perf -from CompStats.metrics import f1_score, recall_score - -mperf = Perf(y_val, hy, forest=ens.predict(X_val), - score_func=[f1_score.measure(average='macro'), - recall_score.measure(average='macro')], - measure_names=['macro-F1', 'macro-Recall']) -mperf -``` -::: - -`measure_names` is optional; when omitted, each measure is labeled with its function's `__name__`. The properties `statistic`, `se`, and `ci` return one value per measure for every system. - -::: {.card title="Inspecting the measures" .flow} -```{python} -#| echo: true - -mperf.statistic -``` -::: - -`plot` facets the resulting figure by measure, and `difference` reports one p-value per measure for each system compared to the best. - -::: {.card title="Difference across measures" .flow} -```{python} -#| echo: true - -mperf.difference() -``` -::: - -## Column - -The convenience wrappers `macro_f1`, `macro_recall`, and `macro_precision` are ready-made, multi-measure-friendly shortcuts for macro-averaged F1, recall, and precision; each also exposes its own `.measure` factory, so they can be combined the same way as any other `CompStats.metrics` wrapper. - -::: {.card title="Convenience wrappers" .flow} -```{python} -#| echo: true - -from CompStats.metrics import macro_f1, macro_recall - -Perf(y_val, hy, forest=ens.predict(X_val), - score_func=[macro_f1.measure(), macro_recall.measure()]) -``` -::: \ No newline at end of file diff --git a/quarto/_freeze/pages/competition_organizers/execute-results/html.json b/quarto/_freeze/pages/competition_organizers/execute-results/html.json new file mode 100644 index 0000000..7f79447 --- /dev/null +++ b/quarto/_freeze/pages/competition_organizers/execute-results/html.json @@ -0,0 +1,16 @@ +{ + "hash": "8af51dfa09cb9b3f14d2c9317d4277f8", + "result": { + "engine": "jupyter", + "markdown": "---\ntitle: \"Competition Organizers\"\nsubtitle: \"Ranking participants and reporting significance with CompStats\"\n---\n\n[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/INGEOTEC/CompStats/blob/main/quarto/pages/competition_organizers.ipynb)\n\n::: {#e1d14076 .cell execution_count=1}\n``` {.python .cell-code}\n# Colab does not have CompStats preinstalled; it is installed only when it is missing.\n# uv, which Colab provides, is much faster than pip; pip is the fallback.\ntry:\n import CompStats\nexcept ImportError:\n !uv pip install -q --system CompStats || pip install -q CompStats\n```\n:::\n\n\nThis page is aimed at people organizing a competition rather than at a single `sklearn` user. Given a gold standard and the predictions submitted by several participants, `CompStats` produces a ranking, confidence intervals for every submission, and p-values for the difference against the best submission. All of them come from the same paired bootstrap distribution, so the comparisons stay valid even when many participants are involved.\n\n## Dataset\n\nThe example uses the gold labels of [INGEOTEC/Delitos](https://github.com/INGEOTEC/Delitos), a corpus of tweets labeled as mentioning a crime (`1`) or not (`0`). Because the tweets' text cannot be redistributed under Twitter/X's terms of service, the published corpus only contains each tweet's id and label. The following cell downloads the test partition and keeps the labels, which play the role of the gold standard an organizer would hold out from the competition's participants.\n\n::: {#1c5370fe .cell quarto-private-1='{\"key\":\"execution\",\"value\":{\"iopub.execute_input\":\"2026-08-25T12:16:16.232454Z\",\"iopub.status.busy\":\"2026-08-25T12:16:16.232027Z\",\"iopub.status.idle\":\"2026-08-25T12:16:16.645342Z\",\"shell.execute_reply\":\"2026-08-25T12:16:16.643138Z\"}}' execution_count=2}\n``` {.python .cell-code}\nimport json\nimport urllib.request\nimport numpy as np\n\nurl = (\"https://raw.githubusercontent.com/INGEOTEC/Delitos/main/\"\n \"corpus/delitos_test.json\")\nwith urllib.request.urlopen(url) as fh:\n lines = fh.read().decode('utf-8').splitlines()\ny_gold = np.array([json.loads(line)['label'] for line in lines])\ny_gold.shape, y_gold.mean()\n```\n\n::: {.cell-output .cell-output-display execution_count=1}\n```\n((360,), np.float64(0.2111111111111111))\n```\n:::\n:::\n\n\n## Simulated submissions\n\nWith only the labels available (no text to train a real classifier on), five submissions are simulated by flipping the gold label with a different probability per team. Higher skill means fewer flipped labels. Team Alpha and Team Beta share the same skill but flip different labels (a different random seed for each). Therefore, their predictions are not identical even though their expected performance is. They are meant to land in a statistical tie for first place. Team Gamma is a step below them but still competitive, and Team Delta and Team Epsilon trail further behind. This mirrors the kind of table an organizer receives, which has one column per participant, aligned with the same gold standard.\n\n::: {#7ac8d275 .cell quarto-private-1='{\"key\":\"execution\",\"value\":{\"iopub.execute_input\":\"2026-08-25T12:16:16.649165Z\",\"iopub.status.busy\":\"2026-08-25T12:16:16.648754Z\",\"iopub.status.idle\":\"2026-08-25T12:16:16.669951Z\",\"shell.execute_reply\":\"2026-08-25T12:16:16.667922Z\"}}' execution_count=3}\n``` {.python .cell-code}\ndef simulate_submission(y_true, skill, seed):\n \"\"\"A synthetic participant that mislabels with probability (1 - skill)\"\"\"\n rng = np.random.default_rng(seed)\n flip = rng.random(y_true.shape[0]) > skill\n y_pred = y_true.copy()\n y_pred[flip] = 1 - y_pred[flip]\n return y_pred\n\nsubmissions = {\n 'Team Alpha': simulate_submission(y_gold, skill=0.95, seed=0),\n 'Team Beta': simulate_submission(y_gold, skill=0.95, seed=7),\n 'Team Gamma': simulate_submission(y_gold, skill=0.90, seed=3),\n 'Team Delta': simulate_submission(y_gold, skill=0.87, seed=2),\n 'Team Epsilon': simulate_submission(y_gold, skill=0.86, seed=9),\n}\n```\n:::\n\n\n## Ranking the submissions\n\n`CompStats.metrics.f1_score` follows the `sklearn.metrics` convention, that is, it takes `(y_true, y_pred)`, and returns a `Perf` instance instead of a bare float. Passing every submission's predictions, one call per team, builds the comparison and sorts it by performance. The bootstrap resampling draws its indices from NumPy's global random state the first time it runs, so fixing the seed here makes the ranking, the confidence intervals, and the p-values below reproducible across runs of this notebook.\n\n::: {#2978cb04 .cell quarto-private-1='{\"key\":\"execution\",\"value\":{\"iopub.execute_input\":\"2026-08-25T12:16:16.674822Z\",\"iopub.status.busy\":\"2026-08-25T12:16:16.674238Z\",\"iopub.status.idle\":\"2026-08-25T12:16:28.771405Z\",\"shell.execute_reply\":\"2026-08-25T12:16:28.769820Z\"}}' execution_count=4}\n``` {.python .cell-code}\nfrom CompStats.metrics import f1_score\n\nnp.random.seed(42)\nleaderboard = None\nfor team, y_pred in submissions.items():\n if leaderboard is None:\n leaderboard = f1_score(y_gold, y_pred, name=team, pos_label=1)\n else:\n leaderboard(y_pred, name=team)\nleaderboard\n```\n\n::: {.cell-output .cell-output-stderr}\n```\n\r 0%| | 0/5 [00:00\nStatistic with its standard error (se)\nstatistic (se)\n0.9057 (0.0238) <= Team Beta\n0.8554 (0.0296) <= Team Alpha\n0.8263 (0.0318) <= Team Gamma\n0.7500 (0.0350) <= Team Delta\n0.7253 (0.0380) <= Team Epsilon\n```\n:::\n:::\n\n\n## Confidence intervals\n\n`Perf.ci` reports the percentile bootstrap confidence interval for every submission's F1 score, so the ranking above can be reported together with a measure of its uncertainty.\n\n::: {#670e1a1f .cell quarto-private-1='{\"key\":\"execution\",\"value\":{\"iopub.execute_input\":\"2026-08-25T12:16:28.775113Z\",\"iopub.status.busy\":\"2026-08-25T12:16:28.774612Z\",\"iopub.status.idle\":\"2026-08-25T12:16:28.784899Z\",\"shell.execute_reply\":\"2026-08-25T12:16:28.782548Z\"}}' execution_count=5}\n``` {.python .cell-code}\nleaderboard.ci\n```\n\n::: {.cell-output .cell-output-display execution_count=4}\n```\n{'Team Delta': (np.float64(0.6771539721539722),\n np.float64(0.8111514168658245)),\n 'Team Epsilon': (np.float64(0.6517443762781187),\n np.float64(0.7978723404255319)),\n 'Team Gamma': (np.float64(0.7628125), np.float64(0.8780458698489652)),\n 'Team Alpha': (np.float64(0.7963957742272659),\n np.float64(0.9086947456213511)),\n 'Team Beta': (np.float64(0.8540010141987829), np.float64(0.9493902439024389))}\n```\n:::\n:::\n\n\n## Significance against the best submission\n\n`Perf.difference` compares every other submission against the best one (`Team Beta` here) using the paired bootstrap distribution of the differences, and `Difference.p_value` turns that distribution into a p-value per submission. Team Alpha's p-value stays well above 0.05. Therefore, it is statistically tied with Team Beta for first place, even though the two teams' predictions are not identical. Team Gamma, Team Delta, and Team Epsilon all trail the top two, but Team Gamma's p-value sits close enough to the 0.05 boundary that, as the next section shows, the conclusion about it can change depending on how the p-values are corrected for testing four submissions against the best one at the same time.\n\n::: {#adc0eb65 .cell quarto-private-1='{\"key\":\"execution\",\"value\":{\"iopub.execute_input\":\"2026-08-25T12:16:28.787983Z\",\"iopub.status.busy\":\"2026-08-25T12:16:28.787664Z\",\"iopub.status.idle\":\"2026-08-25T12:16:28.796233Z\",\"shell.execute_reply\":\"2026-08-25T12:16:28.794429Z\"}}' execution_count=6}\n``` {.python .cell-code}\ncomparison = leaderboard.difference()\ncomparison\n```\n\n::: {.cell-output .cell-output-display execution_count=5}\n```\n\ndifference p-values w.r.t Team Beta\n0.0000 <= Team Delta\n0.0000 <= Team Epsilon\n0.0180 <= Team Gamma\n0.0880 <= Team Alpha\n```\n:::\n:::\n\n\n::: {#0ecb28f1 .cell quarto-private-1='{\"key\":\"execution\",\"value\":{\"iopub.execute_input\":\"2026-08-25T12:16:28.799633Z\",\"iopub.status.busy\":\"2026-08-25T12:16:28.799215Z\",\"iopub.status.idle\":\"2026-08-25T12:16:28.806918Z\",\"shell.execute_reply\":\"2026-08-25T12:16:28.805197Z\"}}' execution_count=7}\n``` {.python .cell-code}\ncomparison.p_value()\n```\n\n::: {.cell-output .cell-output-display execution_count=6}\n```\n{'Team Delta': np.float64(0.0),\n 'Team Epsilon': np.float64(0.0),\n 'Team Gamma': np.float64(0.018),\n 'Team Alpha': np.float64(0.088)}\n```\n:::\n:::\n\n\n## Correcting for multiple comparisons\n\nEvery submission other than the best is tested in the same round, so judging four hypotheses at once against an uncorrected 0.05 threshold inflates the chance that at least one \"significant\" difference is actually a false positive, which is the familywise error rate. `Difference.p_value`'s `correction` argument adjusts for this using any method supported by `statsmodels.stats.multitest.multipletests`. Three common choices are `'bonferroni'` (multiplies every p-value by the number of comparisons, which is simple and the most conservative of the three), `'holm'` (a step-down version of Bonferroni that is less conservative), and `'fdr_bh'` (Benjamini-Hochberg, which bounds the expected proportion of false positives among the rejected hypotheses rather than the probability of any single false positive, making it the least conservative of the three).\n\n::: {#7df65246 .cell quarto-private-1='{\"key\":\"execution\",\"value\":{\"iopub.execute_input\":\"2026-08-25T12:16:28.810053Z\",\"iopub.status.busy\":\"2026-08-25T12:16:28.809729Z\",\"iopub.status.idle\":\"2026-08-25T12:16:28.942627Z\",\"shell.execute_reply\":\"2026-08-25T12:16:28.941701Z\"}}' execution_count=8}\n``` {.python .cell-code}\nimport pandas as pd\n\npd.DataFrame({\n 'raw': comparison.p_value(),\n 'bonferroni': comparison.p_value(correction='bonferroni'),\n 'holm': comparison.p_value(correction='holm'),\n 'fdr_bh': comparison.p_value(correction='fdr_bh'),\n})\n```\n\n::: {.cell-output .cell-output-display execution_count=7}\n```{=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
rawbonferroniholmfdr_bh
Team Delta0.0000.0000.0000.000
Team Epsilon0.0000.0000.0000.000
Team Gamma0.0180.0720.0360.024
Team Alpha0.0880.3520.0880.088
\n
\n```\n:::\n:::\n\n\nTeam Gamma's p-value crosses the 0.05 threshold depending on the method. Under the raw p-value, Holm, and the FDR correction it stays significantly behind the top two, but Bonferroni's stricter correction is enough to call it statistically tied with them instead. The clear-cut cases are unaffected by the choice. Team Alpha remains tied with Team Beta and Team Delta and Team Epsilon remain clearly behind under every correction.\n\n## Visualizing the comparison\n\n`Perf.plot` and `Difference.plot` color every submission by whether it is the best, tied with the best, or significantly behind it, with confidence intervals computed from the same bootstrap distribution. Passing the same `correction` argument used above recomputes that coloring from the corrected p-values.\n\n::: {#8e8e0da3 .cell quarto-private-1='{\"key\":\"execution\",\"value\":{\"iopub.execute_input\":\"2026-08-25T12:16:28.946208Z\",\"iopub.status.busy\":\"2026-08-25T12:16:28.945916Z\",\"iopub.status.idle\":\"2026-08-25T12:16:29.611427Z\",\"shell.execute_reply\":\"2026-08-25T12:16:29.609525Z\"}}' execution_count=9}\n``` {.python .cell-code}\nleaderboard.plot()\n```\n\n::: {.cell-output .cell-output-display}\n![](competition_organizers_files/figure-html/cell-10-output-1.png){width=565 height=470}\n:::\n:::\n\n\n::: {#984b6647 .cell quarto-private-1='{\"key\":\"execution\",\"value\":{\"iopub.execute_input\":\"2026-08-25T12:16:29.614298Z\",\"iopub.status.busy\":\"2026-08-25T12:16:29.613966Z\",\"iopub.status.idle\":\"2026-08-25T12:16:30.400099Z\",\"shell.execute_reply\":\"2026-08-25T12:16:30.398003Z\"}}' execution_count=10}\n``` {.python .cell-code}\ncomparison.plot()\n```\n\n::: {.cell-output .cell-output-display}\n![](competition_organizers_files/figure-html/cell-11-output-1.png){width=562 height=490}\n:::\n:::\n\n\nRequesting `correction='bonferroni'` recolors Team Gamma from \"behind\" to \"tied\" in both plots below, since Bonferroni is the only one of the three corrections that pushes its p-value past 0.05. `'holm'` and `'fdr_bh'` can be passed the same way, but neither changes any submission's color in this comparison. Their corrected p-values for Team Gamma stay under 0.05, so the plots would look identical to the uncorrected ones above.\n\n::: {#bfb5a2c1 .cell quarto-private-1='{\"key\":\"execution\",\"value\":{\"iopub.execute_input\":\"2026-08-25T12:16:30.403245Z\",\"iopub.status.busy\":\"2026-08-25T12:16:30.402895Z\",\"iopub.status.idle\":\"2026-08-25T12:16:31.101322Z\",\"shell.execute_reply\":\"2026-08-25T12:16:31.099422Z\"}}' execution_count=11}\n``` {.python .cell-code}\nleaderboard.plot(correction='bonferroni')\n```\n\n::: {.cell-output .cell-output-display}\n![](competition_organizers_files/figure-html/cell-12-output-1.png){width=565 height=470}\n:::\n:::\n\n\n::: {#5c47a798 .cell quarto-private-1='{\"key\":\"execution\",\"value\":{\"iopub.execute_input\":\"2026-08-25T12:16:31.104912Z\",\"iopub.status.busy\":\"2026-08-25T12:16:31.104583Z\",\"iopub.status.idle\":\"2026-08-25T12:16:31.849706Z\",\"shell.execute_reply\":\"2026-08-25T12:16:31.847528Z\"}}' execution_count=12}\n``` {.python .cell-code}\ncomparison.plot(correction='bonferroni')\n```\n\n::: {.cell-output .cell-output-display}\n![](competition_organizers_files/figure-html/cell-13-output-1.png){width=562 height=490}\n:::\n:::\n\n\n[scikit-learn Users](sklearn_users.ipynb) shows the same workflow when comparing a handful of estimators against a single gold standard, and [Multiple Testing](multiple_testing.ipynb) shows how to combine several measures in a single `Perf` and correct their p-values.\n\n", + "supporting": [ + "competition_organizers_files/figure-html" + ], + "filters": [], + "includes": { + "include-in-header": [ + "\n\n\n" + ] + } + } +} \ No newline at end of file diff --git a/quarto/_freeze/pages/competition_organizers/figure-html/cell-10-output-1.png b/quarto/_freeze/pages/competition_organizers/figure-html/cell-10-output-1.png new file mode 100644 index 0000000..329593d Binary files /dev/null and b/quarto/_freeze/pages/competition_organizers/figure-html/cell-10-output-1.png differ diff --git a/quarto/_freeze/pages/competition_organizers/figure-html/cell-11-output-1.png b/quarto/_freeze/pages/competition_organizers/figure-html/cell-11-output-1.png new file mode 100644 index 0000000..892901c Binary files /dev/null and b/quarto/_freeze/pages/competition_organizers/figure-html/cell-11-output-1.png differ diff --git a/quarto/_freeze/pages/competition_organizers/figure-html/cell-12-output-1.png b/quarto/_freeze/pages/competition_organizers/figure-html/cell-12-output-1.png new file mode 100644 index 0000000..126fe04 Binary files /dev/null and b/quarto/_freeze/pages/competition_organizers/figure-html/cell-12-output-1.png differ diff --git a/quarto/_freeze/pages/competition_organizers/figure-html/cell-13-output-1.png b/quarto/_freeze/pages/competition_organizers/figure-html/cell-13-output-1.png new file mode 100644 index 0000000..08eb672 Binary files /dev/null and b/quarto/_freeze/pages/competition_organizers/figure-html/cell-13-output-1.png differ diff --git a/quarto/_freeze/pages/multiple_testing/execute-results/html.json b/quarto/_freeze/pages/multiple_testing/execute-results/html.json new file mode 100644 index 0000000..fcc1a74 --- /dev/null +++ b/quarto/_freeze/pages/multiple_testing/execute-results/html.json @@ -0,0 +1,16 @@ +{ + "hash": "21cd1db211acd21028dfb365e4295a03", + "result": { + "engine": "jupyter", + "markdown": "---\ntitle: \"Multiple Testing\"\nsubtitle: \"A quick guide to comparing several performance measures and correcting their p-values\"\n---\n\n[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/INGEOTEC/CompStats/blob/main/quarto/pages/multiple_testing.ipynb)\n\n::: {#5302df5d .cell execution_count=1}\n``` {.python .cell-code}\n# Colab does not have CompStats preinstalled; it is installed only when it is missing.\n# uv, which Colab provides, is much faster than pip; pip is the fallback.\ntry:\n import CompStats\nexcept ImportError:\n !uv pip install -q --system CompStats || pip install -q CompStats\n```\n:::\n\n\nThis page is aimed at anyone who needs to compare systems on more than one performance measure at once, e.g., precision together with recall, rather than settling for a single score. `CompStats.interface.Perf` can hold several measures in one instance, evaluated on the same paired bootstrap distribution, so the comparisons stay consistent across measures. `Difference.p_value`'s `correction` argument then adjusts for testing several hypotheses at the same time, whether those hypotheses come from several systems, several measures, or both.\n\n## Dataset\n\nThree synthetic submissions are built from the same gold standard, each with a different precision/recall trade-off: `precise` predicts the positive class conservatively (few false positives, more missed positives), `broad` predicts it liberally (catches almost every positive, but with more false alarms), and `balanced` sits between the two. The trade-off is controlled directly by each system's false-positive and false-negative rates, so the example does not depend on training an actual classifier.\n\n::: {#cf911317 .cell quarto-private-1='{\"key\":\"execution\",\"value\":{\"iopub.execute_input\":\"2026-08-25T12:37:58.692617Z\",\"iopub.status.busy\":\"2026-08-25T12:37:58.692329Z\",\"iopub.status.idle\":\"2026-08-25T12:37:58.771912Z\",\"shell.execute_reply\":\"2026-08-25T12:37:58.771179Z\"}}' execution_count=2}\n``` {.python .cell-code}\nimport numpy as np\n\ndef make_system(y_true, fp_rate, fn_rate, seed):\n \"\"\"A synthetic system that mislabels negatives/positives at the given rates\"\"\"\n rng = np.random.default_rng(seed)\n y_pred = y_true.copy()\n pos_idx = np.where(y_true == 1)[0]\n neg_idx = np.where(y_true == 0)[0]\n y_pred[pos_idx[rng.random(pos_idx.shape[0]) < fn_rate]] = 0\n y_pred[neg_idx[rng.random(neg_idx.shape[0]) < fp_rate]] = 1\n return y_pred\n\nrng = np.random.default_rng(0)\ny_gold = (rng.random(400) < 0.5).astype(int)\nprecise = make_system(y_gold, fp_rate=0.02, fn_rate=0.30, seed=1)\nbroad = make_system(y_gold, fp_rate=0.30, fn_rate=0.02, seed=2)\nbalanced = make_system(y_gold, fp_rate=0.11, fn_rate=0.13, seed=3)\n```\n:::\n\n\n## Comparing three performance measures at once\n\nPassing a list of functions to `Perf`'s `func` argument combines them into a single, multi-measure instance, here `precision_score`, `recall_score`, and `f1_score` from `CompStats.metrics`. Each of them is built with its `.measure` factory so that its `BiB` tag (bigger is better, for all three) travels with it. `measure_names` labels the columns of the result. As with a single-measure `Perf`, fixing the seed makes the bootstrap resampling below reproducible.\n\n::: {#bc6f40c9 .cell quarto-private-1='{\"key\":\"execution\",\"value\":{\"iopub.execute_input\":\"2026-08-25T12:37:58.774513Z\",\"iopub.status.busy\":\"2026-08-25T12:37:58.774286Z\",\"iopub.status.idle\":\"2026-08-25T12:38:08.323256Z\",\"shell.execute_reply\":\"2026-08-25T12:38:08.321401Z\"}}' execution_count=3}\n``` {.python .cell-code}\nfrom CompStats.metrics import precision_score, recall_score, f1_score\nfrom CompStats.interface import Perf\n\nnp.random.seed(42)\nperf = Perf(y_gold, precise=precise, broad=broad, balanced=balanced,\n func=[precision_score.measure(pos_label=1),\n recall_score.measure(pos_label=1),\n f1_score.measure(pos_label=1)],\n measure_names=['Precision', 'Recall', 'F1'])\nperf\n```\n\n::: {.cell-output .cell-output-stderr}\n```\n\r 0%| | 0/3 [00:00\nStatistic with its standard error (se)\nstatistic (se)\n0.8859 (0.0245), 0.8907 (0.0239), 0.8883 (0.0190) <= balanced\n0.9776 (0.0129), 0.7158 (0.0332), 0.8265 (0.0229) <= precise\n0.7149 (0.0306), 0.9727 (0.0120), 0.8241 (0.0211) <= broad\n```\n:::\n:::\n\n\n## Best system per measure\n\n`Perf.best` reports the top system for every measure, and the three systems split the wins exactly as their construction intends: `precise` leads on Precision, `broad` leads on Recall, and `balanced`, which is not the best at either individual measure, comes out ahead once Precision and Recall are combined into F1. Note that `best` only compares point estimates. It says nothing about whether the lead is statistically significant, which is exactly what the next section checks.\n\n::: {#96f2fffa .cell quarto-private-1='{\"key\":\"execution\",\"value\":{\"iopub.execute_input\":\"2026-08-25T12:38:08.326507Z\",\"iopub.status.busy\":\"2026-08-25T12:38:08.325972Z\",\"iopub.status.idle\":\"2026-08-25T12:38:08.334853Z\",\"shell.execute_reply\":\"2026-08-25T12:38:08.333034Z\"}}' execution_count=4}\n``` {.python .cell-code}\nperf.best\n```\n\n::: {.cell-output .cell-output-display execution_count=3}\n```\narray(['precise', 'broad', 'balanced'], dtype='\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n
PrecisionRecallF1
balanced0.00.0041.000
broad0.01.0000.008
precise1.00.0000.022
\n\n```\n:::\n:::\n\n\n`precise` and `broad` are each other's clear runner-up on the measure the other wins (Recall and Precision, respectively), with a p-value of essentially 0. The interesting row is F1. Both `precise` and `broad` trail `balanced` with uncorrected p-values under 0.05 (0.022 and 0.008), so a naive reading would call `balanced` significantly ahead of both. But three measures were just tested against `balanced` at once, so before trusting that F1 conclusion, the next section checks whether it survives a correction for multiple comparisons.\n\n## Correcting for multiple comparisons\n\n`Difference.p_value`'s `correction` argument passes any method supported by `statsmodels.stats.multitest.multipletests` (e.g., `'bonferroni'`, `'holm'`, `'fdr_bh'`) and, with several measures, corrects each measure independently (i.e., per column), so one metric's correction never mixes with another's. The following table focuses on the F1 column, comparing the raw p-values against the three correction methods.\n\n::: {#c937b6b5 .cell quarto-private-1='{\"key\":\"execution\",\"value\":{\"iopub.execute_input\":\"2026-08-25T12:38:08.366364Z\",\"iopub.status.busy\":\"2026-08-25T12:38:08.366089Z\",\"iopub.status.idle\":\"2026-08-25T12:38:08.634874Z\",\"shell.execute_reply\":\"2026-08-25T12:38:08.632335Z\"}}' execution_count=6}\n``` {.python .cell-code}\npd.DataFrame({\n 'raw': {k: v[2] for k, v in diff.p_value().items()},\n 'bonferroni': {k: v[2] for k, v in diff.p_value(correction='bonferroni').items()},\n 'holm': {k: v[2] for k, v in diff.p_value(correction='holm').items()},\n 'fdr_bh': {k: v[2] for k, v in diff.p_value(correction='fdr_bh').items()},\n})\n```\n\n::: {.cell-output .cell-output-display execution_count=5}\n```{=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
rawbonferroniholmfdr_bh
balanced1.0001.0001.0001.000
broad0.0080.0240.0240.024
precise0.0220.0660.0440.033
\n
\n```\n:::\n:::\n\n\n`broad` stays significantly behind `balanced` on F1 under every method. `precise`, however, crosses the 0.05 threshold depending on the correction. Bonferroni's stricter adjustment (0.066) is enough to call it statistically tied with `balanced` on F1, while Holm (0.044) and the FDR correction (0.033) both keep it significantly behind. This is the same lesson as [Competition Organizers](competition_organizers.ipynb)'s Team Gamma, except the extra hypothesis being tested here comes from combining measures rather than from ranking more systems.\n\n## Visualizing the comparison\n\n`Perf.plot` renders one panel per measure, coloring each system by whether it is the best, tied with the best, or significantly behind it on that measure. Therefore, the three-way split from `perf.best` above is visible directly, alongside each system's confidence interval.\n\n::: {#6965dfe7 .cell quarto-private-1='{\"key\":\"execution\",\"value\":{\"iopub.execute_input\":\"2026-08-25T12:38:08.638647Z\",\"iopub.status.busy\":\"2026-08-25T12:38:08.638313Z\",\"iopub.status.idle\":\"2026-08-25T12:38:10.005921Z\",\"shell.execute_reply\":\"2026-08-25T12:38:10.004600Z\"}}' execution_count=7}\n``` {.python .cell-code}\nperf.plot()\n```\n\n::: {.cell-output .cell-output-display}\n![](multiple_testing_files/figure-html/cell-8-output-1.png){width=1538 height=469}\n:::\n:::\n\n\n`Difference.plot` shows the same paired differences against each measure's best system, coloring by statistical significance instead.\n\n::: {#617dab24 .cell quarto-private-1='{\"key\":\"execution\",\"value\":{\"iopub.execute_input\":\"2026-08-25T12:38:10.008795Z\",\"iopub.status.busy\":\"2026-08-25T12:38:10.008463Z\",\"iopub.status.idle\":\"2026-08-25T12:38:11.182336Z\",\"shell.execute_reply\":\"2026-08-25T12:38:11.181428Z\"}}' execution_count=8}\n``` {.python .cell-code}\ndiff.plot()\n```\n\n::: {.cell-output .cell-output-display}\n![](multiple_testing_files/figure-html/cell-9-output-1.png){width=1522 height=469}\n:::\n:::\n\n\nPassing `correction='bonferroni'` recolors `precise`'s F1 panel from significantly behind to tied in both plots, matching the table above. `'holm'` and `'fdr_bh'` would leave every panel unchanged from the uncorrected plots, since neither pushes `precise`'s F1 p-value past 0.05.\n\n::: {#0c68902c .cell quarto-private-1='{\"key\":\"execution\",\"value\":{\"iopub.execute_input\":\"2026-08-25T12:38:11.185481Z\",\"iopub.status.busy\":\"2026-08-25T12:38:11.185271Z\",\"iopub.status.idle\":\"2026-08-25T12:38:12.352012Z\",\"shell.execute_reply\":\"2026-08-25T12:38:12.350647Z\"}}' execution_count=9}\n``` {.python .cell-code}\nperf.plot(correction='bonferroni')\n```\n\n::: {.cell-output .cell-output-display}\n![](multiple_testing_files/figure-html/cell-10-output-1.png){width=1550 height=469}\n:::\n:::\n\n\n::: {#ec6b4fb5 .cell quarto-private-1='{\"key\":\"execution\",\"value\":{\"iopub.execute_input\":\"2026-08-25T12:38:12.354392Z\",\"iopub.status.busy\":\"2026-08-25T12:38:12.354161Z\",\"iopub.status.idle\":\"2026-08-25T12:38:13.340976Z\",\"shell.execute_reply\":\"2026-08-25T12:38:13.340068Z\"}}' execution_count=10}\n``` {.python .cell-code}\ndiff.plot(correction='bonferroni')\n```\n\n::: {.cell-output .cell-output-display}\n![](multiple_testing_files/figure-html/cell-11-output-1.png){width=1522 height=469}\n:::\n:::\n\n\n[scikit-learn Users](sklearn_users.ipynb) and [Competition Organizers](competition_organizers.ipynb) show this same workflow with a single performance measure, comparing a handful of estimators or ranking many competition submissions against a shared gold standard.\n\n", + "supporting": [ + "multiple_testing_files/figure-html" + ], + "filters": [], + "includes": { + "include-in-header": [ + "\n\n\n" + ] + } + } +} \ No newline at end of file diff --git a/quarto/_freeze/pages/multiple_testing/figure-html/cell-10-output-1.png b/quarto/_freeze/pages/multiple_testing/figure-html/cell-10-output-1.png new file mode 100644 index 0000000..3efa2de Binary files /dev/null and b/quarto/_freeze/pages/multiple_testing/figure-html/cell-10-output-1.png differ diff --git a/quarto/_freeze/pages/multiple_testing/figure-html/cell-11-output-1.png b/quarto/_freeze/pages/multiple_testing/figure-html/cell-11-output-1.png new file mode 100644 index 0000000..b0e3174 Binary files /dev/null and b/quarto/_freeze/pages/multiple_testing/figure-html/cell-11-output-1.png differ diff --git a/quarto/_freeze/pages/multiple_testing/figure-html/cell-8-output-1.png b/quarto/_freeze/pages/multiple_testing/figure-html/cell-8-output-1.png new file mode 100644 index 0000000..88f2be8 Binary files /dev/null and b/quarto/_freeze/pages/multiple_testing/figure-html/cell-8-output-1.png differ diff --git a/quarto/_freeze/pages/multiple_testing/figure-html/cell-9-output-1.png b/quarto/_freeze/pages/multiple_testing/figure-html/cell-9-output-1.png new file mode 100644 index 0000000..db45ad6 Binary files /dev/null and b/quarto/_freeze/pages/multiple_testing/figure-html/cell-9-output-1.png differ diff --git a/quarto/_freeze/pages/sklearn_users/execute-results/html.json b/quarto/_freeze/pages/sklearn_users/execute-results/html.json new file mode 100644 index 0000000..10a10c4 --- /dev/null +++ b/quarto/_freeze/pages/sklearn_users/execute-results/html.json @@ -0,0 +1,12 @@ +{ + "hash": "9f3e516aeb66e02d354933c7d3e40713", + "result": { + "engine": "jupyter", + "markdown": "---\ntitle: \"scikit-learn Users\"\nsubtitle: \"A quick guide to comparing the predictions of scikit-learn models with CompStats\"\n---\n\n[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/INGEOTEC/CompStats/blob/main/quarto/pages/sklearn_users.ipynb)\n\n::: {#fc19dcd7 .cell execution_count=1}\n``` {.python .cell-code}\n# Colab does not have CompStats preinstalled; it is installed only when it is missing.\n# uv, which Colab provides, is much faster than pip; pip is the fallback.\ntry:\n import CompStats\nexcept ImportError:\n !uv pip install -q --system CompStats || pip install -q CompStats\n```\n:::\n\n\nTo illustrate the use of `CompStats`, the following example loads a classification problem (the digits dataset), trains four different classifiers, and uses `CompStats.metrics.f1_score` to measure and compare their performance. As with the rest of `sklearn.metrics`, the score function takes `(y_true, y_pred)`. The difference is that it returns a `Perf` instance, with the standard error, confidence interval, and pairwise significance tests already computed from the bootstrap distribution. The package is not limited to classification. The last section, [Regression](#regression), repeats the comparison with three regressors and an error measure.\n\n## Dataset and libraries\n\nThe first step is to load the digits dataset and split it into a training (`X_train`, `y_train`) and a validation set (`X_val`, `y_val`).\n\n::: {#bbb251c3 .cell execution_count=2}\n``` {.python .cell-code}\nimport numpy as np\nfrom sklearn.svm import LinearSVC\nfrom sklearn.naive_bayes import GaussianNB\nfrom sklearn.ensemble import RandomForestClassifier\nfrom sklearn.ensemble import HistGradientBoostingClassifier\nfrom sklearn.datasets import load_digits\nfrom sklearn.model_selection import train_test_split\nfrom CompStats.metrics import f1_score\n\nX, y = load_digits(return_X_y=True)\n_ = train_test_split(X, y, test_size=0.3, random_state=0)\nX_train, X_val, y_train, y_val = _\n```\n:::\n\n\n## Linear SVM\n\nThe following line trains a linear Support Vector Machine and predicts the validation set's classes. The predictions are stored in `hy`.\n\n::: {#654559ee .cell execution_count=3}\n``` {.python .cell-code}\nm = LinearSVC(random_state=0).fit(X_train, y_train)\nhy = m.predict(X_val)\n```\n:::\n\n\n## Score\n\nOnce the predictions are available, `f1_score` measures the classifier's performance. The API follows the `sklearn.metrics` convention, that is, the function takes `(y_true, y_pred)`, but the result, `score`, is a `Perf` instance rather than a bare float.\n\n::: {#a1d9d078 .cell execution_count=4}\n``` {.python .cell-code}\nnp.random.seed(0)\nscore = f1_score(y_val, hy, name='Linear SVM', average='macro')\nscore\n```\n\n::: {.cell-output .cell-output-stderr}\n```\n\r 0%| | 0/1 [00:00\n```\n:::\n:::\n\n\nThe printed representation of `score` shows two values. `statistic` is the measure computed on the validation set, here the macro-$F_1$ of the linear SVM. It is the number that `sklearn.metrics.f1_score` returns for the same arguments, and it is available as `score.statistic`. `se` is the standard error of that measure, estimated as the standard deviation of the measure over the bootstrap samples of the validation set (500 by default, parameter `num_samples`). It is available as `score.se`. The standard error quantifies how much the measure would vary if the validation set were another sample of the same population. The confidence interval, by default at the 95% level, is in `score.ci`.\n\n## Random Forest\n\nComparing a second classifier against the same gold standard reuses the same bootstrap resamples. Calling `score` with a new set of predictions adds them to the comparison without redrawing the bootstrap, keeping every pairwise comparison paired.\n\n::: {#d3943219 .cell execution_count=5}\n``` {.python .cell-code}\nens = RandomForestClassifier(random_state=0).fit(X_train, y_train)\nscore(ens.predict(X_val), name='Random Forest')\n```\n\n::: {.cell-output .cell-output-stderr}\n```\n\r 0%| | 0/1 [00:00\nStatistic with its standard error (se)\nstatistic (se)\n0.9783 (0.0061) <= Random Forest\n0.9440 (0.0098) <= Linear SVM\n```\n:::\n:::\n\n\n## Rest of the classifiers\n\nAdding a Naive Bayes classifier and a Histogram Gradient Boosting Tree completes the comparison. `Perf.plot` renders all four systems' performance together with their confidence intervals.\n\n::: {#a65f6157 .cell execution_count=6}\n``` {.python .cell-code}\nnb = GaussianNB().fit(X_train, y_train)\n_ = score(nb.predict(X_val), name='Naive Bayes')\nhist = HistGradientBoostingClassifier(random_state=0).fit(X_train, y_train)\n_ = score(hist.predict(X_val), name='Hist. Grad. Boost. Tree')\nscore.plot()\n```\n\n::: {.cell-output .cell-output-stderr}\n```\n\r 0%| | 0/2 [00:00\ndifference p-values w.r.t Random Forest\n0.0000 <= Linear SVM\n0.0000 <= Naive Bayes\n0.0060 <= Hist. Grad. Boost. Tree\n```\n:::\n:::\n\n\n## Correction for multiple comparisons\n\nThree systems are compared with the best one at the same time, so the p-values are adjusted for multiple comparisons, here with Holm's method. The correction is described in more detail in [Multiple Testing](multiple_testing.ipynb).\n\n::: {#f75b6387 .cell execution_count=8}\n``` {.python .cell-code}\ndiff.p_value(correction='holm')\n```\n\n::: {.cell-output .cell-output-display execution_count=7}\n```\n{'Linear SVM': np.float64(0.0),\n 'Naive Bayes': np.float64(0.0),\n 'Hist. Grad. Boost. Tree': np.float64(0.006)}\n```\n:::\n:::\n\n\n`Difference.plot` draws the confidence interval of each difference. An interval that contains zero means that the system is not statistically different from the best one.\n\n::: {#e02998fb .cell execution_count=9}\n``` {.python .cell-code}\ndiff.plot()\n```\n\n::: {.cell-output .cell-output-display}\n![](sklearn_users_files/figure-html/cell-10-output-1.png){width=566 height=490}\n:::\n:::\n\n\n## Regression\n\nThe same workflow applies to regression problems. The following example loads the diabetes dataset, trains three regressors and compares them with `CompStats.metrics.mean_absolute_error`. For this measure a smaller value is better. Every function of `CompStats.metrics` knows the direction of its measure, so the best system is the one with the smallest error and nothing else changes in the code.\n\n::: {#c44bfd8a .cell execution_count=10}\n``` {.python .cell-code}\nfrom sklearn.datasets import load_diabetes\nfrom sklearn.linear_model import LinearRegression\nfrom sklearn.ensemble import RandomForestRegressor\nfrom sklearn.ensemble import HistGradientBoostingRegressor\nfrom CompStats.metrics import mean_absolute_error\n\nX, y = load_diabetes(return_X_y=True)\n_ = train_test_split(X, y, test_size=0.3, random_state=0)\nX_train, X_val, y_train, y_val = _\n\nnp.random.seed(0)\nlr = LinearRegression().fit(X_train, y_train)\nerror = mean_absolute_error(y_val, lr.predict(X_val), name='Linear Regression')\nforest = RandomForestRegressor(random_state=0).fit(X_train, y_train)\n_ = error(forest.predict(X_val), name='Random Forest')\nhist = HistGradientBoostingRegressor(random_state=0).fit(X_train, y_train)\n_ = error(hist.predict(X_val), name='Hist. Grad. Boost. Tree')\nerror\n```\n\n::: {.cell-output .cell-output-stderr}\n```\n\r 0%| | 0/3 [00:00\nStatistic with its standard error (se)\nstatistic (se)\n44.6176 (2.8668) <= Linear Regression\n46.5703 (3.3280) <= Hist. Grad. Boost. Tree\n47.7996 (2.9929) <= Random Forest\n```\n:::\n:::\n\n\nThe systems are listed from the smallest to the largest error. `Perf.plot` and `Perf.difference` are used exactly as in the classification example. The horizontal axis of the figure is now labelled as an error, and the best system, at the top, is the one with the smallest error.\n\n::: {#83ffdb9d .cell execution_count=11}\n``` {.python .cell-code}\nerror.plot()\n```\n\n::: {.cell-output .cell-output-display}\n![](sklearn_users_files/figure-html/cell-12-output-1.png){width=558 height=470}\n:::\n:::\n\n\nIn the figure, the histogram gradient boosting tree is statistically equivalent to the linear regression, whereas the random forest is marked as different. The colours of `Perf.plot` come from p-values that are not corrected for multiple comparisons unless its `correction` argument is given. The p-values of the differences with respect to the best regressor, adjusted with Holm's method, are obtained as before. With the correction, neither difference is significant at the 0.05 level.\n\n::: {#3316f95d .cell execution_count=12}\n``` {.python .cell-code}\nerror.difference().p_value(correction='holm')\n```\n\n::: {.cell-output .cell-output-display execution_count=11}\n```\n{'Random Forest': np.float64(0.052),\n 'Hist. Grad. Boost. Tree': np.float64(0.166)}\n```\n:::\n:::\n\n\n[Competition Organizers](competition_organizers.ipynb) extends this workflow to ranking many participants against a gold standard, and [Multiple Testing](multiple_testing.ipynb) shows how to combine several measures in a single `Perf` and correct their p-values.\n\n", + "supporting": [ + "sklearn_users_files/figure-html" + ], + "filters": [], + "includes": {} + } +} \ No newline at end of file diff --git a/quarto/_freeze/pages/sklearn_users/figure-html/cell-10-output-1.png b/quarto/_freeze/pages/sklearn_users/figure-html/cell-10-output-1.png new file mode 100644 index 0000000..c16310a Binary files /dev/null and b/quarto/_freeze/pages/sklearn_users/figure-html/cell-10-output-1.png differ diff --git a/quarto/_freeze/pages/sklearn_users/figure-html/cell-12-output-1.png b/quarto/_freeze/pages/sklearn_users/figure-html/cell-12-output-1.png new file mode 100644 index 0000000..97e92fd Binary files /dev/null and b/quarto/_freeze/pages/sklearn_users/figure-html/cell-12-output-1.png differ diff --git a/quarto/_freeze/pages/sklearn_users/figure-html/cell-7-output-2.png b/quarto/_freeze/pages/sklearn_users/figure-html/cell-7-output-2.png new file mode 100644 index 0000000..7d104ba Binary files /dev/null and b/quarto/_freeze/pages/sklearn_users/figure-html/cell-7-output-2.png differ diff --git a/quarto/_freeze/site_libs/clipboard/clipboard.min.js b/quarto/_freeze/site_libs/clipboard/clipboard.min.js new file mode 100644 index 0000000..1103f81 --- /dev/null +++ b/quarto/_freeze/site_libs/clipboard/clipboard.min.js @@ -0,0 +1,7 @@ +/*! + * clipboard.js v2.0.11 + * https://clipboardjs.com/ + * + * Licensed MIT © Zeno Rocha + */ +!function(t,e){"object"==typeof exports&&"object"==typeof module?module.exports=e():"function"==typeof define&&define.amd?define([],e):"object"==typeof exports?exports.ClipboardJS=e():t.ClipboardJS=e()}(this,function(){return n={686:function(t,e,n){"use strict";n.d(e,{default:function(){return b}});var e=n(279),i=n.n(e),e=n(370),u=n.n(e),e=n(817),r=n.n(e);function c(t){try{return document.execCommand(t)}catch(t){return}}var a=function(t){t=r()(t);return c("cut"),t};function o(t,e){var n,o,t=(n=t,o="rtl"===document.documentElement.getAttribute("dir"),(t=document.createElement("textarea")).style.fontSize="12pt",t.style.border="0",t.style.padding="0",t.style.margin="0",t.style.position="absolute",t.style[o?"right":"left"]="-9999px",o=window.pageYOffset||document.documentElement.scrollTop,t.style.top="".concat(o,"px"),t.setAttribute("readonly",""),t.value=n,t);return e.container.appendChild(t),e=r()(t),c("copy"),t.remove(),e}var f=function(t){var e=1 + CompStats · Sergio Nava-Muñoz, Mario Graff and Hugo Jair Escalante · + Code under the Apache 2.0 license + +format: + html: + theme: [cosmo, style.scss] + toc: true + number-sections: true + link-external-newwindow: true diff --git a/quarto/compstats.csl b/quarto/compstats.csl new file mode 100644 index 0000000..cc6177d --- /dev/null +++ b/quarto/compstats.csl @@ -0,0 +1,102 @@ + + diff --git a/quarto/index.qmd b/quarto/index.qmd new file mode 100644 index 0000000..0410c38 --- /dev/null +++ b/quarto/index.qmd @@ -0,0 +1,104 @@ +--- +title: "CompStats" +subtitle: "Bootstrap-based statistical comparison of supervised-learning systems evaluated on a shared test set" +toc: false +number-sections: false +--- + +::: {.home-lead} +**CompStats** is an open-source Python +package for the statistical analysis of the results of supervised-learning systems evaluated on a +shared held-out test set, the setting of collaborative competitions (also called challenges). From +the gold standard and the predictions of each system, it estimates by bootstrap the standard error +and the confidence interval of every performance measure, tests whether the difference between the +best system and each of the others is statistically significant, and corrects those tests for +multiple comparisons. +::: + +Competitions rank systems by a point estimate computed on a single test set. The differences +between consecutive systems are often in the hundredths or thousandths. Consequently, a higher +score does not imply that a system would remain better on the population from which the test set +was sampled. Moreover, the statistical tests for comparing learning algorithms require access to +the underlying algorithm [@Dietterich1998], whereas a competition gives access only to the +predictions, and the procedures for comparing classifiers over multiple datasets [@Demsar2006] do +not apply because a competition involves a single dataset. + +CompStats implements the methodology of @Nava-Munoz2024, *Analysis of systems' performance in +natural language processing competitions* (Pattern Recognition Letters). The methodology +is designed to complement the standard winner selection process, which in most cases relies solely +on the ranking of the scores, with well-established statistical tools and graphics. It also provides +[measures](pages/methodology.qmd#competitiveness-of-a-competition) that allow organizers to assess +the difficulty of a competition. It is designed to be universally applicable. The article +illustrates it with eight natural language processing competitions as case studies, involving +classification and regression problems. + +::: {.pillars} +::: {.pillar} +### Follows the scikit-learn metrics API + +A function of `CompStats.metrics` takes `(y_true, y_pred)` like its `sklearn.metrics` namesake and +returns a `Perf` object instead of a float. +::: +::: {.pillar} +### Uncertainty for every measure + +The standard error and the percentile confidence interval are computed from the bootstrap +distribution of the measure. +::: +::: {.pillar} +### Paired significance testing + +Every system is evaluated on the same bootstrap samples, so the differences are paired. The +p-values come from the bootstrap distribution of the difference, with optional Bonferroni, Holm or +Benjamini-Hochberg correction. +::: +::: + +## Quickstart + +The package is installed with `pip install CompStats` or with `conda install --channel conda-forge +CompStats`. See [Install](pages/install.qmd) for details. The following example compares three classifiers on +the digits problem. + +```python +from sklearn.datasets import load_digits +from sklearn.ensemble import RandomForestClassifier +from sklearn.model_selection import train_test_split +from sklearn.naive_bayes import GaussianNB +from sklearn.svm import LinearSVC +from CompStats.metrics import f1_score + +X, y = load_digits(return_X_y=True) +X_train, X_val, y_train, y_val = train_test_split(X, y, test_size=0.3, random_state=0) + +svm = LinearSVC(random_state=0).fit(X_train, y_train) +score = f1_score(y_val, svm.predict(X_val), average='macro', name='Linear SVM') +score(RandomForestClassifier(random_state=0).fit(X_train, y_train).predict(X_val), + name='Random Forest') +score(GaussianNB().fit(X_train, y_train).predict(X_val), name='Naive Bayes') + +score # point estimate and standard error of every system +score.ci # 95% percentile bootstrap confidence intervals +diff = score.difference() # paired differences against the best system +diff.p_value(correction='holm') # p-values adjusted for multiple comparisons +score.plot() # performance with confidence intervals +``` + +## Where to go next + +[Install](pages/install.qmd) describes the requirements and the installation methods, and +[Methodology](pages/methodology.qmd) states the statistical basis of the package. The tutorials +are [scikit-learn Users](pages/sklearn_users.ipynb), [Competition +Organizers](pages/competition_organizers.ipynb) and [Multiple +Testing](pages/multiple_testing.ipynb). These three pages are Jupyter notebooks that can be opened +in Colab from the badge at their top. [Citing](pages/citing.qmd) gives the references to cite, and +the architecture and the complete API are in the [developer +docs](https://ingeotec.github.io/CompStats/dev/). + +## Colophon {.unnumbered} + +As with the rest of the project, this site was built by the CompStats team +together with Claude, Anthropic's coding assistant, through [Claude +Code](https://claude.com/claude-code). The assistant helped set up the Quarto +site and draft this page, with the authors reviewing and validating every +change before it was committed. diff --git a/quarto/pages/.gitkeep b/quarto/pages/.gitkeep new file mode 100644 index 0000000..e69de29 diff --git a/quarto/pages/citing.qmd b/quarto/pages/citing.qmd new file mode 100644 index 0000000..ca9476c --- /dev/null +++ b/quarto/pages/citing.qmd @@ -0,0 +1,46 @@ +--- +title: "Citing" +--- + +When CompStats is used in academic work, the following article, which describes the methodology +implemented by the package, should be cited. + +```bibtex +@article{Nava-Munoz2024, + author = {Nava-Mu{\~n}oz, Sergio and Graff, Mario and Escalante, Hugo Jair}, + title = {Analysis of systems' performance in natural language processing competitions}, + journal = {Pattern Recognition Letters}, + volume = {186}, + pages = {346--353}, + year = {2024}, + doi = {10.1016/j.patrec.2024.03.010}, + url = {https://doi.org/10.1016/j.patrec.2024.03.010} +} +``` + +The conference paper that the article extends is the following. + +```bibtex +@inproceedings{Nava-Munoz2023, + author = {Nava-Mu{\~n}oz, Sergio and Graff Guerrero, Mario and Escalante, Hugo Jair}, + title = {Comparison of Classifiers in Challenge Scheme}, + booktitle = {Pattern Recognition}, + series = {Lecture Notes in Computer Science}, + volume = {13902}, + pages = {89--98}, + year = {2023}, + publisher = {Springer Nature Switzerland}, + doi = {10.1007/978-3-031-33783-3_9}, + url = {https://doi.org/10.1007/978-3-031-33783-3_9} +} +``` + +## Authors + +- Sergio Nava-Muñoz, CIMAT, Aguascalientes, Mexico. +- Mario Graff, INFOTEC, Aguascalientes, Mexico. +- Hugo Jair Escalante, INAOE, Puebla, Mexico. + +## License + +CompStats is distributed under the Apache License 2.0. diff --git a/quarto/pages/competition_organizers.ipynb b/quarto/pages/competition_organizers.ipynb new file mode 100644 index 0000000..32a9244 --- /dev/null +++ b/quarto/pages/competition_organizers.ipynb @@ -0,0 +1,706 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "d0bd3c5c", + "metadata": {}, + "source": [ + "---\n", + "title: \"Competition Organizers\"\n", + "subtitle: \"Ranking participants and reporting significance with CompStats\"\n", + "---" + ] + }, + { + "cell_type": "markdown", + "id": "d0fc5091", + "metadata": {}, + "source": [ + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/INGEOTEC/CompStats/blob/main/quarto/pages/competition_organizers.ipynb)" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "e1d14076", + "metadata": {}, + "outputs": [], + "source": [ + "#| eval: false\n", + "# Colab does not have CompStats preinstalled; it is installed only when it is missing.\n", + "# uv, which Colab provides, is much faster than pip; pip is the fallback.\n", + "try:\n", + " import CompStats\n", + "except ImportError:\n", + " !uv pip install -q --system CompStats || pip install -q CompStats" + ] + }, + { + "cell_type": "markdown", + "id": "cf48a043", + "metadata": {}, + "source": [ + "This page is aimed at people organizing a competition rather than at a single `sklearn` user. Given a gold standard and the predictions submitted by several participants, `CompStats` produces a ranking, confidence intervals for every submission, and p-values for the difference against the best submission. All of them come from the same paired bootstrap distribution, so the comparisons stay valid even when many participants are involved." + ] + }, + { + "cell_type": "markdown", + "id": "de569c32", + "metadata": {}, + "source": [ + "## Dataset\n", + "\n", + "The example uses the gold labels of [INGEOTEC/Delitos](https://github.com/INGEOTEC/Delitos), a corpus of tweets labeled as mentioning a crime (`1`) or not (`0`). Because the tweets' text cannot be redistributed under Twitter/X's terms of service, the published corpus only contains each tweet's id and label. The following cell downloads the test partition and keeps the labels, which play the role of the gold standard an organizer would hold out from the competition's participants." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "1c5370fe", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-25T12:16:16.232454Z", + "iopub.status.busy": "2026-08-25T12:16:16.232027Z", + "iopub.status.idle": "2026-08-25T12:16:16.645342Z", + "shell.execute_reply": "2026-08-25T12:16:16.643138Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "((360,), np.float64(0.2111111111111111))" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import json\n", + "import urllib.request\n", + "import numpy as np\n", + "\n", + "url = (\"https://raw.githubusercontent.com/INGEOTEC/Delitos/main/\"\n", + " \"corpus/delitos_test.json\")\n", + "with urllib.request.urlopen(url) as fh:\n", + " lines = fh.read().decode('utf-8').splitlines()\n", + "y_gold = np.array([json.loads(line)['label'] for line in lines])\n", + "y_gold.shape, y_gold.mean()" + ] + }, + { + "cell_type": "markdown", + "id": "9a4bdf58", + "metadata": {}, + "source": [ + "## Simulated submissions\n", + "\n", + "With only the labels available (no text to train a real classifier on), five submissions are simulated by flipping the gold label with a different probability per team. Higher skill means fewer flipped labels. Team Alpha and Team Beta share the same skill but flip different labels (a different random seed for each). Therefore, their predictions are not identical even though their expected performance is. They are meant to land in a statistical tie for first place. Team Gamma is a step below them but still competitive, and Team Delta and Team Epsilon trail further behind. This mirrors the kind of table an organizer receives, which has one column per participant, aligned with the same gold standard." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "7ac8d275", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-25T12:16:16.649165Z", + "iopub.status.busy": "2026-08-25T12:16:16.648754Z", + "iopub.status.idle": "2026-08-25T12:16:16.669951Z", + "shell.execute_reply": "2026-08-25T12:16:16.667922Z" + } + }, + "outputs": [], + "source": [ + "def simulate_submission(y_true, skill, seed):\n", + " \"\"\"A synthetic participant that mislabels with probability (1 - skill)\"\"\"\n", + " rng = np.random.default_rng(seed)\n", + " flip = rng.random(y_true.shape[0]) > skill\n", + " y_pred = y_true.copy()\n", + " y_pred[flip] = 1 - y_pred[flip]\n", + " return y_pred\n", + "\n", + "submissions = {\n", + " 'Team Alpha': simulate_submission(y_gold, skill=0.95, seed=0),\n", + " 'Team Beta': simulate_submission(y_gold, skill=0.95, seed=7),\n", + " 'Team Gamma': simulate_submission(y_gold, skill=0.90, seed=3),\n", + " 'Team Delta': simulate_submission(y_gold, skill=0.87, seed=2),\n", + " 'Team Epsilon': simulate_submission(y_gold, skill=0.86, seed=9),\n", + "}" + ] + }, + { + "cell_type": "markdown", + "id": "54975665", + "metadata": {}, + "source": [ + "## Ranking the submissions\n", + "\n", + "`CompStats.metrics.f1_score` follows the `sklearn.metrics` convention, that is, it takes `(y_true, y_pred)`, and returns a `Perf` instance instead of a bare float. Passing every submission's predictions, one call per team, builds the comparison and sorts it by performance. The bootstrap resampling draws its indices from NumPy's global random state the first time it runs, so fixing the seed here makes the ranking, the confidence intervals, and the p-values below reproducible across runs of this notebook." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "2978cb04", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-25T12:16:16.674822Z", + "iopub.status.busy": "2026-08-25T12:16:16.674238Z", + "iopub.status.idle": "2026-08-25T12:16:28.771405Z", + "shell.execute_reply": "2026-08-25T12:16:28.769820Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 0%| | 0/5 [00:00\n", + "Statistic with its standard error (se)\n", + "statistic (se)\n", + "0.9057 (0.0238) <= Team Beta\n", + "0.8554 (0.0296) <= Team Alpha\n", + "0.8263 (0.0318) <= Team Gamma\n", + "0.7500 (0.0350) <= Team Delta\n", + "0.7253 (0.0380) <= Team Epsilon" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from CompStats.metrics import f1_score\n", + "\n", + "np.random.seed(42)\n", + "leaderboard = None\n", + "for team, y_pred in submissions.items():\n", + " if leaderboard is None:\n", + " leaderboard = f1_score(y_gold, y_pred, name=team, pos_label=1)\n", + " else:\n", + " leaderboard(y_pred, name=team)\n", + "leaderboard" + ] + }, + { + "cell_type": "markdown", + "id": "37861be3", + "metadata": {}, + "source": [ + "## Confidence intervals\n", + "\n", + "`Perf.ci` reports the percentile bootstrap confidence interval for every submission's F1 score, so the ranking above can be reported together with a measure of its uncertainty." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "670e1a1f", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-25T12:16:28.775113Z", + "iopub.status.busy": "2026-08-25T12:16:28.774612Z", + "iopub.status.idle": "2026-08-25T12:16:28.784899Z", + "shell.execute_reply": "2026-08-25T12:16:28.782548Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{'Team Delta': (np.float64(0.6771539721539722),\n", + " np.float64(0.8111514168658245)),\n", + " 'Team Epsilon': (np.float64(0.6517443762781187),\n", + " np.float64(0.7978723404255319)),\n", + " 'Team Gamma': (np.float64(0.7628125), np.float64(0.8780458698489652)),\n", + " 'Team Alpha': (np.float64(0.7963957742272659),\n", + " np.float64(0.9086947456213511)),\n", + " 'Team Beta': (np.float64(0.8540010141987829), np.float64(0.9493902439024389))}" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "leaderboard.ci" + ] + }, + { + "cell_type": "markdown", + "id": "a18993fa", + "metadata": {}, + "source": [ + "## Significance against the best submission\n", + "\n", + "`Perf.difference` compares every other submission against the best one (`Team Beta` here) using the paired bootstrap distribution of the differences, and `Difference.p_value` turns that distribution into a p-value per submission. Team Alpha's p-value stays well above 0.05. Therefore, it is statistically tied with Team Beta for first place, even though the two teams' predictions are not identical. Team Gamma, Team Delta, and Team Epsilon all trail the top two, but Team Gamma's p-value sits close enough to the 0.05 boundary that, as the next section shows, the conclusion about it can change depending on how the p-values are corrected for testing four submissions against the best one at the same time." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "adc0eb65", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-25T12:16:28.787983Z", + "iopub.status.busy": "2026-08-25T12:16:28.787664Z", + "iopub.status.idle": "2026-08-25T12:16:28.796233Z", + "shell.execute_reply": "2026-08-25T12:16:28.794429Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "\n", + "difference p-values w.r.t Team Beta\n", + "0.0000 <= Team Delta\n", + "0.0000 <= Team Epsilon\n", + "0.0180 <= Team Gamma\n", + "0.0880 <= Team Alpha" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "comparison = leaderboard.difference()\n", + "comparison" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "0ecb28f1", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-25T12:16:28.799633Z", + "iopub.status.busy": "2026-08-25T12:16:28.799215Z", + "iopub.status.idle": "2026-08-25T12:16:28.806918Z", + "shell.execute_reply": "2026-08-25T12:16:28.805197Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{'Team Delta': np.float64(0.0),\n", + " 'Team Epsilon': np.float64(0.0),\n", + " 'Team Gamma': np.float64(0.018),\n", + " 'Team Alpha': np.float64(0.088)}" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "comparison.p_value()" + ] + }, + { + "cell_type": "markdown", + "id": "e6c5af37", + "metadata": {}, + "source": [ + "## Correcting for multiple comparisons\n", + "\n", + "Every submission other than the best is tested in the same round, so judging four hypotheses at once against an uncorrected 0.05 threshold inflates the chance that at least one \"significant\" difference is actually a false positive, which is the familywise error rate. `Difference.p_value`'s `correction` argument adjusts for this using any method supported by `statsmodels.stats.multitest.multipletests`. Three common choices are `'bonferroni'` (multiplies every p-value by the number of comparisons, which is simple and the most conservative of the three), `'holm'` (a step-down version of Bonferroni that is less conservative), and `'fdr_bh'` (Benjamini-Hochberg, which bounds the expected proportion of false positives among the rejected hypotheses rather than the probability of any single false positive, making it the least conservative of the three)." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "7df65246", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-25T12:16:28.810053Z", + "iopub.status.busy": "2026-08-25T12:16:28.809729Z", + "iopub.status.idle": "2026-08-25T12:16:28.942627Z", + "shell.execute_reply": "2026-08-25T12:16:28.941701Z" + } + }, + "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", + "
rawbonferroniholmfdr_bh
Team Delta0.0000.0000.0000.000
Team Epsilon0.0000.0000.0000.000
Team Gamma0.0180.0720.0360.024
Team Alpha0.0880.3520.0880.088
\n", + "
" + ], + "text/plain": [ + " raw bonferroni holm fdr_bh\n", + "Team Delta 0.000 0.000 0.000 0.000\n", + "Team Epsilon 0.000 0.000 0.000 0.000\n", + "Team Gamma 0.018 0.072 0.036 0.024\n", + "Team Alpha 0.088 0.352 0.088 0.088" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import pandas as pd\n", + "\n", + "pd.DataFrame({\n", + " 'raw': comparison.p_value(),\n", + " 'bonferroni': comparison.p_value(correction='bonferroni'),\n", + " 'holm': comparison.p_value(correction='holm'),\n", + " 'fdr_bh': comparison.p_value(correction='fdr_bh'),\n", + "})" + ] + }, + { + "cell_type": "markdown", + "id": "4d105a9e", + "metadata": {}, + "source": [ + "Team Gamma's p-value crosses the 0.05 threshold depending on the method. Under the raw p-value, Holm, and the FDR correction it stays significantly behind the top two, but Bonferroni's stricter correction is enough to call it statistically tied with them instead. The clear-cut cases are unaffected by the choice. Team Alpha remains tied with Team Beta and Team Delta and Team Epsilon remain clearly behind under every correction." + ] + }, + { + "cell_type": "markdown", + "id": "86f5f236", + "metadata": {}, + "source": [ + "## Visualizing the comparison\n", + "\n", + "`Perf.plot` and `Difference.plot` color every submission by whether it is the best, tied with the best, or significantly behind it, with confidence intervals computed from the same bootstrap distribution. Passing the same `correction` argument used above recomputes that coloring from the corrected p-values." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "8e8e0da3", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-25T12:16:28.946208Z", + "iopub.status.busy": "2026-08-25T12:16:28.945916Z", + "iopub.status.idle": "2026-08-25T12:16:29.611427Z", + "shell.execute_reply": "2026-08-25T12:16:29.609525Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 470, + "width": 565 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "leaderboard.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "984b6647", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-25T12:16:29.614298Z", + "iopub.status.busy": "2026-08-25T12:16:29.613966Z", + "iopub.status.idle": "2026-08-25T12:16:30.400099Z", + "shell.execute_reply": "2026-08-25T12:16:30.398003Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 490, + "width": 561 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "comparison.plot()" + ] + }, + { + "cell_type": "markdown", + "id": "3a5efd82", + "metadata": {}, + "source": [ + "Requesting `correction='bonferroni'` recolors Team Gamma from \"behind\" to \"tied\" in both plots below, since Bonferroni is the only one of the three corrections that pushes its p-value past 0.05. `'holm'` and `'fdr_bh'` can be passed the same way, but neither changes any submission's color in this comparison. Their corrected p-values for Team Gamma stay under 0.05, so the plots would look identical to the uncorrected ones above." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "bfb5a2c1", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-25T12:16:30.403245Z", + "iopub.status.busy": "2026-08-25T12:16:30.402895Z", + "iopub.status.idle": "2026-08-25T12:16:31.101322Z", + "shell.execute_reply": "2026-08-25T12:16:31.099422Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 470, + "width": 565 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "leaderboard.plot(correction='bonferroni')" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "5c47a798", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-25T12:16:31.104912Z", + "iopub.status.busy": "2026-08-25T12:16:31.104583Z", + "iopub.status.idle": "2026-08-25T12:16:31.849706Z", + "shell.execute_reply": "2026-08-25T12:16:31.847528Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 490, + "width": 561 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "comparison.plot(correction='bonferroni')" + ] + }, + { + "cell_type": "markdown", + "id": "fac88a10", + "metadata": {}, + "source": [ + "[scikit-learn Users](sklearn_users.ipynb) shows the same workflow when comparing a handful of estimators against a single gold standard, and [Multiple Testing](multiple_testing.ipynb) shows how to combine several measures in a single `Perf` and correct their p-values." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.13.15" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/quarto/pages/install.qmd b/quarto/pages/install.qmd new file mode 100644 index 0000000..aa6d8d6 --- /dev/null +++ b/quarto/pages/install.qmd @@ -0,0 +1,40 @@ +--- +title: "Install" +--- + +## Requirements + +CompStats is a pure-Python package. Its runtime dependencies are numpy, scikit-learn (version 1.3.0 +or later), pandas, seaborn (version 0.13.0 or later) and statsmodels. The package tqdm is optional. +When it is installed, progress bars are shown while the bootstrap samples are computed. + +## From PyPI + +```bash +pip install CompStats +``` + +## From conda-forge + +```bash +conda install --channel conda-forge CompStats +``` + +## From source + +The following commands install the package in editable mode, together with the dependencies +required to run the test suite. + +```bash +git clone https://github.com/INGEOTEC/CompStats.git +cd CompStats +pip install -e ".[test]" +``` + +## Checking the installation + +The installed version is printed with the following command. + +```bash +python -c "import CompStats; print(CompStats.__version__)" +``` diff --git a/quarto/pages/methodology.qmd b/quarto/pages/methodology.qmd new file mode 100644 index 0000000..7185fc5 --- /dev/null +++ b/quarto/pages/methodology.qmd @@ -0,0 +1,143 @@ +--- +title: "Methodology" +subtitle: "The statistical basis of CompStats" +nocite: "@Nava-Munoz2023" +--- + +This page states the methodology implemented by CompStats, as published in @Nava-Munoz2024. Each section gives a definition, its formula and the CompStats call that +computes it. + +## Setting + +A competition provides a gold standard $y$ of size $n$, kept by the organizers, and the predictions +$\hat{y}_1, \ldots, \hat{y}_m$ of $m$ systems. A performance measure $s(y, \hat{y})$ ranks the +systems. The quantity of interest is the performance $\theta_j$ of system $j$ on the population +from which the test set is assumed to be a random sample. The value computed on the test set is an +estimate of it. The setting imposes three constraints: there is a single dataset of fixed size, +the number of submissions is small, and only the predictions are available, not the algorithms. + +## Bootstrap + +Bootstrapping draws conclusions about the sampling distribution of a statistic by resampling the +data with replacement [@Chernick2011; @Efron1994]. In CompStats, +$B$ samples of $n$ indices are drawn with replacement from $\{1, \ldots, n\}$, and the measure is +computed on each sample for every system, which gives the bootstrap distribution +$s_j^{*1}, \ldots, s_j^{*B}$ of system $j$. The article uses $B = 10{,}000$, whereas the package default +is `num_samples=500`. This value is set with the parameter `num_samples` of every function of +`CompStats.metrics` and of `Perf`. + +## Standard error and confidence interval + +The standard error of the measure is the standard deviation of the bootstrap distribution +(`Perf.se`). The $1-\alpha$ confidence interval is the percentile interval + +$$ +\left[ q_{\alpha/2}(s_j^{*}),\; q_{1-\alpha/2}(s_j^{*}) \right], +$$ + +where $q_p$ is the $p$-th quantile of the bootstrap distribution and $\alpha = 0.05$ by default +(`Perf.ci`). + +## Comparison through independent samples + +For two systems $i$ and $j$, with $i \neq j$, the comparison tests the null hypothesis +$H_0: \theta_i = \theta_j$ against the alternative $H_1: \theta_i \neq \theta_j$. If the +confidence intervals of the two systems do not overlap, there is a significant difference between +their performances. Conversely, if they partially overlap, there is some possibility that the performances of +the two systems are the same in the population. The latter case motivates the paired comparison +described next. `Perf.plot()` draws the intervals of the systems, ordered by performance. + +## Comparison through paired samples + +Every bootstrap sample contains the gold standard and the prediction of every system for the same +elements. Therefore, the difference in performance can be computed on each sample (the paired +bootstrap). For a system $A$ and a system $B$, the bootstrap distribution of the difference is + +$$ +\delta^{*} = s^{*}(y, \hat{y}_A) - s^{*}(y, \hat{y}_B). +$$ + +If the confidence interval of the difference contains zero, the hypothesis that both systems +perform equally cannot be rejected. `Perf.difference()` returns the differences between the best +system and each of the others, or with respect to the system named by the argument `wrt`, and +`Difference.plot()` draws their intervals. + +## Statistical significance + +Let $\delta(x) = \theta_A(x) - \theta_B(x)$ be the difference observed between systems $A$ and $B$ +on the test set $x$. The null hypothesis $H_0$ states that $A$ is not better than $B$ in the +population. The p-value is + +$$ +p\left(\delta(X) > \delta(x) \mid H_0, x\right), +$$ + +where $X$ ranges over test sets of size $n$. Traditionally, if the p-value is below 0.05, the +observed difference $\delta(x)$ is considered sufficiently unlikely under $H_0$ to reject it, in +which case the evidence suggests that $A$ is superior to $B$. The exact p-value is in general hard +to compute and must be approximated. The paired bootstrap is widely used for this purpose +[@Koehn2004; @Berg-Kirkpatrick2012] and applies to any performance measure. +Following @Berg-Kirkpatrick2012, the p-value is estimated as the fraction of bootstrap samples in which the difference exceeds +$2\delta(x)$. The bootstrap distribution is centred on $\delta(x)$ rather than on zero because the +samples are drawn from $x$. `Difference.p_value()` returns these p-values. + +## Multiple comparisons + +Comparing the best system with each of the other $m-1$ systems tests the hypotheses +$H_0^j: \theta_1 \le \theta_j$ against $H_1^j: \theta_1 > \theta_j$, for $j = 2, \ldots, m$, +simultaneously, which inflates the probability of a Type I error. Correcting the p-values serves to +control the Type I error, to avoid spurious findings and to preserve the validity of the research. +Three corrections are +considered, all of which adjust the p-values. Bonferroni is conservative and multiplies each +p-value by the number of comparisons. Holm's step-down procedure adjusts the p-values +sequentially [@Holm1979]. Benjamini-Hochberg controls the false discovery rate [@Benjamini1995]. +In CompStats they are selected with +`Difference.p_value(correction='bonferroni')`, `'holm'` and `'fdr_bh'`, respectively, or with any +other method accepted by `statsmodels.stats.multitest.multipletests`. The same `correction` +argument is accepted by `Perf.plot` and `Difference.plot`. When a `Perf` holds several measures, +each measure is corrected as its own family. + +## Competitiveness of a competition + +The competitiveness of a competition is evaluated with three aspects. The first is the number of +ties between systems in relation to the number of possible comparisons, which is $m(m-1)/2$ for +$m$ participants. A large proportion of ties indicates a higher level of competitiveness. The +second is the coefficient of variation of the participants' performance, +$CV = 100\, s_x / \bar{x}$, where $s_x$ is the sample standard deviation and $\bar{x}$ the mean. +A smaller $CV$ means greater competitiveness. The third is the distance between the winner and the +competitor in the middle of the table, $|win. - med.|$. A smaller distance indicates a smaller gap +between them. + +The potential for improvement of a task, considering its measure, is assessed separately with the +possible percentage improvement, + +$$ +PPI = 100\,(1 - x_{winner}), +$$ + +where $x_{winner}$ is the score of the winner. The $PPI$ is higher when the gap between the +performance of the winner and the ideal value of the measure is large. It applies to scores where +the highest value is the best and the scores are capped. When a competition has a low $PPI$, +achieving substantial improvements is more challenging. It is a measure of the room for +improvement, not of competitiveness. + +The summary tables of the article also report the number of ties with the winner without +correction and with the Bonferroni, Holm and Benjamini-Hochberg corrections, and the $CV$ is not +analysed for the mean absolute error, due to the nature of that measure. These indicators are +computed by the earlier DataFrame-based interface, +`CompStats.performance.performance_multiple_metrics`, documented in the [developer +docs](https://ingeotec.github.io/CompStats/dev/performance_api.html). + +## Scope and assumptions + +The inference assumes that the test set can be treated as a random sample of the population of +interest. Therefore, the intervals and the tests must be read in light of how the test set was built. The +methodology applies to any measure computed from a gold standard and predictions, for +classification and for regression. Measures where smaller is better, for example the mean absolute +error, are handled through the `BiB` (bigger is better) flag, which every function of +`CompStats.metrics` sets for its measure. + +## References {.unnumbered} + +::: {#refs} +::: diff --git a/quarto/pages/multiple_testing.ipynb b/quarto/pages/multiple_testing.ipynb new file mode 100644 index 0000000..96f0ad9 --- /dev/null +++ b/quarto/pages/multiple_testing.ipynb @@ -0,0 +1,658 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "a9f1afbf", + "metadata": {}, + "source": [ + "---\n", + "title: \"Multiple Testing\"\n", + "subtitle: \"A quick guide to comparing several performance measures and correcting their p-values\"\n", + "---" + ] + }, + { + "cell_type": "markdown", + "id": "aa9fe4ec", + "metadata": {}, + "source": [ + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/INGEOTEC/CompStats/blob/main/quarto/pages/multiple_testing.ipynb)" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "5302df5d", + "metadata": {}, + "outputs": [], + "source": [ + "#| eval: false\n", + "# Colab does not have CompStats preinstalled; it is installed only when it is missing.\n", + "# uv, which Colab provides, is much faster than pip; pip is the fallback.\n", + "try:\n", + " import CompStats\n", + "except ImportError:\n", + " !uv pip install -q --system CompStats || pip install -q CompStats" + ] + }, + { + "cell_type": "markdown", + "id": "c4206c3e", + "metadata": {}, + "source": [ + "This page is aimed at anyone who needs to compare systems on more than one performance measure at once, e.g., precision together with recall, rather than settling for a single score. `CompStats.interface.Perf` can hold several measures in one instance, evaluated on the same paired bootstrap distribution, so the comparisons stay consistent across measures. `Difference.p_value`'s `correction` argument then adjusts for testing several hypotheses at the same time, whether those hypotheses come from several systems, several measures, or both." + ] + }, + { + "cell_type": "markdown", + "id": "f7c0c461", + "metadata": {}, + "source": [ + "## Dataset\n", + "\n", + "Three synthetic submissions are built from the same gold standard, each with a different precision/recall trade-off: `precise` predicts the positive class conservatively (few false positives, more missed positives), `broad` predicts it liberally (catches almost every positive, but with more false alarms), and `balanced` sits between the two. The trade-off is controlled directly by each system's false-positive and false-negative rates, so the example does not depend on training an actual classifier." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "cf911317", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-25T12:37:58.692617Z", + "iopub.status.busy": "2026-08-25T12:37:58.692329Z", + "iopub.status.idle": "2026-08-25T12:37:58.771912Z", + "shell.execute_reply": "2026-08-25T12:37:58.771179Z" + } + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "\n", + "def make_system(y_true, fp_rate, fn_rate, seed):\n", + " \"\"\"A synthetic system that mislabels negatives/positives at the given rates\"\"\"\n", + " rng = np.random.default_rng(seed)\n", + " y_pred = y_true.copy()\n", + " pos_idx = np.where(y_true == 1)[0]\n", + " neg_idx = np.where(y_true == 0)[0]\n", + " y_pred[pos_idx[rng.random(pos_idx.shape[0]) < fn_rate]] = 0\n", + " y_pred[neg_idx[rng.random(neg_idx.shape[0]) < fp_rate]] = 1\n", + " return y_pred\n", + "\n", + "rng = np.random.default_rng(0)\n", + "y_gold = (rng.random(400) < 0.5).astype(int)\n", + "precise = make_system(y_gold, fp_rate=0.02, fn_rate=0.30, seed=1)\n", + "broad = make_system(y_gold, fp_rate=0.30, fn_rate=0.02, seed=2)\n", + "balanced = make_system(y_gold, fp_rate=0.11, fn_rate=0.13, seed=3)" + ] + }, + { + "cell_type": "markdown", + "id": "2a7a274f", + "metadata": {}, + "source": [ + "## Comparing three performance measures at once\n", + "\n", + "Passing a list of functions to `Perf`'s `func` argument combines them into a single, multi-measure instance, here `precision_score`, `recall_score`, and `f1_score` from `CompStats.metrics`. Each of them is built with its `.measure` factory so that its `BiB` tag (bigger is better, for all three) travels with it. `measure_names` labels the columns of the result. As with a single-measure `Perf`, fixing the seed makes the bootstrap resampling below reproducible." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "bc6f40c9", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-25T12:37:58.774513Z", + "iopub.status.busy": "2026-08-25T12:37:58.774286Z", + "iopub.status.idle": "2026-08-25T12:38:08.323256Z", + "shell.execute_reply": "2026-08-25T12:38:08.321401Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 0%| | 0/3 [00:00\n", + "Statistic with its standard error (se)\n", + "statistic (se)\n", + "0.8859 (0.0245), 0.8907 (0.0239), 0.8883 (0.0190) <= balanced\n", + "0.9776 (0.0129), 0.7158 (0.0332), 0.8265 (0.0229) <= precise\n", + "0.7149 (0.0306), 0.9727 (0.0120), 0.8241 (0.0211) <= broad" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from CompStats.metrics import precision_score, recall_score, f1_score\n", + "from CompStats.interface import Perf\n", + "\n", + "np.random.seed(42)\n", + "perf = Perf(y_gold, precise=precise, broad=broad, balanced=balanced,\n", + " func=[precision_score.measure(pos_label=1),\n", + " recall_score.measure(pos_label=1),\n", + " f1_score.measure(pos_label=1)],\n", + " measure_names=['Precision', 'Recall', 'F1'])\n", + "perf" + ] + }, + { + "cell_type": "markdown", + "id": "7a721c3a", + "metadata": {}, + "source": [ + "## Best system per measure\n", + "\n", + "`Perf.best` reports the top system for every measure, and the three systems split the wins exactly as their construction intends: `precise` leads on Precision, `broad` leads on Recall, and `balanced`, which is not the best at either individual measure, comes out ahead once Precision and Recall are combined into F1. Note that `best` only compares point estimates. It says nothing about whether the lead is statistically significant, which is exactly what the next section checks." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "96f2fffa", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-25T12:38:08.326507Z", + "iopub.status.busy": "2026-08-25T12:38:08.325972Z", + "iopub.status.idle": "2026-08-25T12:38:08.334853Z", + "shell.execute_reply": "2026-08-25T12:38:08.333034Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array(['precise', 'broad', 'balanced'], dtype='\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
PrecisionRecallF1
balanced0.00.0041.000
broad0.01.0000.008
precise1.00.0000.022
\n", + "" + ], + "text/plain": [ + " Precision Recall F1\n", + "balanced 0.0 0.004 1.000\n", + "broad 0.0 1.000 0.008\n", + "precise 1.0 0.000 0.022" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import pandas as pd\n", + "\n", + "diff = perf.difference()\n", + "pd.DataFrame(diff.p_value(), index=perf.measure_names).T" + ] + }, + { + "cell_type": "markdown", + "id": "1f8e2ab8", + "metadata": {}, + "source": [ + "`precise` and `broad` are each other's clear runner-up on the measure the other wins (Recall and Precision, respectively), with a p-value of essentially 0. The interesting row is F1. Both `precise` and `broad` trail `balanced` with uncorrected p-values under 0.05 (0.022 and 0.008), so a naive reading would call `balanced` significantly ahead of both. But three measures were just tested against `balanced` at once, so before trusting that F1 conclusion, the next section checks whether it survives a correction for multiple comparisons." + ] + }, + { + "cell_type": "markdown", + "id": "a0b27429", + "metadata": {}, + "source": [ + "## Correcting for multiple comparisons\n", + "\n", + "`Difference.p_value`'s `correction` argument passes any method supported by `statsmodels.stats.multitest.multipletests` (e.g., `'bonferroni'`, `'holm'`, `'fdr_bh'`) and, with several measures, corrects each measure independently (i.e., per column), so one metric's correction never mixes with another's. The following table focuses on the F1 column, comparing the raw p-values against the three correction methods." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "c937b6b5", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-25T12:38:08.366364Z", + "iopub.status.busy": "2026-08-25T12:38:08.366089Z", + "iopub.status.idle": "2026-08-25T12:38:08.634874Z", + "shell.execute_reply": "2026-08-25T12:38:08.632335Z" + } + }, + "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", + "
rawbonferroniholmfdr_bh
balanced1.0001.0001.0001.000
broad0.0080.0240.0240.024
precise0.0220.0660.0440.033
\n", + "
" + ], + "text/plain": [ + " raw bonferroni holm fdr_bh\n", + "balanced 1.000 1.000 1.000 1.000\n", + "broad 0.008 0.024 0.024 0.024\n", + "precise 0.022 0.066 0.044 0.033" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pd.DataFrame({\n", + " 'raw': {k: v[2] for k, v in diff.p_value().items()},\n", + " 'bonferroni': {k: v[2] for k, v in diff.p_value(correction='bonferroni').items()},\n", + " 'holm': {k: v[2] for k, v in diff.p_value(correction='holm').items()},\n", + " 'fdr_bh': {k: v[2] for k, v in diff.p_value(correction='fdr_bh').items()},\n", + "})" + ] + }, + { + "cell_type": "markdown", + "id": "e2c32a2d", + "metadata": {}, + "source": [ + "`broad` stays significantly behind `balanced` on F1 under every method. `precise`, however, crosses the 0.05 threshold depending on the correction. Bonferroni's stricter adjustment (0.066) is enough to call it statistically tied with `balanced` on F1, while Holm (0.044) and the FDR correction (0.033) both keep it significantly behind. This is the same lesson as [Competition Organizers](competition_organizers.ipynb)'s Team Gamma, except the extra hypothesis being tested here comes from combining measures rather than from ranking more systems." + ] + }, + { + "cell_type": "markdown", + "id": "ca5f885f", + "metadata": {}, + "source": [ + "## Visualizing the comparison\n", + "\n", + "`Perf.plot` renders one panel per measure, coloring each system by whether it is the best, tied with the best, or significantly behind it on that measure. Therefore, the three-way split from `perf.best` above is visible directly, alongside each system's confidence interval." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "6965dfe7", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-25T12:38:08.638647Z", + "iopub.status.busy": "2026-08-25T12:38:08.638313Z", + "iopub.status.idle": "2026-08-25T12:38:10.005921Z", + "shell.execute_reply": "2026-08-25T12:38:10.004600Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 469, + "width": 1538 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "perf.plot()" + ] + }, + { + "cell_type": "markdown", + "id": "dc32694b", + "metadata": {}, + "source": [ + "`Difference.plot` shows the same paired differences against each measure's best system, coloring by statistical significance instead." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "617dab24", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-25T12:38:10.008795Z", + "iopub.status.busy": "2026-08-25T12:38:10.008463Z", + "iopub.status.idle": "2026-08-25T12:38:11.182336Z", + "shell.execute_reply": "2026-08-25T12:38:11.181428Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 469, + "width": 1521 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "diff.plot()" + ] + }, + { + "cell_type": "markdown", + "id": "09fb1988", + "metadata": {}, + "source": [ + "Passing `correction='bonferroni'` recolors `precise`'s F1 panel from significantly behind to tied in both plots, matching the table above. `'holm'` and `'fdr_bh'` would leave every panel unchanged from the uncorrected plots, since neither pushes `precise`'s F1 p-value past 0.05." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "0c68902c", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-25T12:38:11.185481Z", + "iopub.status.busy": "2026-08-25T12:38:11.185271Z", + "iopub.status.idle": "2026-08-25T12:38:12.352012Z", + "shell.execute_reply": "2026-08-25T12:38:12.350647Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 469, + "width": 1549 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "perf.plot(correction='bonferroni')" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "ec6b4fb5", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-25T12:38:12.354392Z", + "iopub.status.busy": "2026-08-25T12:38:12.354161Z", + "iopub.status.idle": "2026-08-25T12:38:13.340976Z", + "shell.execute_reply": "2026-08-25T12:38:13.340068Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 469, + "width": 1521 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "diff.plot(correction='bonferroni')" + ] + }, + { + "cell_type": "markdown", + "id": "ecf9e9a2", + "metadata": {}, + "source": [ + "[scikit-learn Users](sklearn_users.ipynb) and [Competition Organizers](competition_organizers.ipynb) show this same workflow with a single performance measure, comparing a handful of estimators or ranking many competition submissions against a shared gold standard." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.13.15" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/quarto/pages/sklearn_users.ipynb b/quarto/pages/sklearn_users.ipynb new file mode 100644 index 0000000..1738129 --- /dev/null +++ b/quarto/pages/sklearn_users.ipynb @@ -0,0 +1,712 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "5efdbe21", + "metadata": { + "collapsed": false + }, + "source": [ + "---\n", + "title: \"scikit-learn Users\"\n", + "subtitle: \"A quick guide to comparing the predictions of scikit-learn models with CompStats\"\n", + "---" + ] + }, + { + "cell_type": "markdown", + "id": "5f15b0ad", + "metadata": { + "collapsed": false + }, + "source": [ + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/INGEOTEC/CompStats/blob/main/quarto/pages/sklearn_users.ipynb)" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "fc19dcd7", + "metadata": {}, + "outputs": [], + "source": [ + "#| eval: false\n", + "# Colab does not have CompStats preinstalled; it is installed only when it is missing.\n", + "# uv, which Colab provides, is much faster than pip; pip is the fallback.\n", + "try:\n", + " import CompStats\n", + "except ImportError:\n", + " !uv pip install -q --system CompStats || pip install -q CompStats" + ] + }, + { + "cell_type": "markdown", + "id": "012c9a39", + "metadata": { + "collapsed": false + }, + "source": [ + "To illustrate the use of `CompStats`, the following example loads a classification problem (the digits dataset), trains four different classifiers, and uses `CompStats.metrics.f1_score` to measure and compare their performance. As with the rest of `sklearn.metrics`, the score function takes `(y_true, y_pred)`. The difference is that it returns a `Perf` instance, with the standard error, confidence interval, and pairwise significance tests already computed from the bootstrap distribution. The package is not limited to classification. The last section, [Regression](#regression), repeats the comparison with three regressors and an error measure." + ] + }, + { + "cell_type": "markdown", + "id": "62ca16cc", + "metadata": { + "collapsed": false + }, + "source": [ + "## Dataset and libraries\n", + "\n", + "The first step is to load the digits dataset and split it into a training (`X_train`, `y_train`) and a validation set (`X_val`, `y_val`)." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "bbb251c3", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "from sklearn.svm import LinearSVC\n", + "from sklearn.naive_bayes import GaussianNB\n", + "from sklearn.ensemble import RandomForestClassifier\n", + "from sklearn.ensemble import HistGradientBoostingClassifier\n", + "from sklearn.datasets import load_digits\n", + "from sklearn.model_selection import train_test_split\n", + "from CompStats.metrics import f1_score\n", + "\n", + "X, y = load_digits(return_X_y=True)\n", + "_ = train_test_split(X, y, test_size=0.3, random_state=0)\n", + "X_train, X_val, y_train, y_val = _" + ] + }, + { + "cell_type": "markdown", + "id": "1710649a", + "metadata": { + "collapsed": false + }, + "source": [ + "## Linear SVM\n", + "\n", + "The following line trains a linear Support Vector Machine and predicts the validation set's classes. The predictions are stored in `hy`." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "654559ee", + "metadata": {}, + "outputs": [], + "source": [ + "m = LinearSVC(random_state=0).fit(X_train, y_train)\n", + "hy = m.predict(X_val)" + ] + }, + { + "cell_type": "markdown", + "id": "3f06d338", + "metadata": { + "collapsed": false + }, + "source": [ + "## Score\n", + "\n", + "Once the predictions are available, `f1_score` measures the classifier's performance. The API follows the `sklearn.metrics` convention, that is, the function takes `(y_true, y_pred)`, but the result, `score`, is a `Perf` instance rather than a bare float." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "a1d9d078", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 0%| | 0/1 [00:00" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.random.seed(0)\n", + "score = f1_score(y_val, hy, name='Linear SVM', average='macro')\n", + "score" + ] + }, + { + "cell_type": "markdown", + "id": "be593d1f", + "metadata": { + "collapsed": false + }, + "source": [ + "The printed representation of `score` shows two values. `statistic` is the measure computed on the validation set, here the macro-$F_1$ of the linear SVM. It is the number that `sklearn.metrics.f1_score` returns for the same arguments, and it is available as `score.statistic`. `se` is the standard error of that measure, estimated as the standard deviation of the measure over the bootstrap samples of the validation set (500 by default, parameter `num_samples`). It is available as `score.se`. The standard error quantifies how much the measure would vary if the validation set were another sample of the same population. The confidence interval, by default at the 95% level, is in `score.ci`." + ] + }, + { + "cell_type": "markdown", + "id": "fd51826b", + "metadata": { + "collapsed": false + }, + "source": [ + "## Random Forest\n", + "\n", + "Comparing a second classifier against the same gold standard reuses the same bootstrap resamples. Calling `score` with a new set of predictions adds them to the comparison without redrawing the bootstrap, keeping every pairwise comparison paired." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "d3943219", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 0%| | 0/1 [00:00\n", + "Statistic with its standard error (se)\n", + "statistic (se)\n", + "0.9783 (0.0061) <= Random Forest\n", + "0.9440 (0.0098) <= Linear SVM" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ens = RandomForestClassifier(random_state=0).fit(X_train, y_train)\n", + "score(ens.predict(X_val), name='Random Forest')" + ] + }, + { + "cell_type": "markdown", + "id": "dc59d0ee", + "metadata": { + "collapsed": false + }, + "source": [ + "## Rest of the classifiers\n", + "\n", + "Adding a Naive Bayes classifier and a Histogram Gradient Boosting Tree completes the comparison. `Perf.plot` renders all four systems' performance together with their confidence intervals." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "a65f6157", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 0%| | 0/2 [00:00" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 470, + "width": 550 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "nb = GaussianNB().fit(X_train, y_train)\n", + "_ = score(nb.predict(X_val), name='Naive Bayes')\n", + "hist = HistGradientBoostingClassifier(random_state=0).fit(X_train, y_train)\n", + "_ = score(hist.predict(X_val), name='Hist. Grad. Boost. Tree')\n", + "score.plot()" + ] + }, + { + "cell_type": "markdown", + "id": "551b6fee", + "metadata": { + "collapsed": false + }, + "source": [ + "In the figure, each row is a classifier, and the classifiers are ordered from the best, at the top, to the worst. The dot is the mean of the bootstrap distribution of the measure, and the horizontal bar is its 95% confidence interval. The colour is the result of comparing each classifier with the best one, which is drawn in blue, with the paired bootstrap test described in [Methodology](methodology.qmd#statistical-significance). A classifier is *Equivalent* (green) when its difference with the best one is not statistically significant at the 0.05 level, and *Different* (red) when it is. In this example the random forest is the best classifier and the other three are statistically different from it. The p-values behind the colours are obtained in the next section." + ] + }, + { + "cell_type": "markdown", + "id": "265a9468", + "metadata": { + "collapsed": false + }, + "source": [ + "The data split, the classifiers and NumPy's global random state, from which the bootstrap samples are drawn, are seeded so that this page is reproducible." + ] + }, + { + "cell_type": "markdown", + "id": "c53f9dc7", + "metadata": { + "collapsed": false + }, + "source": [ + "## Comparison against the best system\n", + "\n", + "`Perf.difference` computes, on the same bootstrap samples, the difference between the best system and each of the others. The object it returns prints the p-value of each difference." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "d6b16137", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "\n", + "difference p-values w.r.t Random Forest\n", + "0.0000 <= Linear SVM\n", + "0.0000 <= Naive Bayes\n", + "0.0060 <= Hist. Grad. Boost. Tree" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "diff = score.difference()\n", + "diff" + ] + }, + { + "cell_type": "markdown", + "id": "80f57bad", + "metadata": { + "collapsed": false + }, + "source": [ + "## Correction for multiple comparisons\n", + "\n", + "Three systems are compared with the best one at the same time, so the p-values are adjusted for multiple comparisons, here with Holm's method. The correction is described in more detail in [Multiple Testing](multiple_testing.ipynb)." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "f75b6387", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'Linear SVM': np.float64(0.0),\n", + " 'Naive Bayes': np.float64(0.0),\n", + " 'Hist. Grad. Boost. Tree': np.float64(0.006)}" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "diff.p_value(correction='holm')" + ] + }, + { + "cell_type": "markdown", + "id": "990d439d", + "metadata": { + "collapsed": false + }, + "source": [ + "`Difference.plot` draws the confidence interval of each difference. An interval that contains zero means that the system is not statistically different from the best one." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "e02998fb", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 490, + "width": 565 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "diff.plot()" + ] + }, + { + "cell_type": "markdown", + "id": "b9de8b96", + "metadata": { + "collapsed": false + }, + "source": [ + "## Regression\n", + "\n", + "The same workflow applies to regression problems. The following example loads the diabetes dataset, trains three regressors and compares them with `CompStats.metrics.mean_absolute_error`. For this measure a smaller value is better. Every function of `CompStats.metrics` knows the direction of its measure, so the best system is the one with the smallest error and nothing else changes in the code." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "c44bfd8a", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 0%| | 0/3 [00:00\n", + "Statistic with its standard error (se)\n", + "statistic (se)\n", + "44.6176 (2.8668) <= Linear Regression\n", + "46.5703 (3.3280) <= Hist. Grad. Boost. Tree\n", + "47.7996 (2.9929) <= Random Forest" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from sklearn.datasets import load_diabetes\n", + "from sklearn.linear_model import LinearRegression\n", + "from sklearn.ensemble import RandomForestRegressor\n", + "from sklearn.ensemble import HistGradientBoostingRegressor\n", + "from CompStats.metrics import mean_absolute_error\n", + "\n", + "X, y = load_diabetes(return_X_y=True)\n", + "_ = train_test_split(X, y, test_size=0.3, random_state=0)\n", + "X_train, X_val, y_train, y_val = _\n", + "\n", + "np.random.seed(0)\n", + "lr = LinearRegression().fit(X_train, y_train)\n", + "error = mean_absolute_error(y_val, lr.predict(X_val), name='Linear Regression')\n", + "forest = RandomForestRegressor(random_state=0).fit(X_train, y_train)\n", + "_ = error(forest.predict(X_val), name='Random Forest')\n", + "hist = HistGradientBoostingRegressor(random_state=0).fit(X_train, y_train)\n", + "_ = error(hist.predict(X_val), name='Hist. Grad. Boost. Tree')\n", + "error" + ] + }, + { + "cell_type": "markdown", + "id": "fe9b17e4", + "metadata": { + "collapsed": false + }, + "source": [ + "The systems are listed from the smallest to the largest error. `Perf.plot` and `Perf.difference` are used exactly as in the classification example. The horizontal axis of the figure is now labelled as an error, and the best system, at the top, is the one with the smallest error." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "83ffdb9d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABFwAAAOsCAYAAAB3TKJeAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjIsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvgI3uAAAAAAlwSFlzAAAdhwAAHYcBj+XxZQAAkx5JREFUeJzs3QWYXOX5P+43AoEkBBIS3CW4B6d4Ke5Q3IuVAkULxaVIgSJFiru7Q/EWKAQvxQsUCxISCEmQkOR/Pe/3f/Y32ezsbjZn/b6va66d3Zk5c+bMZOF89nmfp8v48ePHJwAAAABK07W8TQEAAAAgcAEAAABoBipcAAAAAEomcAEAAAAomcAFAAAAoGQCFwAAAICSCVwAAAAASiZwAQAAACiZwAUAAACgZAIXAAAAgJIJXAAAAABKJnABAAAAKJnABQAAAKBkAhcAAACAkglcAAAAAErWvewNAtC2jRs3Ln377bf5+rTTTpu6dpW9AwBA2fxfNkAnE2FLv3798qUIXgAAgHIJXAAAAABKJnABAAAAKJnABQAAAKBkAhcAAAAAgQsAAABA26bCBQAAAKBkAhcAAACAkglcAAAAAEomcAEAAAAomcAFAAAAoGQCFwAAAICSCVwAAAAASiZwAQAAACiZwAUAAACgZAIXAAAAgJIJXAAAAABKJnABAAAAKJnABQAAAKBkAhcAAACAkglcAAAAAEomcAEAAAAomcAFAAAAoGQCFwAAAICSCVwAAAAASiZwAQAAACiZwAUAAABA4AIAAADQtqlwAQAAACiZwAUAAACgZAIXAAAAgJIJXAAAAABKJnABAAAAKJnABQAAAKBkAhcAAACAkglcAAAAAEomcAEAAAAomcAFAAAAoGQCFwAAAICSCVwAAAAASiZwAQAAACiZwAUAAACgZAIXAAAAgJIJXAAAAABKJnABAAAAKJnABQAAAKBkAhcAAACAkglcAAAAAEomcAEAAAAomcAFAAAAoGQCFwAAAICSCVwAAAAASiZwAQAAACiZwAUAAACgZAIXAAAAgJIJXAAAAABKJnABAAAAKJnABQAAAKBkAhcAAACAkglcAAAAAEomcAEAAAAomcAFAAAAoGQCFwAAAICSCVwAAAAASiZwAQAAACiZwAUAAACgZAIXAAAAgJIJXAAAAABKJnABAAAAKJnABQAAAKBkAhcAAACAkglcAAAAAEomcAEAAAAomcAFAAAAoGQCFwAAAICSCVwAAAAASiZwAQAAACiZwAUAAACgZAIXAAAAgJIJXAAAAABKJnABAAAAKJnABQAAAKBkAhcAAACAkglcAAAAAEomcAEAAAAomcAFAAAAoGQCFwAAAICSCVwAAAAASiZwAQAAACiZwAUAAACgZAIXAAAAgJIJXAAAAABKJnABAAAAKJnABQAAAKBkAhcAAACAkglcAAAAAEomcAEAAAAomcAFAAAAoGQCFwAAAICSCVwAAAAASiZwAQAAACiZwAUAAACgZAIXAAAAgJIJXAAAAABKJnABAAAAKJnABQAAAKBkAhcAAACAknUve4MAdC5jx41PQ0f+WPX2/r17pG5du7ToPgG0B35/AnRsAhcAJkuELcuf8mjV2587Yq00Y5+pHGUAvz8BOhVLigAAAABKJnABAAAAKJnABQAAAKBkAhcAAACAkglcAAAAAEomcAEAAAAomcAFAAAAoGQCFwAAAICSCVwAAAAASiZwAQAAACiZwAUAAACgZAIXAAAAgJIJXAAAAABKJnABAAAAKJnABQAAAKBkAhcAAACAkglcAAAAAErWvewNAgC0NcNH/ZS+GvljGvXjz6lXj+5pQO8eqW+vKVt7twCADkzgwiQ5++yz08iRI9MvfvGLtNpqqzl6dEg33XRTevfdd9O8886btt1229beHaCJRv74c7rj5U/Tdc/9L731+XcT3b7gTNOk7ZefM2221Kypdw//SwQAlMv/XXRCl19+efrss89Sv3790r777jtJjz311FPTF198kf74xz8KXJp43GubYoop0rTTTpvmn3/+tPzyy6fevXtP6qYp2TXXXJPuu+++9Ktf/UrgAu3Qt9+PSWc/8k66+YWP06ifxla9X4QwR9/1ejr1gTfT1oNmTweuPTBNO/UULbqvAEDHJXDphC644IL04osv5r/eT2rgwuQf9/r07Nkz7bHHHunkk08WvAA0wYdDR6Vdrnw+ffj16EY/JkKZK575MD3x9lfpyl2XTXNO38uxBwAmm8CFSfL73/8+fffdd2n11Vd35Jqob9++EwRdo0ePTh988EF66KGH8vVzzz03vfTSS+mxxx7L1S+0vG222SYtueSSaeDAgQ4/tLOwZcu/PZOGjvypSY//4OtRaYuLnkm37rVSmqu/0AUAmDwCFybJ4Ycf7ohNpljKddJJJ03081hutOGGG6aXX345/fOf/8xLkPbaay/HuxXssMMOjju0w2VEUdnS1LClEI/f9crB6c7frmx5EQAwWYyFhjZilllmSX/7299qvr/ttttadX8A2pPo2TIpy4gaqnSJ7QEATA4VLpQ6paio3FhnnXXScsstl6//+9//Ts8991z69ttv05xzzpnWXnvtNN100zXq+eK5nnrqqbzkJpbbzDDDDGmllVbKDWYb4/3330//+c9/cvXIiBEjcnXJ0ksvnZeLdOnSpd7H1vVaXn/99fTCCy+kIUOGpIUXXjhtsskmqUyxb1NOOWX66aef8r435Msvv0xPPvlkfn1jx45Ns846a35fZppppkY9XxzTRx55JP33v/9NU089dVpiiSXSiiuumG975ZVX0r333puvH3HEEalbt241j4vXf9lll+XrO++8c5p99tnz9ajMeeONN9JXX32VfvnLX9Yct8KYMWPSs88+m9588838eYjPwTLLLJNfd0PvR4jHDR48ODdu7tGjR5p55pnT3HPPnbdR3+Mn9XGTMqVo6NCh6YknnkiffPJJGj9+fJptttnykrsBAwY0qonyYostVvM5im08/vjj6fPPP08zzjhjWnPNNfP2gIanEUWD3DLd8uIn6eB1FjC9CABoMoELpU4pOvroo/PXmLSzwAILpJ122indfffdE9ynT58+6a9//Wvacccdqz7PqFGj8rYuvPDC9MMPP0x0e5yIXnTRRVWDl7/85S+5WuTtt9+u8/YIS84///x6e9FUvpY4Od9+++3T3//+95rb4/uyA5dK3btX/+f50UcfpUMPPTTdcsst+SS/UteuXfO+RS+Y+oKtq6++Oh144IFp+PDhE/x82WWXTbfeemsOlopjcMghh0wQuHz66ac1t8Ux/Oabb9Kvf/3rHGwUevXqVRO4xD6ec845uRlwBBR1vR/xmVhjjTXq3Ne33nor7b777umZZ56p8/YIJWK523777VfK4xozpShe88EHH5yuuuqqHHbVfg/i833WWWflkK++JsrxXsVSssMOOyy/Zz///PMEn4F4n//0pz+ltmzsuAk/g7V9MWLif8NQpltf/KTeaURNDXGufvbDtMXSQk+aT0O/Hxv6/QpA2yZwoVlEhUZUskRFyGabbZbmm2++HNTccccdudIkqiJiCc1aa6010WO//vrr/NiosAhRhbDCCivkCT7vvfdePhGOhrIxQvnpp59OCy200ETbuOuuu9I777yTllpqqTTPPPPk5xo3blz+WTw2qjCiciUa1VY7yS98//33adVVV00ffvhh2nTTTXMj1WhmG1UyZYtmuXHsQgRWdXnttdfyvsfxjBAkAo/FF188n+TH46NCIgKDuB5BQwRctUVYtc8+++TrcfsGG2yQw4f//e9/+fhGBdMBBxzQqH2OSpwILOKYRO+TqHaJfYn3J0QYEWFMsUQqqkbimEcQERUe8XzF+xEBUhzjSlEtE+FeVPMUrzfeg/g8RPAT1U9RvfLggw9OEJw09XGNESHVKquskvc7RGVQPFdUy0TFUXx2I4iJyq6o+pl++unr3d6ee+6ZrrjiihwkxrbiMxdBZeznKaeckoOzCGTaqqEjf6z39o3Pf7rF9gXKdPpDb+cLtObv11mmm9obANBOCVxoFlFhEieJcUIa1SGFY489NocncTIcVTJ1BS4RxsQJazz+5ptvzktTKkXost566+WvUR0QVQK1l4VEVUCEDsVSl0pRhREBQCx1ihPdCGHqW44Sy6gilIjwKMKC5hIBShGChL333rvOJVabb755vu+CCy6Ybr/99okCpwhcNt5447yU6qCDDkqXXnrpBLfH8qGYNhUikLr//vsnWIIU1TNR2XHaaac1ar/jWMd7Gu9VXRU1J5xwQg5bIvSICo54jZXHOypFttxyy/Too4+mXXbZJe9fZUBx8cUX59AkgpIIMwYNGjTRc0RwE+9PpaY+rjHiNcRnO15HfD7233//CW6P1xmBVVTYxGesvn488bqjiiv2MYKuwumnn55Dovh8x/K2CIXitTRW7cqlSnHMAQCA5qVpLs0iApUIAyrDlhDVJrE8JcRf/yM4qBQnnVHxECIwqR22hKiWufHGG/P1mOgTJ6y1RcVGXWFLiIAienSECG2iR0x94qQ9nq+ssCVOhOMEurgceeSReQxxvK44uQ5RzRChUm2xTCoCiammmioHJXVV90T1yBlnnFGzbCjei0qxtCdO8KNXTFSU1O73Msccc+TjU9fSn7pEBUvcv66wJbbx5z//OV8/6qij8jjs2uFWPC6WMMW47Ojrcskll0xwexGIRG+ZukKTEBVMUSFTxuMaEsvUIlwKu+2220RhS4ifRXgU4t9BfaFO9GuJ5W2VYUuxlC1ClxCj2CNImxRRQVTtEv8OAQCA5iVwoVnEkqC6woBQGaLUPhG99tpr89cIH6KvRTWxzKjYfjR9nVTx2CJAiSau9YnqjXi+sgwbNiz3PykusWQkAouoXollPbHkqVp1SXF8YtlN7TCr0nbbbZeX9UST2gixKhU9ddZdd92qIVIsUaqrR09dosdJhCV1icqOWB4T1S11BROVoUvxftd+P4tql6hEiuChsZr6uIbEcrWib05RKVSXIlgsHlNNNIKOiqu6xFK2CMZCUypxAACA1mNJEc0iGq9WE1UFleFDpSL8iJPMaNAbipPbyuawcb3odRK9OKqJfjDPP/98vk+cdEcAUfjxxx9rJsPUp5jaU5YIJ6LSo7LCIfp8ROVE7Mt5552XVl555ZoT7cqJQtG/pThu1Y5P8TWm8UTYUXl8YilJ9GkJMe2pPnF7Y6oq6js+xfsZ1RqxxKdQ1z4X+1X7/YwKlKgA+fjjj/M0o1iiE2HRoosuWu9SsKY+riFRVRWiUmSRRRaper+4rX///rnKp6hcqkvsW2VD4krRNDcCmfhc1P630pD67h+fA1UuAADQvAQuNItqk1mKIKB26FEZPoTojxGjiBsjmvDWFifZUX0QlQWVU18a+/hKjR2xPCnHphg5XYiGvrF8JF5zNBaOyTnRB6f20qa4X3j44YfzpTEqX1/lMqGGXldjX3d99yvez1gq1NT3M/rR7LHHHrkXTSwBi+VWcYmqmGhcG5UxUdEzzTTTlPK4hhTHsDI4rCbuE/evb3lWff9WKv+91P630pBqVUcAAEDLELjQLJpaQVCEI/FX/7p6mNQlJs9UipPbqLqICS/FtJ/Y3owzzpimnnrqvNQmXHnllfk+RYhRTe1Kk+YQ+/SHP/whV0JEP5PosxITfyqXMlUGR9GjprFTkqotDWroPWrse1jf8Sn2eeaZZ879ThojxknXFn1dos/NZZddlnv2RPgUVRr33ntvvkR/mOhXU/sz09TH1aeoymnM8Sk+a7VHd1eanGobAACg7RK40KbE8omohojKgNpVII115pln5iAlgoA777yz6sl0VL8UoUxbEb1bYp8jqIgw4IEHHqi5bcCAARMs2YqJT5OqcvpP7YbF1apTJvf9LAKHpr6fhZhoVUy1iuk/sQzrnnvuycFJhGxbbLFF7tcSfXDKeFw1sUyomHDUkOI+xWM6qv69/1/VWl3u/u3KacY+U7XY/tD53PriJ+nPD5c/vvmwXy2Qtli6cb8boCm+GPFD2vj8p5v8+xWAtk3gQpuy/PLLp3fffTdPDopJOjGNZ1LFCXVRBVItbIl+KPE8bU301YgmtDGh6cEHH0wvvfRSrs4J0047bR4FHaHBQw891KTAJZaZxPSmWHLVULPgf/3rX6mM9/OGG27I4U30n4lmvGWI4xCXWDIU24+lQdGvJkKUusZpT+7jKsUo7WhyHP2B4r2I7dUlevJERU0o3sOOqlvX+qt0ImwRuNCcdl5prnTBE++lUT+NLW2bvXt0TzutOFf+Cm319ysAbZspRbQpcQJc9PEoRhtPqjiBbsiFF144yT0xWsqhhx5ac732tKLi+ERYEoFMUxTTgGKs9EcffVTnfd58881JHkNcl6geKZYcNSUgaoz111+/5npURzX346I3TCGWflVz9tln1/kYoHwRimw9aPZSt7nVMrMJWwCAySJwoU2JipQYKV2coEfj2LFjx1atUrnvvvsmmsZSTI6JKpCoEKnt5ptvzuOYG2pW2loWW2yx9Ktf/apmrPJ///vfmtsOOOCANMccc+TrUQlTjHiuS1RgRD+Y2mI8c4QgEThFf5Paxy+qUeLn0Vx2csUynYMOOihfj6VSe+21Vx5/XZd4n4tpTZXqC4ZCNMUtLLHEEpP9uMaMFN98883z9b/97W+5P0xt8bO4rQhbJmX7QNMcuPbANPf0E/eAaorYTmwPAGByqJPtxIYPH96ovhoxXne55ZZLLSWWa0TPjVdeeSWfrEfo8stf/jLNOuusuXolAoEYkxtLXmLZUVRjVIYnEUpcf/31OZCJJS1xwhvLPiJgePLJJ9MLL7yQjjzyyNxE9bnnnkttUUzTicAoQoio9ImKnNCnT5/cfyQCmTgOm2yySR5zvOqqq+YeL9EQNnqzREgTDXijSfCWW245wbbjWJxyyinp4IMPzpUy888/f9pss81y35wIKCIYiTHO0cS3qLaZnMau8RmL/bnlllvyaOgIvGL/55133tzbJV7HkCFD8vsZ+x/LqaLRceGEE07I71MEHRGmxVSkeL8jKHr66adrxjSvueaa+bM6uY9rjAhT/v3vf+dlacUkpKI5cSyHK5ZrxWuMxr1A85t26inSFbssm7b82zNp6Mifmryd/r2nTFfuumzeHgDA5BC4dGJx4hmVHg2Jk++WDFzipPiZZ57JJ8znn39+7jdy+eWX1znNJpbHVDaCLfplxMn97rvvnl/j7bffXnNb9IQ58cQT0x//+MccuLRVEQIMGjQoh0MxTem4447LU5ZC9EGJyp0YHR19SF5//fV8qS0CmGL5UG0RZEUYE9uIY1RZpREVNhG6ROATunfvPsEo70nVrVu3HKKtvvrqOeiJsCy+ry2e5xe/+MVEPVGiF0+ESBGsxaW2qNaJ0OPPf/5zzVSgyXlcY0QT3PiMRrXQjTfemMOiyp43EVBF0BWf38pmx0Dzmqt/r3TrXiulXa8cnD74elSTKlsibJmzpEoZAKBz6zK+vnmldEhRLTEp03nixDXGLBc9Rb777rt88lws/akUk3VqP6a2qEopKmu22mqrepdbREVLVCO88cYbufphmmmmycFDLKuJEKi+kcSjRo3KoUE0No0T6njMuuuuW1MNE1UKEebEeOXaVSCNfS1NOe4REP3+979v8P7xuospRVGlU1foFWFJVFS8//77+X2J1xbHJ6pW4nU1VJkSvUviOeLxEcDEe7HGGmvkx0XgFcu6IjAomr9WTt+54IIL8vU999yzZplTQ6JiJ0KkCIxiyVO8f7G/UV2zwgor5Pe3mpgkFFUl8dzxuiNwi9cZlSX1LX9qyuOuvfba/LmJkeM77bRTva8p3tPHHnssB0nx6zSWUcUxjObEjfk8VPv8FaLCK47VSiutNEHfmcmtbiv+HcQxiWbKkztlY/lTqgeYzx2xlqa5tKhvvx+Tzn7knXTLi5+kkT/+33j6hnrARM+WWEaksoWW5PcnQMcmcAHqFCf3EcZEtU1brgZi0glc6CwibLnzlU/Tdc99lN4cMmKi2xeauU/afvk50qZLzqpBLq1C4ALQsVlSBEwkepP8/e9/z9frqmQCaA+icmWH5efMl+GjfkpDR/6YQ5j4ef/ePVLfXtWrJAEAJpfABTqhWC7Ts2fPOpcCRYPbaKL7888/5+U3u+yyS6vsI0CZIlwRsAAALUngAp1QjF+O3ivRmDem+ETfkXHjxuVeJw8//HAaM2ZM7uNyzjnnpJlnnrm1dxcAAKDdEbhAJxQhy5xzzpkGDx6cL7XFbTGOur5mrgAAAFQncIFOaOWVV86TiV599dU8MnnIkCF5qlNMrllqqaXyRKQY0wwAAEDTOKOCTiqWDMVI4rgAAABQrq4lbw8AAACg0xO4AAAAAJRM4AIAAABQMoELAAAAQMkELgAAAAAlE7gAAAAAlEzgAgAAAFAygQsAAABAyQQuAAAAACUTuAAAAACUTOACAAAAUDKBCwAAAEDJBC4AAAAAJesyfvz48WVvFIC2a/jw4alfv375+rBhw1Lfvn0na3tjx41PQ0f+WPX2/r17pG5du0zWcwB0RH5/AnRs3Vt7BwBo3yJMmbHPVK29GwDtjt+fAB2bJUUAAAAAJRO4AAAAAJRM4AIAAABQMoELAAAAQMkELgAAAAAlE7gAAAAAlEzgAgAAAFAygQsAAABAyQQuAAAAACUTuAAAAACUTOACAAAAUDKBCwAAAEDJBC4AAAAAJRO4AAAAAJRM4AIAAABQMoELAAAAQMkELgAAAAAlE7gAAAAAlEzgAgAAAFAygQsAAABAyQQuAAAAACUTuAAAAACUTOACAAAAUDKBCwAAAEDJBC4AAAAAJRO4AAAAAJRM4AIAAABQMoELAAAAQMkELgAAAAAlE7gAAAAAlEzgAgAAAFAygQsAAABAyQQuAAAAACUTuAAAAACUTOACAAAAUDKBCwAAAEDJBC4AAAAAJRO4AAAAAJRM4AIAAABQMoELAAAAQMkELgAAAAAlE7gAAAAAlEzgAgAAAFAygQsAAABAyQQuAAAAACUTuAAAAACUTOACAAAAUDKBCwAAAEDJBC4AAAAAJRO4AAAAAJRM4AIAAABQMoELAAAAQMkELgAAAAAlE7gAAAAAlEzgAgAAAFAygQsAAABAyQQuAAAAACUTuAAAAACUTOACAAAAUDKBCwAAAEDJBC4AAAAAJRO4AAAAAJRM4AIAAABQMoELAAAAQMkELgAAAAAlE7gAAAAAlEzgAgAAAFAygQsAAABAyQQuAAAAACUTuAAAAACUTOACAAAAUDKBCwAAAEDJBC4AAAAAJRO4AAAAAJRM4AIAAABQMoELAAAAQMkELgAAAAAlE7gAAAAAlEzgAgAAAFAygQsAAABAyQQuAAAAACUTuAAAAACUTOACAAAAUDKBCwAAAEDJBC4AAAAAJRO4AAAAAJRM4AIAAABQMoELAAAAQMkELgAAAAAlE7gAAAAAlEzgAgAAAFAygQsAAABAyQQuAAAAACUTuAAAAACUTOACAAAAUDKBCwAAAEDJBC4AAAAAJRO4AAAAAJRM4AIAAABQMoELAAAAQMkELgAAAAAlE7gAAAAAlEzgAgAAAFAygQsAAABAyQQuAAAAACUTuAAAAACUTOACAAAAUDKBCwAAAEDJBC4AAAAAJRO4AAAAAJRM4AIAAABQMoELAAAAQMkELgAAAAAlE7gAAAAAlEzgAgAAAFAygQsAAABAyQQuAAAAACUTuAAAAACUTOACAAAAUDKBCwAAAEDJBC4AAAAAJRO4AAAAAJRM4AIAAABQMoELAAAAQMkELgAAAAAlE7gAAAAAlEzgAgAAAFAygQsAAABAyQQuAAAAACUTuAAAAACUTOACAAAAUDKBCwAAAEDJBC4AAAAAJRO4AAAAAJRM4AIAAABQMoELAAAAQMkELgAAAAAlE7gAAAAAlEzgAgAAAFAygQsAAABAyQQuAAAAACUTuAAAAACUTOACAAAAUDKBCwAAAEDJBC4AAAAAJRO4AAAAAJRM4AIAAABQMoELAAAAQMkELgAAAAAlE7gAAAAAlEzgAgAAAFAygQsAAABAyQQuAAAAACUTuAAAAACUTOACAAAAUDKBCwAAAEDJBC4AAAAAJRO4AAAAAJRM4AIAAABQMoELAAAAQMkELgAAAAAlE7gAAAAAlEzgAgAAAFAygQsAAABAyQQuAAAAACUTuAAAAACUTOACAAAAUDKBCwAAAEDJBC4AAAAAJRO4AAAAAJRM4AIAAABQMoELAAAAQMkELgAAAAAlE7gAAAAAlEzgAgAAAFCy7qkVjB49On3wwQdpxIgRaezYsfXed8kll0y9e/dusX0DAAAAaFeByw033JDOPffc9Pzzz6dx48Y16jGDBw9OgwYNavZ9AwAAAGh3gctuu+2WrrjiipZ6OgAAAICOHbjcdtttNWHLggsumHbddde0xBJLpL59+6auXetvI7Pwwgu3xC4CAAAAtK/A5cYbb8xfV1tttfTQQw+lHj16tMTTAgAAAHTcKUWfffZZ/nrQQQcJWwAAAIAOr0UCl5lnnjl/nX766Vvi6QAAAAA6fuCy+uqr56//+c9/WuLpAAAAAFpVl/Hjx49v7icZPXp0WmSRRdKUU06ZXnzxxdS7d+/mfkoAqhg+fHjq169fvj5s2LDcwBwAAGiHFS49e/ZMDz/8cPr+++9z49znn3++JZ4WAAAAoONOKQrzzz9/XlK01VZbpeWXXz7NOeecaeDAgTmMqc+ZZ56Z5p133pbaTQAAAID2saQofP7552nXXXdNDz744CQ9bvDgwWnQoEHNtl8AnY0lRQAA0EEqXL777ru00korpQ8++CB/P9VUU6X55psv9w3o2rX+VU3TTDNNS+wiAAAAQPsKXP7617/msKVHjx7pL3/5S9pll13S1FNP3RJPDQAAANAxA5enn346fz3yyCPTPvvs0xJPCQAAANCxpxSNGjUqf11zzTVb4ukAAAAAOn7gEv1awujRo1vi6QAAAAA6fuAS04nCvffe2xJPBwAAANDxA5eYUHT44Yeniy66KN19990t8ZQAAAAAHbtp7pAhQ9Lee++dunXrlrbYYot8+fWvf50WWGCB1LNnz3ofO8sss6Qpp5yyJXYTAAAAoBRdxo8fPz41s0GDBqUXX3yxSY8dPHhwfjwA5Rg+fHjq169fvj5s2LDUt29fhxYAANrjkiIAAACAzqRFlhSdeeaZ+S+qkzPhCAAAAKC9aJHAZbXVVmuJpwEAAABoEywpAgAAACiZwAUAAACgPS4pqub7779PY8eOrfc+MTa6a1e5EAAAANB+tGiS8cYbb6R99903LbTQQmmKKabIYco000xT7+Wll15qyV0EAAAAaD8VLhdffHHab7/90pgxY1rqKQEAAAA6buDy2muvpX322SeNGzcu9ejRI2200UZp2WWXTdNPP33q1q1bvY+de+65W2IXAQAAANpX4HLJJZfksGWWWWZJjz32WFpggQVa4mkBAAAAOm7g8vrrr+evxxxzjLAFAAAAJsPo0aPzSpKwyCKL5P6ndNLApUuXLvnrYost1hJPBwAAQIm+/fbb9OWXX6bvvvsuTTfddGnWWWfN7SJoHe+8805accUV8/V//OMfaZVVVvFWdNYpRQsuuGD+OmzYsJZ4OgAAACbTxx9/nA466KA8ZTZCloEDB6ZlllkmzTvvvGnaaadNq666am4fEdUWwMS6jB8/fnxqZi+//HL+h7nbbrulSy+9tLmfDoB6DB8+PPXr168mCO/bt2+bPl5jx41Nw374uurt/aaaPnXrWn8DdgA6Bv9NaDknnXRSOvHEE9NPP/2Uv+/evXuaffbZc/ASlS5DhgzJfTpD/DzO89ZZZ50W3MPO7d1330077rhjzUTgxRdfvLV3idYKXMIpp5ySjj766HTjjTemLbfcsiWeEoAOELh8NfrLtN4ta1W9/YGtHk0Des7QovsEQOvw34SWsfPOO6err746X59vvvnScccdlyfN9unTp+Y+Ebpcf/31+Twvrv/617/O53pAM/VwiZTzxx9/rPO2bbfdNo0ZMyZ/vfnmm9M222yTlxr17Nmz3m3GZKMpp5yyzN0EAACgDmeddVZN2LLuuuum2267rc5zthlmmCEdeOCBOZzZfffdHUto7sAlUs8XX3yxwfvdcsst+dIYgwcPToMGDSph7wAAAKjmq6++SkcddVS+Ptdcc+U/lDf0B/KolI1zu3vvvbfe+40dOzZ99NFHudI2liXNMccceZlSQ41633zzzXx9ySWXTFNNNVW+Hj1jPvzww7xvsZ2uXetuTRqVN5999lmaaaaZ8mVSn2fUqFH5eWI/55577kkqBPjmm2/Sp59+ml93PHcEVA2pth9R1BDHLiqTo39O//79J2lKUTz+gw8+yI+Jx8b+NPa1lPm+/fDDD3k/YpFNHM+pp546dXQt0jQXAACAtu38889P33//fb4e7SAaO2q4W7duaZNNNqnztggd9tprrzRgwIA0zzzz1DTdjRP/XXfdNf3vf/+rut1nn302T+KJSwQfX3/9ddppp51yyBMhQ5y0R/+YWNpU6c4770yLLrpomnHGGdNSSy2VZp555tzg96233mrU83zxxRdpu+22ywFDbCdWZsT+H3DAAWnEiBF1biNChKuuuiovrYr9i0s8dokllsj7EQ2HzznnnBxgNPb1RsCyxx575G3F41dYYYX04IMPTjClKC6vvvpqndv717/+lauUevfunRsfx7Gfc845cwCy9NJLp9NPP73q6ynzffvuu+/SPvvsk5e0L7zwwvm9m3766dOee+5Z9fk7ilIrXM4888ycfJUp1gwCAADQvO677778dYoppsgtICbXCy+8kNZbb700dOjQ/H2crEdAEifzUX1y5ZVX5nDknnvuaXCscYQPEepE0BAn/hEiRBVFVLBsv/32uYHvDjvskM4777wcjET1RIQdcX4aFRoxOnn11VdPr7zySr3VLlHls/766+dKjAgnInT573//m4OBc889Nz311FPp0UcfremHV1lFsssuu+TrUXETFS0R9MR+x+uNJrexBOvhhx9Od999dw6p6hPHLFaQvPfee2m22WbL24rtRgDSGPfff38+Xj///HP+Ph4fwU+EH7E/MdgmLhFERZDTXO/bd999l37xi1/kUCi2EdsqjmdMuHrjjTfSk08+2eDxaLeiaS4AncewYcOiWXq+xPW27stRX4xf5spFq17idgA6B/9NaD6jR48e361bt/z/B8sss8xkb2/o0KHjZ5lllry9aaaZZvxNN900fuzYsfm2cePGjb/jjjvGTzvttPn2/v37j//ss88m2sYDDzxQ8/8syy677Pglllhi/L///e+a2z///PPxyy+/fL59hhlmGP/000+P7969+/ijjjoqv55CPHfx2vbZZ596n2fppZceP88884x/9tlna27//vvvxx977LE199lyyy0n2saPP/44fvfddx9///335+uVvvrqq/H77bdfzePPPPPMOo9Z5X7EezBw4MAJ9qPSyy+/XHPff/zjHxPdPvfcc+fbFllkkfGvvfbaRLe/+uqr4w8//PDxb7zxRrO+byussML4hRZaaPxzzz1Xc/sPP/wwft999625z6WXXjq+o7KkCAAAoJOLZTTFcpdYqlNG892oPgmx5Gfrrbeu6bXSpUuXtOmmm+YeMSEqKWLaUX3ef//9XB0Sy3QKUbER46hDVF786le/Svvuu28eZ13ZHySeO6pgQkxSqm9Qb1RcPPTQQxNUfcQSnJjUFJUz4dZbb00vvfTSBI+LniixL1EZUrs/SlR1ROVNLKsJsbSoIbH8KV5v7eqTxvj4449zhU447bTT0mKLLTbRfWKM9KmnnpqXGjXn+/b222+nRx55JC233HI1P+vRo0euFoplUuG6665LHVWLBC5RMvT666/nJjnN+RgAAAAmXSx9KUw77bSTfQivvfba/DUCgw033LDO+6yzzjp5mU9x//qCkL333rvOxrMRwEQj1xD9Z4488sg6H1/sQywxKsKIusSypGptLaKvTRGmNCUkiJ4lIZY4RYBUn+hVE0uamqJyec6knk+X/b7ttddeefJwXfu4+eab1yxh6qhaJHCJxkGRqkWA0pyPAQAAYNJF1UHhp59+mqxDOGTIkBwqhKj4qM8GG2xQE4RENUQ1xQl+XWKiUohqjah6qe8+4fPPP6+6raiSqSYavUbz2PDcc8+l+sTr+c9//pOef/753Lw2LlFFVIheNPVZe+21U1NFwBE9W8Jvf/vbdMUVV+TJQa3xvq255ppVbyuCrejzUjRr7mgsKQIAAOjkIkyoq9qlKYolKSEa3Nanspqk8nG11dfotlg+VC1sqbxPqO/kPiby1Ke4va59jSU2hx9+eF6SFU11o/pm+eWXr5nYExODCg0FIJUBUVPEsqVYAhQhz2677Zbf32WXXTY37o1mt9HktyXet5n//+CnLr169aq5HiOrO6JSpxSVqVg/2NCMbwAAACZPhBVxUh6jl6uNGW6symUslZUzdam8vb7lL405L2zsuWN9S2Aa2t/o51LXvsYSodVWWy198skn+fvoezLrrLPmYxrLkCL8iHPcYvnMmDFj6n2enj17psmx1VZb5d4xJ510UnriiSdqnjsuEcbEbccff3zuedPa71tD70l71ibTjBjpFY1+ylo/CAAAQHURCMT43hj3G6FBNG1dcMEFm3TIYpRyY6tlKm+vfFxriSUyjdnf2vsaDXXjuMW46mgIG4FHXK8UjX3rq8Ip2xprrJEv33zzTR6L/fTTT6fHHnssDR48OFfjxHKjOPfeb7/92v371qkCl2h4W1mmVSRe8fMiEaxLvNmRqEYDovgaJUZFAyQAAACaTzRqjcAl/PWvf82Xxoq+L0VD2Vh2M8UUU+QqjtrTfGp78cUXawKfpgY8ZXr55ZfTKqusUvX2V155JX+t3Nd47Q8++GC+fsQRR6Rdd921zsfG+XBriEBko402ypfw73//Oze+jV42MZWoCFza8/vWqXq4FA1vi0s0CwrbbLPNBD+vfVliiSVyU53LLrss33+77baboMMyAAAAzSNG/hYjhC+66KJcFdEYsQTp0EMPnaBfShFa3HbbbWnkyJF1Pi7+SB9jmsPSSy+d+560tvqmD/3zn/+smXBU2dQ2Kkh+/vnnfH322Wdv0rZbUrzHca4diia57f19a6vaZNPcSNViHNcZZ5zR2rsCAADQKUS1wg033JBXGkTPj/XXXz/dfvvt9fbdiGBm1VVXnWACT7HEJsTSlaigqKtHRzRwjck4xfW2IHqcxJKg2qLJbdHvJCpGtt9++5rbInAoeq7ccccddW43KocuvfTS1BIiKKmvMXCsLIlKnroCovb6vnWqJUUXXHBBGjFiRM33sTYsxl6df/75aeDAgVUfF9Us0bNlgQUWmKBjMQAAAM1vkUUWyVNstthii9zPJL4ut9xyabPNNsu3Rdjw1Vdf5aqWCGfefffd/Lja52+bbLJJrqK4/vrr01VXXZWbyu655565ZcSnn36aLrnkkvT444/n+2688cb5D+5twSGHHJJDhxjjHCs34vW+/vrreelNvIYQTWcre41GY9hYzXH55ZfnwCWCqlieFeOZo29LhC1xrI499th8aW6x73FMo4lvXCJUKaY8ffjhh+nqq69OTz31VP6+WE7U3t+3ThW4xD/IStNMM03NzwcNGtQcTwkAAEAJotFqVHpEP5JbbrklPf/88/lSl5jC8/vf/36CJUWFOGGPYOJvf/tbXp5U1xKlXXbZJVfJtBWxP+G0007LIUntlRixCiPClNoikIlWGs8991x64IEH8qVSHMvf/e53LRK4FOff0Vem6C1TW4REhx12WDrooIM6xPvWqacUxRsUJWmTO9oKAACA5hcNVG+66aZ06qmn5pP2CBJi2VAsV4mqj/nmmy9PNdpggw2qjhCOk/pY/RArHmJb0XA2+p306dMnLb744nmSz1JLLVV1H+J5ll9++Zr+ItUstNBCebvxtZo4Fy221dAk3HjNUb0RlSDvvfdefh1LLrlkboYbqzHqEtuMHi/R2+T+++/PE4si+Ij7R0ATj49jV+zDgAEDmvx6i4qi4r5xPCvFz2OKUJyHx0jo//3vf3kJUJyTx5Sk6Luy9dZbp7nnnrtV37f+/fvX3C/CrI6oy/iOOvAagDpFeXDR3Cz+Y9y3b982faS+Gv1lWu+Wtare/sBWj6YBPWdo0X2CtuybH75JX38/NH3/8+g0dfeeafqp+6fppjKyk47BfxNoDhEorbfeevn6m2++aeoO7avCpaMaNWpUTbOhSPpqJ4u0TZE2x9rF6Bm04oortvbuAMBkGzVmVHrgv/em2965Ob07/J2Jbp+/78C0xcCt03rzbph6TaFPHgC0u8Al0sAIIcLCCy9cs4So8ueTqnI7kytGdUUDoRANjKJMriExozw6UkeJU1HuVIgGUVFGF6Jcq7557e1ZvP4oH4wysihdm2GGGeosgWsvrr322ryGMl5LtVFnZX7W6ur+Hp/p+AxGSR/liXLHyXlP432JEkuA9mLEj9+mS169KN317u1p9M+jq94vQphTnzspnfviWWmT+TdPv1li79SnR/0l9QBAGwpcdtxxx/Tiiy/m64MHD65pkFv580lVuZ3JFYFBEZDEerS//vWvDT4mGhs9+eSTuRlUjMZqCTHh6bXXXsvXY61f7969U0v7+OOPc/ftKK+L5k+1RZfqtdZaK69HXH311Vt8/9q6ys9afeaaa67ccCqajHXUHkct+XmOYxkd85sq1ti+9dZbpe4TQHP5eMRHaf9H9kkff/dRox8TocwNb16bnv70H+nctS5Ms/WZcBwoAFAeS4omQ5w4rrzyyo1qvDQp4uS0OFkvM3BqjGjpc+KJJ6aTTz45/fTTT/lnXbt2TXPOOWcOnaJ6IJbkfPTRR+mKK67IlzgGMR6sviZVndnMM888QTVVNKuKplXF0qbjjjsu3XbbbXm8WhzjjqYlP8/RvKtaoBPL/0aPHp0bd1WrYonPOUB7CVt2f2DHNOyHYU16/Ecj/pd2e2CHdNl616TZ+8xR+v4BACUHLldeeWVNOX/lyXflzydVWz6Jj87c0Ym6o4iwJWauR2ftMP/886ejjjoqbbTRRhM01YzAIKp+Lr300nzfp59+Ot13331t+r1qTZtvvnmd1VQRuBx88MHp5ptvzkvXYpnTxRdf3Cr72FFEAFjNoosumqu1ojqrI/27BTrnMqKobGlq2FKIxx/w6L7pyvWvs7wI6NQmZToQtFrgEic0k/Jz2pZTTjmlJmzZcMMN8wiwupa5RLPZNddcM1/233//tP3227fC3rZ/s802W7rmmmvyiL0Y1XbLLbcIXABoUPRsmZRlRA1VusT2Dl7ucEce6LRWWGGFqv0Xoc0vKXrsscfy6NHo+dHWx48215SiWMrw/vvv568xbzyWmdSVnsZf3qPaoRD9KH744YcJ7tMcfTA+//zzdMIJJ9RU7kTw0pieIsUvp8p9ruxj8vrrr+fryyyzTM3rjWMQAUN8JgYOHDhRA96otPn666/Tp59+mqtp4ljFZVJFz51Y+jTNNNPkXiltcbb7lFNOmZZddtl8POJ4xXs91VRTNdiQ94MPPsijfSONj9cW25kUk7uNtv55boqowoumu7X/Pcf+xufoq6++SnPPPXdudlxb3Cfew2gwHcdz3nnnzcHkpChjG0DnmEYUDXLLdPd7d6S9l9rP9CIAaI+By+GHH55eeOGFFu9H0twaM6Uoltsce+yxuT/HuHHjJrhtscUWS9tss01u4Bs9YOIkuHaj1T322GOibTbHcYwlLz/++GO+fvTRR+cJPo0VgUlUu9QWQUzlPPs4MT/kkENy5Uxx0h0VHjvssEMOWS6//PJ0//33p7///e/pu+++m2BbcaIbx+mAAw5I3bvX/7GNECyW6jzxxBN5uyF6o8Rj//jHP6a2JsKlEGFkfWFLNDKOfi+33nprbkRbiLBi0003Tccff3yDk7cmdxvt5fPcFNEst/Lf8xJLLJF/d1199dU1U9b+8pe/pAMPPLDmMdEMPHoePfzww+n777+v+Xm8/m233TYfq5lmmqne5y1jGx3d2PETftZq+2r0Vy22L9Da7n3v7nqnETU1xLn5rRvThvNuVOp2oTk09Du/of9mAHS4wCX+WhuKk9/O4p577sn9O+LEM8w+++x5DHCECVG9EX/5j0uEFVEpEuOCowFtnAgXVQFx0lf7r/9RsVG2Bx54IH+NKoett9669O1HdcAGG2yQqyKimiIqIqIZb4yYDhH2FCfj8Vf9qCKI+0QVTFQXRDVGhDURxkS/mGp/+Y+T1k022aQm0CmOeTz+mGOOycFPVC+0FS+99FJ65pln8vV111236v1i2VEcvyKcidcUvUjic/TZZ5/lUdfxebvrrrvSaqut1izbaE+f5zKqXWLfY7/jdcZnJj6vs846a819zjvvvPT73/8+V2HFa43KsH79+uVjGf15LrroonzM4jNbrb9RGdvoDIZ9/3+f2Wp2um+bFtsX6KjOf+nsfIGO8N+MmXp17j9UAJ0scIllI4888kj64osvUlsRU2Ia0zgzyvubKvqbxMlpnKzFEp3aJ0xvvPFGuv7662sCqQgRYp/iUvylPRrTNvdf/2NZSLGUIk6IG1rS0hRRXRJhTlQ6xfKi2uJkdq+99kpbbLFFWmONNSaoYollL7Hc6eyzz04PPfRQrjKI8KW2+HxFRUCELREEXHfddXkZW4gT2qigieqLlh77W/uzFvsS+xoBSLy/ETbFifaf/vSnqkujNttssxyUxDKXaAwb38cJerj33nvzeO44TnH8YtlOZTBQ1jbay+e5DEceeWT+tx/NoVddddWJbo+pUnE8wq9//et02mmnTTDh6Kmnnko77rhjDgsjpIrjWXvJVhnbqE+8l9XE8jUAAKADBC5x0nDBBRfkE4xoxtoW3H777fnSXOIkKUb+Fs1o6/rr9MILL5xOOumk1Nri5L9YHtJcY3Fj+VWckEe1QF3iRDL+ml+XWGoTIUuc7MfSp3PPPbfOwOWMM87IFTER3kSVRtFpvDj5/81vfpPDmOIkty181uJ1x2fgd7/7XdUeQGeeeWYObUIEHcUyrUL8m4pJR7/85S9zoHLqqafmyokyt9GePs9liN5DEULGa6otArJ4v8KWW26ZbrjhhprgqhAhTVSNRYAZAV8EUbvsskup22hIVMoAAACtp2tLPEksL4gT5OiFEJe2IJarxJKBhi71NcKtT2WD1qggacsq/xIefSPqU1Qs1L4Uy2Kq2XnnnauGLY1VLDmKPiT//e9/J7q9mLAUS3Mqw5ZK++67b4v3w6jrs1Y0iv3pp59y9U78+4jrdYlKnbDSSitNFJQU1l577Zo+OrE0qPbyvcndRnv6PJchKkrqClvC3XffXRNeRfhUOygpxOOLYx3LgsreBgAA0La1SIVLnFjEiW5UHuy22275ZC6aa8ZfbmP5QX2TOKKXx6ROYGnsCVVUSzRk9dVXz8sKmnKSHfsevRjitRdLNdriX5179OhRc71onFuXupqgVm6j9vSZSnU11a1PLIGJviDRrLSovqls8hoVMzHFpVD0vAjrrLNO1e0WI62jWqClVPusxfGMAHK//fZLl1xySZ5QExUN8e+k8nVFwNRQj5cQJ+YxESyWi0RFRFGFUsY22tPnuQz1fV6jGXNReRWf07iEIqCq/Fr0p/nPf/5T+jYaEtVe1cT721CDZQAAoB0ELhtttFGexFGIBpBxaYy2MsGkKWJJxlZbbZUbxu65555p7733zv0vosIheovEyW9do3RbWkzwacxJWtEEtdLbb79dc7JYn2iU25Avv/wy97GIpS1FeNLY3joRBFRONKpPWznRjD41EUBG09mYfBMNfyMIiqlNhaIKIlQGTHWJPjCVjyvCkjK20Z4+z2Wo7/MawViI0GnFFVdsUj+VMrbRkAhzAACADh64dFZR2RB/yY6+Fo8++mhulhp9IeJy/vnn5+qAGPna0j1FaosGs7EvEba89tprVe9XNEGtFJVKMea5IT179qz39lgiFD0riuAknism6EQYFBVOEfbE8YtR02HMmDETPL6yMqehiqjKip62YPvtt68ZNRxhU2XgUlk1NCmvq/JxZWyjPX2ey1Df57VYUhWVJ42deFU0Ei5zGwAAQNvWIoFLNOyc1L/O1vUX9/YoluDEZJ2oYoiw4umnn85LNiI4iIAjpvfEsoH42loizIiw484778yVJVG1ssACC7ToPsTrj7AlTkDj5D2Wq9Q+6Y0KmAiH6lLZe6ahz1p9VTytoX///vm1xkl4LJWqdpLd0H4X455rP66MbbSnz3NzKypHYqR5YyadNdc2OpN+U/+/Kry6XL3BjWlAzwEttj/Qmu597+50/svnlL7d3y59YNpw3o1K3y6U7avRX6Wd7tumyf/NAOhwgctqq62WOrsIEqI/RtEAMyb2RJPSWLYR444rT1CrNdBsTjESOAKXEP1Gak+5aU7RLDZO4otxvDHVqi7vvfdevcFcNHaNypeXX345j4eu5qWXXkptSfSoKSp0avcziiVAUZUSx6hyWV5ditvj87PggguWuo329nluTosuumieOvX+++/n1xv9bVpjG51Jty7193ePsGVAzxlabH+gNW290Lbpin9fkkb/XF4D815T9EpbL7hN/god/b8ZAC3Jb6RWEtNHtttuu3y9aGha17KOapNryrbpppumxRZbLF+/8MIL01NPPZVaSjTwjAayYdZZZ616v2i2XM1UU01V018mluVUO24ffPBBm6soeOGFF/LynLoquuJ1FY2KY6x6VJbUJapjiilNyyyzzATNbMvYRnv7PDenTTbZJH+NSp5zzjmn1bYBdE4Rimwy/+albnPj+TYTtgBAMxC4NJM4qY0JO9XECXacaIfoVVKp8q/dtZeYVKvYiBCh6G/SFFGFECfbMao49m399ddPN9xww0TjhSvFbfW9xsaKE/tevXrVBAJ1ufXWW9Pll19e73Z++9vf1jQkPeKIIya6PapIdt999wYrLso4no0VAURU9RS23HLLie5TVIvEcp+YEFT7PYnvo2/K559/nr///e9/X/o22tvnuTktvfTSNYHJGWec0eDEq/jcRahY9jaAzus3S+yd5ugzZynbiu3E9oDOZ/ion9I7X3yXXv5oeP4a3wMdpGlunMDFyVecRMRkkxg5O+ec5fzPQ1vw3HPPpQ033DBXFsSSqtlnnz3NNNNM+bYPP/wwXXPNNbn/RajdZDSqPGIZSDSSPe644/LJcEzWKcYFL7nkkjkYKURlQfRdiT4mk3NSFlUK9913Xz7pj0k0sd0//elPaeONN87PGQ1sY19iKlGcFEez3GLayuRMRIlpPbEE6NJLL0133XVXHuscS5ziMxF9W2KpU1StnHjiiemoo46qup3Y75iIdc8996Szzjorvf7662mXXXbJfV9iOdK5556bqy9iuk59I8HLOp6FWDJSu6omqkliGU685mLcb3xOiiqRSvGaYplVfGaiyic+FzElKIKNGJ0dI6X/8Y9/5PtuttlmzbKN9vh5bk6XXXZZevPNN9M777yTmx5fccUVue9QvM54fRFcxfte9Li56KKLJmiGXNY2gM6pT49p0zlrXZB2f2DHNOyHpvcl6zdVv3TuWhfm7QGdw8gff053vPxpuu65/6W3Pp+46nnBmaZJ2y8/Z9psqVlT7x7ta75K/AHro48+qvO2qLiOc5mo6I//9+xoS95pu1r8X1FUUUQJ/fPPP597V9T+S/jOO++cDj744NxItD3r06dPDhIeeeSRfKlL9ByJSoy6Goyefvrp6de//nU+md11111bbFR2NM+NPh5HH310uu6663JoEZdq4qQ7qkYOPfTQyW6sHCefcXJZe2x4/EKMoCUqWOoLXIrPV4Q3d999dx6zHJdCnMBHeBPhQUuKXh1xqU/sc5xQFyFEbVHdE01so6Hws88+my+V4hjF+xC3VzM522ivn+fmEv/BjgqcvfbaK1df1XdcYklXXYFkGdsAOq/Z+8yRLlvvmnTAo/umj0b83x8/JrWyJcKW2frM3iz7B7Qt334/Jp39yDvp5hc+TqN++r+l7HWJEObou15Ppz7wZtp60OzpwLUHpmmnniK1BxdffHF68sknG7zfXHPNlU455ZQ8bbUtij8Mjxw5Mq244op6oXYALRa4REl8fKiLxqx1ib/mnnrqqenqq6/OlQ5ln4TFCWHR5yP+itwYkYJGf5G6JrbEX+WL7VVOyQnLLbdcntoSAUKM0o1KkHh9sfQiKi5iScFWW2010fKLyhG8MW63CD2+/fbbmj4f0bC0UvTbiICq9s+bKqoXrrzyyvyLKIKPODGPv7YX1UhxohhNP1dYYYW0yiqrTNTotRAniMXxaWgsdJzQxy/IW265Jd1///15WlK8npiWFJUZ8T7EL55iezHdpS7xPPHZiSa8sTwperbEduJ477HHHjkgimlIsZ1q+1TG8az8rFU7gY7juMQSS+T3ur4GtSHCjqjQieVAUe0Tn414P+K4xVjh+CwVPXiaYxvt+fNciH2Mf8fVKuni+ar9e672+Y7jGEFhBHxR9RVLtqJBcRyTqNCKfx+rr756/nfTXNsAOnfocuX616VLXr0o3f3eHWnUmFGN6gETPVtiGZHKFugcPhw6Ku1y5fPpw68b32w7QpkrnvkwPfH2V+nKXZdNc07ffppqR6uC/fbbb4Kfxf9fxeqK6FMZfwCMP3Z+8cUXbXKy5kknnZT37fDDDxe4dABdxtfXpKNEUbkSQUqIk6k4OYsTqzjp/OGHH/KSj3vvvbem+mDAgAH5BC1OOAAoT4xOL5oiR5DW1qtnvhr9ZVrvlrWq3v7AVo+aUkSnF2HLA+/fl25/++b0zvC3JzoeA/sukDZfYOu03jwbaJBLu+a/CZMetmz5t2fS0JFN78/Sv/eU6da9Vkpz9W/boUv8gSr+gBt/tCr6EtYWf9xac8018x//4g+g8YfYtvb/QfEH4iJwiWIE2rcWqXCJD3YRtkTwEmVSlT0bCrFc5I477sgVDdFD5IQTTsjLLAAAqL9yZcsFts6Xb374Jg374es0esyo1HOKXqnfVNOn6aaauFIX6PjLiKKyZXLClhCP3/XKwenO367cbpYX1VfxfMghh+T2CfFH/+hhGP0qoV0HLtFcNUSzzWgMWV+TomjYGQ08o3Fm9DW44IILqva1AABgQhGuCFiA6NkyKcuI6vPB16Py9o7daJF2f2Arl/JHy4KGRDATAzDef//9PLUzVmtEa4X555+/Uc/36quvppdffjlXFUfRQfQtHThwYG6dUCl6PsYwhWIyaPT6q13hoq9L+9MigUt8yMI+++zTqI7QW2+9dV53F2vtopdHtb4QAAAATDyNKBrklumWFz9JB6+zQLubXlRbBCeVDXTr60EaU1Jj4EtdwUwsYYrigIUWWqjOx0fvwxiOUEwkrS16Yp588sk1FTZFH9NCLI+q3QRYX5f2p0X+tcQauaIZa2NEE9YYJRspYDT1FLgAAAA0Tox+rm8aUVNDnDtf+TTtsHzdAwjaS9gS01FDVJgsv/zydd7vu+++S+uuu2565plnasKRqC6JIQuxjQceeCAPkoifRSgSgzAq/fvf/05rr712ro6JYQhrrbVWDnfiPDcKCqKSJQZJRBPfInDZYostcvVNtN+IKpeoookVIrVDHtqXFglciokf8eFqjBgXHQ2MQl3TgQAAAKjbdc9N+rj4xrjuuY/afOASYUXtpTgxMCCmFMWQljFjxuTwIyZFVpu2GpUpEbbExKNrrrkmt72oFJNQ119//fTWW2/liUcRnlS2wTjjjDNy2BIDYKLSpa5KmjfeeCMXGBSij2mIabHxGiJs0TS3/WuRwCUSvxjTG7PRY7lQQ2L9WiwniglGs802W0vsIgAAQLs3fNRP6a3Pv2uWbb85ZETeft9eU6a2Kpb/HHHEEVVv32STTXLP0JiKW5fot3LDDTfk63H+WjtsCXPPPXfuN7r44ounN998Mwc5lc13X3vttfx10003rbpsaeGFF57k10b70yLdaIuQ5dFHH0377rtvTvuqefjhh9Mee+xRU1alYS4AAEDjfDXyx2Y9VEObefuTK6pSotdJ5eWggw7K56T9+vXLfVIiBLn77rvrfHxUtIRobrvNNttUfZ5FFlkkTz0Kf//73ye4LZ6nCF5i9QadV4tUuCyzzDJphx12SNdee2268MIL84c8PvDxAY2559GQ6L333str4YrGQFHdcswxx7TE7gEAAHQIo378uVm3H71c2rKYBFRtKU4s1dl5553TbbfdljbffPP04IMP5l4rlZ599tma7Zx11ln5+vjx42tuL67H1++//75miVGlX/7yl+mxxx7L041WWmmlXFAQP5tzzra9HIvytViL6Sjbiga4UW4V/VnOPvvsqvedaaaZ0p133pkb5wIAANA4vZp5ilB7nlIU1S/RI+WRRx7Jg12OPPLIiQKXIUOG5K/R8+XQQw+dpCExhaioiWKCaIr73HPP5UuIdhmrrrpqXqYUy426d2+/x5LGabF3eKqppkr33HNPuu6669J5552XBg8ePFF5VQQt0SwoPtjV1tQBAABQtwG9ezTroenfzNtvblG5svLKK6f7778/n5MWvUMLP//8c82SoQ033LBR26zdpyUmEz3++OPpxhtvzKs8IniJ6poYInP99dfny/zzz58rbRZbbLGSXyFtSYtHattvv32+jBgxIo/DijQwwpjo4BzNhwAAAGiaaGi74EzTNEvj3IVm7tOmG+Y2VuUf9z/99NMJApe4LX42wwwzTNaUoOhFut122+VLhDjRjPcf//hHDlliAlJU0ESgE+fEPXq07xCLVm6aW5c+ffqkQYMG5ZnkkTAKWwAAACbf9s00unn75edIHUFUtVQuM6q0/PLL1/Ry+e67ckKrWDq07LLL5qVGMSb6qKOOyj//6KOPanrGFLp06VLKc9LJAxcAAADKt9lSs6ZeU3YrvXfLpku2/x6bo0ePzqFHmHbaaSdqZLvtttvmrzFZ95RTTmmWfahcqlS7/0vPnj3z11iCRPsncAEAAOhAIhzZetDspW5zq2Vma9cNc8NPP/2U9t577zR8+PD8fUzSrd24drXVVksbbbRRvh5Lik4//fSavi51bS8a8H755ZcT/DwGwAwbNqzqfkTj3kLtHi5FP5gXXnhhkl8fbU+L/IuJzs+vvPLKJD2mW7duedlRzD+P8dExtis6OgMAAFC/A9cemJ54+6v0wdeTXykx9/S98vbag6gMqd17JQKTjz/+ODfKjca1RVPcE088sc5tXHPNNXmMczTVPfzww9Nf//rXtM4666Q55pgjV7588cUXeTvRi2XkyJH5ftHzpbDLLrvkn0cLjWiOG8NhpplmmhzMREDz9ttv5/vFuOh55plnouqXGCn9r3/9Kz9njJWOnqdhxRVXzIEQ7UeX8ZVDxZtJfNBefPHFyd5OBC7x4Y8POgBNE3/V6devX74ef33p27dvmz6UX43+Mq13y1pVb39gq0fTgJ7/739yAOi4/Ddh0nw4dFTa8m/PpKEjf2ryMe/fe8p0294rpTmnn7DXSVuz+uqrpyeffLLB+8UEoZiM++c//7ne/wf68ccf0wknnJDDlhj4UpcIQn7xi1+kyy67LM0++/+rKNptt93S3XffPUGvmErRN+aQQw5JRx99dC40qP28MTL6wQcfnOhxEf5MTiNfOmjgcvHFF6fPPvssXy6//PIUTxlJ3eKLL54/5JESvv/++3lcVnwoI6DZYIMN8vq6aCT0xBNP5BQxREL4/PPPp+mmm665dxugQxK4ANBeCVyaFrrseuXgJlW6RGXLlbsu2+bDluKcM84p6xLLhqJfy8CBA9Mqq6wywVSixvZ8ef311/P/Q8VY6RlnnDEHLFFxMvXUU9f5uHHjxqWXXnopvfXWW2nIkCE5tIl9WGihhXI4VLtZb23x2GioG+fBsXQpxOPWXXfdRu87nSRwCVEWFcuClltuufyPofas8hAfpHPPPTf94Q9/yOVVF110UU0J2HnnnZdTwPjgHnnkkenkk09uid0G6HAELgC0VwKXpvn2+zHp7EfeSbe8+Eka+WPd/UgqRa+W6NkSy4imnXqKJj4r0CI9XKKyJcKWeeedN913331piimmqFreFaFKzCHff//9cwIZo7Mikfz973+fvvnmm1zWde211wpcAAAAGiFCk2M3WiQdvM4C6c5XPk3XPfdRenPIxMtkFpq5Tx79HNOI2nuDXOg0FS7HHntsDkqiG/POO+/c4P2j0qV///65XCuaEXXt+n/DlCJwiZ+PHTs2ff7557mUC4BJo8IFgPZKhUt5ho/6KQ0d+WOueIlwpX/vHqlvrylLfAagRWLLYqRV9F9pjKh0iXnosU4uqmNmm222/PPo2zL33HOn9957Lw0dOlTgAtAJ9Jtq+twYt77bAegc/DehPBGuCFigAwQu3377bf4aIUljFfeNxxaBSxHGhGI0FgAdW7eu3UwhAsB/E4B25//W6jSzYozz9ddf3+gGu7FkKJYSVYYtoZibPsssszTDngIAAAC0k8Al5oiHm266Kc8Nj0lD1bzyyitpp512ytfXWGONPDqrECOxYpxWhDDVxm8BAAAAdIolRVtttVUe9xzzy4844og8ZWjrrbdOiy++eOrbt2/64Ycf0gcffJD+/ve/p7vuuis3xY2lQ6effvoE27n33nvz1/XWW68ldhsAAACg7U4pCsOGDUsbb7xxDl0aElUtsfxo/fXXn+DnN954Y3rrrbfStttumxZYYIFm3FuAjqu9TSkCAID2qMUClxBLiS6//PJ00UUXpZdeeinVfuoBAwbkMOXwww/XowWgmQhcAACggwUulWL60Lvvvpu/9ujRI80666x55DMAzUvgAgAAHaSHS7VlQ4MGDWqtpwcAAABo31OKAAAAADoTgQsAAABAW15S9Oabb6ZRo0aVucm08MILp549e5a6TQAAAIB2E7jsuOOO6cUXXyxzk2nw4MF6vQAAAADtiiVFAAAAAG25wuXKK69MI0eOLHOTaaGFFip1ewAAAADtKnBZdNFFy9wcAAAAQLvUppcU/etf/0pffPFFa+8GAABAh/LND9+k/w5/L73+1Wv5a3xP27DzzjuntddeO1144YWprWoP+9jhKlzK8Omnn6ZrrrkmXXXVVemtt97KTXNnnHHG1t4tAACAdm3UmFHpgf/em2575+b07vB3Jrp9/r4D0xYDt07rzbth6jVFr9SeHHzwwenVV19t9P1XXnnldPzxx6e26Omnn07//e9/2/QKkvawj21Bmwhcfvjhh3TnnXfmHjB///vf07hx41p7lwAAADqEET9+my559aJ017u3p9E/j656vwhhTn3upHTui2elTebfPP1mib1Tnx7TpvYgpuU++eSTjb5/7969m3V/aBu23nrrNGzYsLTtttum3XffvXMFLrFkKEKWm266KX3zzYQlbLPPPns+KPPNN1+r7R8AAEB79vGIj9L+j+yTPv7uo0Y/JkKZG968Nj396T/SuWtdmGbrM3tqL/r27ZtuvvnmBu83wwwzpLbq6quvTqNHj05zzDFHa+9Ku/fUU0/lNiWDBg1qlefv3tpLhipNO+20aYsttkg77LBDWn311VOXLl1aevcAAAA6TNiy+wM7pmE/DGvS4z8a8b+02wM7pMvWuybN3qd9nPxPOeWUubdIe7bSSiu19i7QngKXhpYMde3aNf/s4YcfTsstt1xL7BIAAECHXkYUlS1NDVsK8fgDHt03Xbn+de1meRF0isClviVD8847b9puu+3S9ttvny+x5i6CFwAAACZP9GyZlGVEDVW6xPYOXu7wTvG2/O9//8urMqIJ788//5zbXOyyyy5pkUUWSZ999lnaaaed8v1OPfXUCZaqDB06NG2zzTb5+gknnFC1UuXDDz9Me+yxR75+5plnpiWWWGKiCUCxMiRWf+yzzz41P7/hhhvSZZddlleC3HjjjWn66aev+hrGjx+fttxyy/Ttt9+mddZZJx122GET3P7ll1+mBx54IP373//OrynO12M51lJLLZWfd+65505lefLJJ/Nzvf/++2nUqFGpf//+aYUVVki//vWvU79+/ao+bqONNkrff/992nXXXXNmEMus4n2Jhr3RlyXakGy66abpV7/61USPPfbYY/P9hg8fnr+P4/XCCy9McJ+W6OvSvSWXDMU6uTioEbTEAQYAAKD8aUTRILdMd793R9p7qf3a3fSiSXXxxRenAw88MJ/oV4pg5MQTT8zns48++mhNwFJ7ZUdx23777Vf1OUaOHFlzvyIQaMwEoKWXXjqfSxcBwm9/+9uqz/HEE0+k22//v8/A7373uwlu23fffdNFF12UQ5narr/++nTEEUekww8/PL/eyWnz8d5776Udd9wxF2LU1afmD3/4QzrvvPNqAqzaHn/88RzQRLuRN998M22wwQbpgw8+mOA+8ToiOIntde/+/+KNCMuKY1yEaHGp1BJ9XUoPXCJhqkyOpplmmvyzSKRiLV23bt3KfkoAAAD+fzH6ub5pRE0eKf3+fWnLBbbusMc5Kkj22muvfH2WWWZJ+++/fw49opoiVm0cddRRueKltSywwAK5Bcfzzz+fA4b6Ape4PUQ1yfrrrz/BbR999FGac84508Ybb5yrd+K1FgFJVNC8++676eSTT86TnCIUaYp33nknV/h8/fXXuVdrVAjF95EPRKXLJZdckkORqOaJoKQIkuoSxz+qdHr16pXOOuusNHDgwLzdCFueffbZ/L4tueSSE1TxRIVRhF4xpShCrag8ql3NMtdcc6V2F7hUpmS77bZbOuecc4zcAgAAaCG3vdPwlJ6muP3tm9t84BIn141pmlt7OdCIESNqqlIi2PjnP/+Zw4pCVGqcdNJJ+US+NUVAEYFLXCLUiPChtlh6c9ttt+XrUf0xxRRTTHD73/72tzTrrLPWuf2DDjooh05XXHFFrnDZe++903TTTTfJmUBUAn399df5WD7yyCNpttlmm+A+e+65Z9632M8IjjbccMPUp0+fOrd3/vnn5yqXu+++O/Xo0aPm5/H4VVZZJR+Lv/zlL+nggw+uKfBYfPHFa5oohwiYWqOZcrM2Tbn88stzYnbAAQfkgwAAAEDz+eaHb9K7w99plm2/M/ztvP227KeffspLSRq61F4OFEtpopIiROVEZdhS+OMf/zjRMp+WFpUaRYhQVLHUdscdd6TvvvsuX69ruU61sCVEOHPuueemnj175uDm3nvvneR9jGDklVdeydej3UjtsKV4nli+NfXUU+f+MVFBVE0sa4qWJZVhS7GNoqrl888/z/1o2prSA5drr702v+iiLClmXscbtvzyy6f5558/N695++23y35aAACATu/r7ycMEso27Iev2/QxjsavMRm3ocuyyy47wePiZ0UlRFRTVDvxj6UxrSmazEY1SHHuXVcfliKIWXjhhZvUpySWEhWNfF966aVJfnxMKA4LLbTQRMe59mspertG35pqYjnRTDPNVOdtkTMUouKnrSl9SdGCCy6YTjvttPSnP/0pj3mOKUV33XVX+vHHH/OasCjBissyyyyT+7oUXZwBAACYPN+X3LulttFjRqW2LKo/mrJ05I033qhpTFufhm5vqWVF0RA3msA+9dRTabXVVqu5bciQITXNYqs1oy0qgSJkiqVT0VMlllSNGTOm5vaiSCKmGU2qIqT56quv0rrrrpuvVwZDxfX4+p///Kdmv6uJ4KiaykqkeA2dZix0rJ1ab7318iVKhKKRTYQvxdKiGAMdl0MOOWSCbsIAAAA0zdTdezbroevZQacUxTlrqG9McahvFHNLiXPsAQMG5EAjqlkqA5eoehk7dmzq2rVr2mGHHaqOaY5KnRhP3ZCYEjSpondLGDp0aHrooYca9ZhYvlRfxU01lVlCazY0rqZFko5oshPzw+MS45wieIkPQsz7HjduXE7Xig9ONNeJD4ax0QAAAJNm+qkn7j1Spn5TtX7g0ByKvijFuWk19d3e2BHKkxsMRO+SaBgbrTtuvfXW9Ne//jX3Qil6poS11lqrzl4tMYEozrtj7HU0qY0pPrH6JJbsRN+WCGrCoYcemvuw1LVkqSFFCLL66qvnvjeNMamNeduLFi8tiXVc1ZYcRQIWHYjjEs12Y8lRdEmu1q0YAACA/2e6qaZL8/cd2CyNcwf2XSBvvyOaeeaZ87jkWKZTn/qqQqaaaqqa6xFoVBMNXstYVhSBSyyjiZ4pEcC8/PLLNY1jqy0ninPtImyJQGXuuedOZYugJ47jiBEjWmUyUFvSrFOKGrPkKLoRxwfuggsuyDPFC9Hv5fjjj2+TjW8AAADaqi0GNs/o5s3b+EjoyVE0X40WGPX1AokRx/VVaRSVMtEXpZonnngiTa7oJVNMTCqqWopmubEEZ/PNN6/zcUUgs+aaa1YNW2K0dtFbpSmKJU4vv/xy+uCDD1JrKsZEN6VSp10HLnUtOXruuedys6LKKUcAAAA03nrzbph6ltzLpdcUvdJ682zQYd+GaG0Rfvjhh3TmmWfWeZ+PP/44r9Co7+S+mO4TqzjqElN8L7nkklL2uahiiZUjn3zySe6bGrbccsu8PKguxZKhaO9RTRQ+VDbQnVS77757XlY0fvz49Lvf/S63EWktxWqZCJE6beBS15KjKOe6//77BS8AAACTGI5sMn/dFQ5NtfF8m+XtdlQrrbRSXoERTjrppHTOOefk5rOFqPiIiTsNLcEppvAOHjw4HXfccROEDa+//nr65S9/meaaa65S9jl6n0bIE/u522675TCnWG5Uzcorr1xTyRPn3ZX9ZKKy5+CDD06XXnppbvHRVPPOO29N75b77rsvbbDBBnVWzMRzx5SlP/zhD3mFS3MoJhxFZdJ3332XWlqbHQ9ULDkCAABg0vxmib3T05/+I300ov6eJI0xR5858/bag6hkaEzfkGmnnTbddtttE/zs8ssvz8thoq3FgQcemIOXBRdcME8wirAk+rxEFUk0g61m3333TVdccUW+f1SKXHzxxWn++efP45XfeuutHABceOGFaZVVVpns1xr7EwHOgw8+mEc8hznnnHOCqUW17b///vl1RrVOBB1nnHFG3r+oaInlRvE19j+WJ01OCHLsscfmAOcvf/lL3r+4xL7NMcccuYoowqFoLVI0IY6qnOaw44475hHasbRp9tlnz8uwil470fcmqnE6ZeACAABA0/TpMW06Z60L0u4P7JiG/TCsyYex31T90rlrXZi31x7ECfyjjz7a4P3qGu8ck3qefvrp3OIigpUY6vLPf/4zTx+KYoAIShpaahMn8/H8++23Xz7RHzJkSL7EZKGoSDnvvPPy8p+yxLKiCDMK8Rz1TUuKsdfxmmL/ovokXmNcwlJLLZVOOeWU9Ktf/aqmH0xTxT6cddZZaaONNkqnn356evzxx3Mj3cqmxNHvZo011siVQxH6NIdNN900h0qnnnpqfp3x/hYGDRqUmluX8a3VPQaAVvvLT/zHNgwbNiz17dvXOwEAHdTHIz5KBzy6b5MqXaKyJcKW2frMntq6F198cZL6dMTJ/qqrrlr19lh+8vbbb+dlL7FEZsCAAfnnUfVRhAMPPPBADguqif2JbcTqjViiU/w/16hRo9Kzzz6br8dI5tr/L/bMM8+k0aNH52qQgQMH1vs6YtrvP/7xj5rvIzSpK0yqtn9RdRORQDzXbLPNVnNbNLz9+uuv0wwzzJAWX3zxiR47KfsYoqolRlLHc0ZT3xlnnDFvO4Ko+poLx/GPY1dtGVbsexGwRXuSukZhh1jaFc8flTVFVU1sc3KWTjWGwAWgkxG4AEDnMuLHb9Mlr16U7n7vjjRqzKgG7x+9WqJnSywjai+VLS1lUgIXsKQIAACgA4vQ5ODlDk97L7VfeuD9+9Ltb9+c3hn+9kT3G9h3gTz6OaYRdeQGudBSBC4AAACdQIQoWy6wdb5888M3adgPX6fRY0alnlP0Sv2mmj5NN9V0rb2L0KEIXAAAADqZCFcELNC8ujbz9gEAAAA6HRUuAAAA0AgxBefvf/97zUQgqI8pRQCdjClFAADQ/CwpAgAAACiZwAUAAACgZAIXAAAAgJIJXAAAAABKJnABAAAAKJnABQAAAKBkAhcAAACAkglcAAAAAEomcAEAAAAomcAFAAAAoGQCFwAAAICSCVwAAAAASiZwAQAA6GTGDhuexrz9dvrxpZfz1/ieCc0333ypS5cu6cADD6z30Fx22WVppZVWStNOO22+f1z22GOPCe5zyy23pDXWWCP17ds3de3aNd9nww03dMg7uO6tvQMAAAA0v3EjR6bRt92eRl1zbRrz5psT3T7FQgulXjvukHpusXnq2rt3u3pLVl999fTkk09O9PNevXrlIGTAgAFpySWXTMsuu2zaaqut0gwzzFDK8x5yyCHpzDPPrPc+Z5xxRjr00ENLeT7aFxUuAAAAHdi4b75J3xxzXBqy9KD0zZF/rDNsCfHzuD3f75jj8uPau1GjRqXPPvssvfrqq+mqq65K++23X5ptttnSDjvskL788svJ2nZs9+yzz87XY3uffPJJGjduXBo/fny69NJLa57/hBNOyNc32GCD9P7776exY8fm+9x7772pMzvuuONypc90002XOiqBCwAAQAf18wcfpC832CiNvOyyNH7UqEY9Ju4X9/9yw43Tzx9+mNqTGWecMYcZxeXHH39Mn3/+eXrmmWfS6aefngYOHJjGjBmTrrvuurTYYoulwYMHV93We++9l7dRhCq1PfXUUzk8CbHtWWedNQcIlWL73333Xb5+4oknprnnnjsvKaJz8E4DAAB01LBl082bHJrkx2+yWf7aXk055ZQ5hFlxxRXzsp633nornXbaaalbt265wmXjjTfOlSlNrXAJ3bt3TzPPPHO99wmzzz57E18F7ZXABQAAoIOJ5UBDd9gpjRs6dPK2M3RoGrrjzh1ieVGICpTDDjusZplPVL8cffTRTdrWTz/9lL9GeNPQfYpghs5F4AIAANDBjDjr7NKWA0WFS2yvI/nDH/6Ql/eEa6+9doJKlIamFK2wwgr550cccUT+PpYtFdOJal923XXXmsfFhKLK276pI8T64osvcgA0aNCg1K9fv9SjR4+8VGmLLbZIDz30UL2vqXfv3nm7J510Uv4+llFFg+CorImwZ9NNN53g/tFv5oYbbkibbLJJfo54rtjH5ZdfPp166qk1S6GqNQuO54p+OCHue/zxx6eFFlooTT311Kl///5po402Sk8//fREj33wwQfzY+P+4dtvv53ouHWUvi4CFwAAgA42jWjUjTeWus1RN92Ut9tRRB+V3XbbLV//+eef02OPPdbau5RuvvnmNO+88+bA5MUXX0zDhw/PFTIRBt1+++1p3XXXTTvvvHPe34ZcdNFFadVVV0233nprXjJV9JopDBkyJC+z2m677dLdd9+dnyOeK0Kg559/PodJiy66aHr99dcbfK6oElp55ZVzE9xYsvXDDz+kr7/+OjcFjn246aabUmclcAEAAOhAYvRzYxvkNtb4GCl9+x2pI4mQoFBXJUY1//rXv3Iz3VNOOSV/H5UhlY16Ky9XXHFFzeMiQKm8rbKKI0KPbbbZJk81WmmlldI999yTQ4sIQSLE+N3vfpcrP66++up0+OGH17t/EdbE/Xfcccc8nSkqcOL57rzzzppqlDXWWCMHKzEy+89//nNuEBzPNXTo0FzxM8sss6SPPvoorb/++mnYsGFVnyuqZLbffvvciPiOO+7Igc3o0aPz/s8yyyz59r322iu/lkIER7E/xx57bP4+9qH2caur+qc9ErgAAAB0IKOuubZdbbe1xMSiQl1LilpKhCxRbRNBQyzvielHG264YV5SNMUUU6QFFlggnXvuuTUBzznnnJM+qKeRcQQrv/3tb3PYs/jii+fGwZWOOeaY9Pbbb6c+ffrkZUexPCgqa+K5pp9++hygRAAVgdDHH3+czjjjjKrPFZUyH374Yd5OLFmK8CSWFMX+33zzzTVLhjprlYvABQAAoIMYO2x4GvPmm82y7TFvvJG331FUVpjUV8XR3KJqJSpAos/KhRdeWLUJ78EHH5xmmGGGvDyoCDOq9XIp+rjUNnLkyHTxxRfn6zG1aeGFF67zfnPNNVfaZ5998vXo81Kfk08+Ofd+qauCaOD/H2pNSgVRRyJwAQAA6CDGffVl825/6Fepo4jlLoVYrtNaHn744fx12WWXrTpeOkQgE/cplg1Vs+aaa+bQpS4RfMSSnxAjsesTS5tCVLBUC6SiF84GG2xQdRuLLbZY/hqVMp2RuVQAAAAdxLhRo5t3+yPL7Q3TmmKpSyGW77SW6NFS9IYpRkfH8qJCcb3yZ9FrpZpYgtTQc4Wll1666nNUPlfxfHUdo/jZNNNMU/X5pp122prKms5I4AIAANBBdO3Vs3m337tX6iiij0khGry2lqJBbIQctacJVRMNbqupLwCpbEbb2Oeq7/miYXB9uvz/lUOV1USdiSVFAAAAHUTXATM07/b7D0gdRTR6rb18pjUUAckWW2xRddpR7cs///nPqturb3lUZRjz1VdfNfr5YkQ0k07gAgAA0EF069c3TbHQQs2y7SkWXjhvvyOIiotiZHMs41lrrbVabV9iQlB46aWXWuy5Wur5OjuBCwAAQAfSa8cd2tV2W8Opp55aM1p5hx12qLdZbXP71a9+lb/G/jz55JPN+lyrr756zTKgInBqLVNMMcUkL21qbwQuAAAAHUjPLTZPXXqV22ulS+/eqefmm6X2LpbH/PnPf07HHHNM/n6mmWZKJ554Yqvu02677VbTkPY3v/lN+uKLL5rtuaKJbTxHuOmmm9L111+fWkv//v1rGuqOGDEidUQCFwAAgA6ka+/eqdc225S6zV6//nXebnszZsyY3KskJgBF0LLQQgulww47LFdVzDDDDOnuu+9Os802W6vuY58+fdJVV12VRyy/++67aamllkrnnntueu+993Kz2ggj4uePP/54DooGDRo0WcuB/vSnP6VFFlkkh09R3ROBT/SEieeJ5/vkk0/y2OlLL700bb755umggw5KzWHQoEE1148//vianjIdiSlFAAAAHUyfgw5MPzz2WPr5/182Mzm6zz133l57ENUh9TWNLZaybL311umss87KoUtbsOGGG6a77ror7bTTTmnIkCHpgAMOyJdqJmfqTzTOfeyxx9K2226bv8bSovqWF+2+++6pOSyzzDJptdVWy8uo4r2IS2UlTuVEpfZK4AIAANDBdJ1uutT/mqvSl5tunsYNHdr07fTvn/pfe3XeXnvUs2fPXEESwcqSSy6ZlltuubTVVlu1maCldugSfVyisuT+++9Pr7/+eho+fHjq3bt3mnHGGdPss8+ee7Csu+66uQpmcsTrf/TRR9NDDz2Urr322vTss8+mzz//vKbyJ5ZaLb300vm51lxzzdRc7r333txP55577kn//e9/0+jRoztUlUuX8R3p1QDQoPgPd7FOeNiwYalv344xbQAAmFhUuAzdcecmVbpEZUuELd3nmsuhhSbQwwUAAKCDitBkhnvvTr133z03vm2MuF/cPx4nbIGmU+EC0MmocAGAzmncyJFp9O13pFHXXJvGvPHGRLdPsfDCefRzTCNqjw1yoa0RuAB0MgIXAGDssOFp3NCv0riRo1LX3r1S1/4DUrd+lhlDmTTNBQAA6GQiXBGwQPPSwwUAAACgZAIXAAAAgJIJXAAAAABKJnABAAAAKJnABQAAAKBkAhcAAACAkglcAAAAAEomcAEAAAAomcAFAAAAoGQCFwAAAICSCVwAAAAASiZwAQAAACiZwAUAAACgZAIXAAAAgJIJXAAAAABKJnABAAAAKJnABQAAAKBkAhcAAACAkglcAAAAAEomcAEAAAAomcAFAAAAoGQCFwAAAICSCVwAAAAASiZwAQAAACiZwAUAAACgZAIXAAAAgJIJXAAAAABKJnABAAAAKJnABQAAAKBkAhcAAACAkglcAAAAAEomcAEAAAAomcAFAAAAoGQCFwAAAICSCVwAAAAASiZwAQAAACiZwAUAAACgZAIXAAAAgJIJXAAAAABKJnABAAAAKJnABQAAAKBkAhcAAACAkglcAAAAAEomcAEAAAAomcAFAAAAoGQCFwAAAICSCVwAAAAASiZwAQAAACiZwAUAAACgZAIXAAAAgJIJXAAAAABKJnABAAAAKJnABQAAAKBkAhcAAACAkglcAAAAAEomcAEAAAAomcAFAAAAoGQCFwAAAICSCVwAAAAASiZwAQAAACiZwAUAAACgZAIXAAAAgJIJXAAAAABKJnABAAAAKJnABQAAAKBkAhcAAACAkglcAAAAAEomcAEAAAAomcAFAAAAoGQCFwAAAICSCVwAAAAASiZwAQAAACiZwAUAAACgZAIXAAAAgJIJXAAAAABKJnABAAAAKJnABQAAAKBkAhcAAACAkglcAAAAAEomcAEAAAAomcAFAAAAoGQCFwAAAICSCVwAAAAASiZwAQAAACiZwAUAAACgZAIXAAAAgJIJXAAAAABKJnABAAAAKJnABQAAAKBkAhcAAACAkglcAAAAAEomcAEAAAAomcAFAAAAoGQCFwAAAICSCVwAAAAASiZwAQAAACiZwAUAAACgZAIXAAAAgJIJXAAAAABKJnABAAAAKJnABQAAAKBkAhcAAACAkglcAAAAAEomcAEAAAAomcAFAAAAoGQCFwAAAICSCVwAAAAASiZwAQAAACiZwAUAAACgZAIXAAAAgJIJXAAAAABKJnABAAAAKJnABQAAAKBkAhcAAACAkglcAAAAAEomcAEAAAAomcAFAAAAoGQCFwAAAICSCVwAAAAASiZwAQAAACiZwAUAAACgZAIXAAAAgJIJXAAAAABKJnABAAAAKJnABQAAAKBkAhcAAACAkglcAAAAAErWvewNAgDNb/zYsWncV19Vvb3rgAGpS7du3goAv1uBViJwAYB2KMKWIcssW/X2mV8cnLrNNFOL7hNAe+d3K1AmS4oAAAAASiZwAQAAACiZwAUAAACgZAIXAAAAgJIJXAAAAABKJnABAAAAKJnABQAAAKBkAhcAAACAkglcAAAAAEomcAEAAAAomcAFAAAAoGQCFwAAAICSCVwAAAAASiZwAQAAACiZwAUAAACgZAIXAAAAgJIJXAAAAABKJnABAAAAKFn3sjcIAACVxg4bnsZ99WUaN2p06tqrZ+o6YIbUrV9fBwmADk3gAq3o3HPPTQcddFDq3r17+uGHH7wXAHQY40aOTKNvuz2NuubaNObNNye6fYqFFkq9dtwh9dxi89S1d+9W2UcAaE6WFNEmnHXWWTl0qH2ZcsopU79+/dJiiy2Wdt999/TUU0+ljmTcuHFp7Nix6eeff04d3ahRo+p8j6tdHnvssdbeZQCaYNw336RvjjkuDVl6UPrmyD/WGbaE+Hncnu93zHH5cQDQkQhcaFPBQ+3LmDFj0vDhw9Prr7+eLr/88rTaaqul3XbbLd9G+zJ+/Pg63+Nql/hMdEZrrbVWDpy22GKL1t4VgEn28wcfpC832CiNvOyyNH7UqEY9Ju4X9/9yw43Tzx9+6KgD0GEIXGhz/vWvf+WgJS6xzObdd99Nl156aZp11lnz7VdccUU65ZRTWns3mQwRmhXvcbVLBA+dUWXoBNDuwpZNN29yaJIfv8lm+SsAdAQCF9qcbt261Swr6dGjR5pvvvnycqKHH344fx/+8pe/dNoKiI6gS5cuDS4pivsA0D7EcqChO+yUxg0dOnnbGTo0Dd1xZ8uLAOgQBC60GwsvvHBaddVV8/Vhw4ald955p7V3CQBIKY046+zSlgNFhUtsDwDaO4EL7cpcc81Vcz16u9Tlgw8+SOeff37aZJNN0qKLLpqb7vbp0ycNHDgw7bLLLnnJUn2efPLJmiqLV199Nf/s5ptvzv1j+vfvn/r27ZtWXnnl3FMm+pLUZ/To0enkk09OSy65ZN6HWWaZJW2wwQbp0UcfbfRrjue44YYb0kYbbZSXVfXs2TPNPPPMae21105/+9vf8vKbxr6W2Fbs90orrZSmn376vL3NN988/fvf/57gcf/73//Sb3/727TAAguk3r17p3nnnTcddthhacSIEak1xf7feuutadNNN02zzTZbPhYzzTRTWmONNdJf//rX9OOPP1Z97IsvvlhzLJ5++uma9zWOY7wvU0wxRZ4aVbvR79lnn53WXHPNfMzj+eK+8V7cdNNNDb7/UZX161//Os0zzzypV69e+bO4yCKLpA033DBdcsklOTgs/PGPf8z7Fu9ZuPvuuyeq+tHXBWir04hG3XhjqdscddNNebsA0J4ZC0278mHFX8/ixLcucXJbl++++y73g7nqqqvyye1JJ51Ub3PXEMuW9txzz3xyXOmZZ57Jlzhxv+yyy+rczqeffppP1CsrcWIfhgwZkh544IH05z//OS+fqk+ckEe48I9//GOCn3///ffp888/z8FNBA33339/mn322et9LfF12223zUFBpTvuuCM9+OCDeVsrrrhievbZZ3MoVBlovf/++3l/H3nkkbwvER60tAh7ttxyy/T3v/99omPxxRdfpCeeeCKdd955+VhEQNTQ+7rrrrumK6+8coL7VC5Ti2AuAo7PPvtsoue799578yV6C9122205TKtt//33z/tTO4CL4/rGG2+k++67L4cq99xzT76tdt+Wyv0t6OvCBJ/psfUvqxz7xRcOGC1i1C23NrpBbmONHzkyjbzyqtRrSw3EaVkN/e5s6HcvQCWBC+3GW2+9VRM8xAl1XQFDmH/++fOJ8i9/+ctcBRGVCd9880167bXX0oknnpiee+65XHUSo6aj+qA+Ud0QJ9SnnXZa2nrrrdMMM8yQ3n777fT73/8+VyJEtUgEIlHxUCnGPMfPImyJUOXQQw/NfWhiX/773//mMdhRMRLVJdXEyXVl2LLPPvvkqpO55547hzkR9Jxxxhl5gtM666yTKziiAqOauG8EKxHQxPNGSBBjtiNQ+uSTT9KOO+6YA6SNN944Lb744vlYRWVOBB3RM+fMM89ML7/8cj4WJ5xwQmpJET7E8S/ClghLDjzwwPw5iLAlgpNTTz01H+9432M/p5122qrbiwqoO++8Mx1//PFp++23z5+lrl271gRgcUyjaW8EJNFD6Oijj87fR4VKBDDXXXddDuwigNphhx1ycFIpjnMRtmy22WbpoIMOyhVW8f7EexdVWPH80RS68Kc//SlvM54n3pd4H+KzVyn2EQrjhn5V78H4cv0NHSzatRGnnJov0OZ+985a9x/9AGrrMr6hmnhoAREGRCgRBg8enAYNGpSvx8czTlAff/zxdNRRR6WPPvooN1ONKo2tttpqkp8nKhjiRDaqC2K5Ue2lNCEqJWKJSnGCG5Ufq6+++kRLTSLYiWqV9ddfP2+vUiz12XvvvfP1CDgiKKntd7/7Xb4txIl+hDSVIsyJkCYce+yx6bjjjqszONhvv/3y9bg97lfttcRzxIl8LCeqdp9YQhRLdCLYiCU2lWIZTLzOqCyK92RSjRw5Mk0zzTT5eryH9YUHsbRn3333rfk+lv4U4djBBx+cPy+1ReVSLBkLhxxySK7IqfTCCy+kZZddtub7WJpUbYnOMsssk1566aW0xBJL5GNWVwXL7bffXvP4OF6xNKmw1157pYsvvjiHLG+++eYkBSXxWYswL5bERSjTVNWW3IUIIItKsKiiimVytD8/vfqqUAWghc1w/71pyiWWcNyBRvHnUtqcFVZYYYK+FVF9sNNOO+WwJSpWrr/++iaFLSFOfKNaoahiiG3WJ07ya4ctIZbUxPKcEEuLaouwpGj0WxkcVIrR1nWdyBfihD3Ea46wqS6x7QgFipCnPrG/tcOWEK+vWJ4V1TtRfVM7bAnbbbdd/hoVHpVLu5qiWC5T7VJ7AlVxLKKHTrWlYDvvvHPN64ulPvUtv4nmy9XClgigImwpgp9q71FUCcVnNcRnsna4FKJHTmtVpUQ1TrVLtWV3AABAeQQutDnVTryjKiKqObbZZpvJ2n6EIIUIXeoT1TDVxJKkolqgsplsLEOJ5T3FcpJq442jGe2vfvWrOm+r3EYsK4rgqS6x7aLyI6ptokdNNVGhUk1UtoSobll66aXrvM+CCy5Yc72hoKohu+22W272W+1SWREUlT9FqBWvYaqppqq63eKzUSwhqyaqR+prdBumm266mqlY1RQBT1TP1HWsolLlwgsvrLexMQAA0DEJXGhzollpceIdyyL++c9/5n4oURXxhz/8ITe8bUg0pY2KhwhF4i/6U045ZU3FTOXyicopMXWJfinVVPYIKSoaijCiqK5YaKGFGh3+VPr4449rlhjFVJv6VN5eX+VJ5YSn2oqlPo25T+3X2xQRFNWewFN5qQypokdLNKot81gUAVNdYglQ+Pbbb3O4U1x69OiRL/FZiktUAUWPnzB06NAJthFLimIKVASGUYUUvX+ioiZ64USQVruCpznEZ7vaJZogAwAAzUvTXNqc6DVSVHRElUGMYL7rrrty09TouxFLcaJJbIxprqsyJJYbxaSaxqhsWlqXOMGupjIUqDyBrgwjooqlPtVuj2lGdQUddalc8lLf2ObGvJamvN7m1hzHor6lXFEdEyLgq2/MdKWffvppgu8jYIneP1GRFYFhbDN6vsQlxBKu6OET/WjqWr5VBn1ZAACgdalwoV2Ik/1oEBsn3HEiHCeqdYn+LEXYEn1fotIlKh3ipD1OiqNqpjihbi6VIUo0161PtUqRSakmqby9oUCiPWqOY1FtmVfl+xfVR/Ute6q8RBVObdFbJyZMRV+caI4cS7+ip0vRB+eII47I47f1LQcAgI5JhQvtRlQNRG+PGP8byzJiFG/tHisxHrjoERJjk+vy5ZdfNut+RpPfqNKJZUUxyro+1W6PRrnFNt544416t/Gf//yn5np9S4La8/s+9dRT52VFLXEsYtR0eO+993IFVENVSg2JSUVxKfrSxMjqGGkd049iulGMkF5vvfUm6znonLr2H9DgJI1uM87YYvtD5zXqllvTiFNPK327fY74Q+q1Zd0NzqG5jP3ii3onwDX0uxegksCFdiVOVKMPRiz1OO200yYIXKKKpejJssoqq1TdRu0RzmWLCUZLLrlkDoViKdQJJ5xQ5/0iQHjooYeqbiNGEz///PN5GzE5KAKYusQyq6LhbZzYdzSx5GbFFVdMjz32WLr33ntzpVL0UKnvWER/nWJ606SKRsbnnHNOfp4bbrgh/eY3v0llWmqppfJUowjVwquvvjpB4FIsMapvyhKELt3qL1KNsKXbTDM5WDS73rvukr47769pfANVnZOiS+/eqfcuO6eukxl6Q0v/7gWo5DcG7cqMM86YlwqFmFwT/TEKPXv2rDlZHTx4cJ2P/+CDD6qOFS5TVNiEmJRTjIiu7dhjj613eVNxov+///0vnX766XXe54orrqiZkFN2MNCWFK8tqpOOP/74Ou9zyy235JHOxfGvFlA1JnBZdNFF8/Vo0txQlVJTVC59ij5FlaLZbrHsCKA9iFCk12ROEKyt169/LWwBoN0TuNDuHHLIIalr1//76MbyokKcYK+77rr5+kUXXZSOO+64PO0nKgWix8Yll1ySVlhhhbT22ms3+z7uscceNWOj995773TiiSemTz/9NDebjaUqsbzkjDPOqHc88S677JL3N8RkpuhbE9NlYhuxraic2XPPPfPt888/fzrssMNSRxUNk9dcc818/U9/+lNuRhsjsOO9/fzzz3O104477lizpCt6+TRVfLauueaaXGUUFVPLL798Ovnkk3PwEv1aoroqJlE999xzufIoPk8R9lTafPPNc+hz880352VOX3/9dX7f4msshYtx4UVIGBO4Kg0aNCh/feWVV/J2G2rsDNAW9DnowNS9nsl+kyK2E9sDgPZO4EK7E8tmiqVE0SD39ddfr7ktlhtFFUw0Io1KiDnmmCNPPIrlNhFOxGPPPffcZt/HWPISJ9YxVjpO0o855piaviwRjlxwwQU5MFl99dWrbiP2O7ax3HLL5dcTJ/fRXyS2EduKCpkYHR2vKfqATG6vkbYsQpBYLrTqqqvm76OBcrzuOEYzzzxzrkSJICT6tjz88MOTPaEnloTFEqb4/MS0o6OOOiqP+I73NUZEzznnnDkMixAsphHVnmYU1SlRfRSNcqNapn///vl9i68RssXo6ehLE8FO0Ui3EMFRMVI6gqa4XzEuO0ZLA7RFXaebLvW/5qrUtX//ydtO//6p/7VX5+0BQHsncKFdKqo5IoioXG4TgUQ0JY0KkjgpjpPcmFaz9NJLp7PPPjufRNc3ErhMcfIf/TmiOiXCgVjuFMtHImSJICVO4hsyYMCAvHQqGgCvtdZaqV+/fnnCTvQoiXHZETDFc8wzzzypo4sQ5fHHH88hRYwFj1Aigph4PyP8iM9BVJMsuOCCpTxfBF0xYSiqpaJyKpr3RugRAUi8tyuttFL+HEbgEsFIpTvuuCM3cN52221z4FK8b0V/n0MPPTRXzEQlTG0RGD777LN56VwRGEYlT3EBaKuiMmWGO29vcqVLfvxdd6TuHbABPACdU5fxZpLSBsTHsDiZjBPMxoj7x+PiRHZS+3VEZUiIx9UeEdzYfWnKPlfbRlNew6Rsv6F9jGqKuDS0H/Udt8YoHh9BSbEsrCUVz9/U96u1FJ/1so7b8OHDcwgUYtnU5FYE0TrGfv55GrLMslVvn/nFwZrm0irGffNNGnHW2WnUTTel8RU9q+prkBs9W2IZkcoWWpvfrUCZ2tdZBx1WnLxP6knw5AQU9T1XY/elKfvcHNsoY/uNPZGf3H1t7aCjtZ+/qZojjANoLhGaTHfCcanPYYek0bffkUZdc20a88YbE91vioUXTr123CH13HwzDXIB6JDa59kHAABtfnpR7512zJexw4ancUO/SuNGjkpde/dKXfsPSN36qa4DoGMTuAAA0KwiXBGwANDZaJoLAAAAUDKBCwAAAEDJBC4AAAAAJRO4AAAAAJRM4AIAAABQMoELAAAAQMkELgAAAAAlE7gAAAAAlEzgAgAAAFAygQsAAABAyQQuAAAAACUTuAAAAACUTOACAAAAUDKBCwAAAEDJBC4AAAAAJRO4AAAAAJRM4AIAAABQsi7jx48fX/ZGAWi7hg8fnvr165evDxs2LPXt27e1d4kmGD92bBr31VdVb+86YEDq0q2bYwvgdyvQSrq31hMDAE0XYUq3mWZyCAFK5HcrUCZLigAAAABKJnABAAAAKJnABQAAAKBkAhcAAACAkglcAAAAAEomcAEAAAAomcAFAAAAoGQCFwAAAICSCVwAAAAASiZwAQAAACiZwAUAAACgZAIXAAAAgJIJXAAAAABKJnABAAAAKJnABQAAAKBkAhcAAACAkglcAAAAAEomcAEAAAAomcAFAAAAoGQCFwAAAICSCVwAAAAASiZwAQAAACiZwAUAAACgZAIXAAAAgJIJXAAAAABKJnABAAAAKJnABQAAAKBkAhcAAACAkglcAAAAAEomcAEAAAAomcAFAAAAoGQCFwAAAICSCVwAAAAASiZwAQAAACiZwAUAAACgZAIXAAAAgJIJXAAAAABKJnABAAAAKJnABQAAAKBkAhcAAACAkglcAAAAAEomcAEAAAAomcAFAAAAoGQCFwAAAICSCVwAAAAASiZwAQAAACiZwAUAAACgZAIXAAAAgJIJXAAAAABKJnABAAAAKJnABQAAAKBkAhcAAACAkglcAAAAAEomcAEAAAAomcAFAAAAoGQCFwAAAICSCVwAAAAASiZwAQAAACiZwAUAAACgZAIXAAAAgJIJXAAAAABKJnABAAAAKJnABQAAAKBkAhcAAACAkglcAAAAAEomcAEAAAAomcAFAAAAoGQCFwAAAICSCVwAAAAASiZwAQAAACiZwAUAAACgZAIXAAAAgJIJXAAAAABKJnABAAAAKJnABQAAAKBkAhcAAACAkglcAAAAAEomcAEAAAAomcAFAAAAoGQCFwAAAICSCVwAAAAASiZwAQAAACiZwAUAAACgZAIXAAAAgJIJXAAAAABKJnABAAAAKJnABQAAAKBkAhcAAACAkglcAAAAAEomcAEAAAAomcAFAAAAoGQCFwAAAICSCVwAAAAASiZwAQAAACiZwAUAAACgZAIXAAAAgJIJXAAAAABKJnABAAAAKJnABQAAAKBkAhcAAACAkglcAAAAAErWvewNAtC2jRs3rub6N99806r7AgCd1bTTTpu6dvX3b+jIBC4AncyIESNqrs8zzzytui8A0FkNGzYs9e3bt7V3A2hGIlUAAACAknUZP378+LI3CkDb9fPPP6ePP/44X+/Tp0+7KWeO5U9FRc7777+fpptuutbeJToIny18tmgNlhRBx2dJEUAn07179zT33HOn9izCFmXY+GzRnvi9BdD5tI8/awIAAAC0IwIXAAAAgJIJXAAAAABKJnABAAAAKJnABQAAAKBkAhcAAACAknUZP378+LI3CgAAANCZqXABAAAAKJnABQAAAKBkAhcAAACAkglcAAAAAEomcAEAAAAomcAFAAAAoGQCFwAAAICSCVwAAAAASiZwAQAAACiZwAWANmWXXXZJ0003Xc2lMT788MN0+OGHp6WXXjrNPPPMaf7550+bbrppuu2225p9f2kfxo8fn9Zee+2az9Xiiy9e9b7Dhg2b4DNY3+Waa65p0ddB63nllVca/bl48sknG9zeM888k3/fLbLIImnGGWdMiy66aNpjjz3S4MGDW+T1AND8urfAcwBAo9x9993pqquumqSjFaFKnLSMHDlygp+/99576a677kobbbRRuvnmm9NUU03lXejEzjvvvPToo4/WfD9ixIiq9x03blz69ttvG7XdH3/8sZT9o+37+eefG/25GDNmTL23/+EPf0inn356DgILX375ZfrPf/6TrrjiinTcccelo48+erL3GYDWpcIFgDbhm2++SXvvvXe+PttsszXqMc8++2zabrvtctgycODAdOedd6ZPP/00vfbaa2mvvfbK97nnnnvSbrvt1qz7Ttv2/vvvpyOPPDJ17949VxJMivPPPz8NHz686mWnnXZqtv2m7YrfK/V9LlZfffWqjz3rrLPSaaedlsOWddddNz399NNpyJAhuSomHheB3zHHHJMuvvjiFn1NAJRPhQsAbcKBBx6YTzq22WabfCJy00031Xv/uM/++++ffvrppzRgwID0j3/8I80wwwz5tllmmSVddNFFqWfPnukvf/lLuuGGG9Kee+5Z70kQHVN8TmKZxqhRo3JVweOPP56++OKLRj8+PkONXdpG59G7d+8mfS4+//zzHKaENddcM917772pW7du+fuZZpopPfzww+kXv/hFeu655/Lndauttkp9+/Ytff8BaBkqXABodQ8++GBeShQnFmeffXajHhN/FX7hhRfy9TgxKcKWSieccEI+MQqN3S4dy9/+9rccssw777w1J7rQWi699NIc/oVYUlSELYUpppgiV7+EqJSZ1CWWALQtAhcAWlX00ojqk+IEpLFLPu64446a61EVU5cIW6KHS4i/HI8ePbqUfaZ9+Pjjj9Nhhx2Wr0fF09RTT93au0QnV/zeiiWQyyyzTJ33WW211XLz7xDLJAFovwQuALSqQw89NJ8Yr7rqqmn33Xdv9OOef/75/HXOOefMS4iqWWmllfLX77//Pr3++usl7DHtxW9+85v03XffpR133DFPKILWFMsfX3311Xx9xRVXrPe+xe+tqOKrbKwLQPsicAGg1Tz22GPpkksuSVNOOWVe+tGlS5dGP/bNN9/MX+ebb7567zfPPPNM9Bg6vssvvzw99NBDafrpp89NSpsqPpdLLLFErryKcC/6axx11FF5FDmd1/HHH58WXnjhvJRx7rnnzoHen/70pzxpqJp33nknjR07dpJ+b8Xyo48++qjkvQegpQhcAGgVcSIRzUzjr7dHHHFEWnDBBRv92JjiMWzYsHy9oSVI0Yiy8NVXX03GHtNefPbZZ+nggw/O188444zUv3//Jm/rX//6V556FSfSceL7z3/+M5188slp/vnnz1/pnJ544okc4MbvlAjfYuT4H//4xxy+RNhXl8rfP35vAXQOphQB0Cqi0e0HH3yQg5YY2TspYgx0UWbfUF+OyttjeQkdX4wXjzHja6yxRtpll12atI1FFlkkbbvttmn55ZdPc8wxR55I88knn6T7778/V8xEQ9OodBkzZkw67rjjSn8NtD1RgbfCCivkyUFLL710/lz06tUr/x6LXivnnntu7hMVSyO7du060Wev8veP31sAnYPABYAWFyOczz///HwCE0s2YklRUzW0DKnydr0QOr7rrrsu3XPPPWmqqabKn62miIqYuvr9xPKRONHeaaedcs+h//3vf+mkk07KTZsnpUKL9ine+2effXain0e1SgQx8TmIkC/CvhhzHw27Y0lbXfzeAugcLCkCoEVF89r4C3CEH/E1TlwnVfxVufDDDz80+HyFYkQ0HVMs+znggAPy9ag+iWU/zSEqGy644IJ8PXpyXH311c3yPLQtDYUkSy65ZM0ys2+//TbddtttE9zu9xZA5yNwAaBFRdn9u+++m6sFYgx0U3Tr1i1NO+20jerLUnl7tb820zEce+yx6euvv87LgYpx0M1l3XXXTX369MnXBw8e3KzPRfux9dZb11yv/bmo/P3j9xZA52BJEQAtqjjRiB4Y0WCyLtEHoRC9M8JSSy2VHn/88ZqfxxKO5557Lr3//vv1Pl/0V6h8DB3/s/Xee++lAQMGVO3/E6IBbvHZ2mSTTdJVV101Sc8VPTqiIfOIESNyyAPFcrRYIhkjoGt/LgYOHJirZKK6r7G/t3r06JHmmmsuBxegnRK4ANAqotlolN03pLhP7Ya30U8hApc4uY4Tm2rVK3Gf0L1797TYYouVsu+0bT/++GO+1CdOeovPVkzMaoqhQ4fmr0W1FUQAF2FLXZ+Lnj175tA3phsVv5eqKW6PkeRR0QdA+2RJEQAtKpqMRnVLfZfNN9+85v7Fz2IMa6WoSihOnG+//fY6nytOfKKBaohmlsUSEDqm6KXS0Gdr0KBB+b6zzz57zc+a0oPlmWeeqRlNHifFEO69996aA1HX56L4vRWjxt955506D9pLL71UU+FS3B+A9kngAkCLiukxsZSjvssUU0xRc//iZ7Ub3q611lq5RD+ccsopdVYpnH322TVVCPvuu2+zvzZaV1QQNPTZKqoFYklQ8bN43KSIaqvf/va3Nd9vt912pb8W2p/PPvssj7svlgJtscUWE93nN7/5Tc3vt2jsXJfi5zE6uqljzQFoGwQuALRLsUTorLPOyj0R4q/B66yzTnr11VdryvpPO+20dOSRR9aEM5tuumkr7zHtxa9+9avcgPdf//pXGjJkSJ5EFKIa5oYbbsjL2V555ZWaE+jllluulfeY5hZL1FZaaaV06qmn5gqUmIg1bty4fNsXX3yRLr744rTMMsukjz/+OP/smGOOyVVUtc0zzzzp97//fb5+yy23pD333DMHNUVfoR122CE98MAD+fsjjjgizTLLLN5cgHasy/ioxQaANmSbbbZJN910U77e0H+mYurRQQcdVHNSHH9ZruzfESfHjzzySOrbt28z7zXtwQorrJD7Y8w555zpww8/rPM+0Qw3TqILUQ0TlVmVzZzD3nvvnc4777wc/tGxxfj5qDipFO97VKtUjp6PCqoIW+JSTfyu2n777Wt+x9X1e2u33XZLl156aYOjqAFo21S4ANCu7b///unpp59OW221VQ5V4qQlToIWX3zxdMYZZ+QqBWELkyICuqiQisqo2WabLZ9ER9gSJ9gLLLBArmqJkb8XXnihsKWTiMAtfpccd9xxaZVVVkkzzzxzDoMjbImpRPH75sADD0yvv/56vWFLiM/TjTfemK6//vq02mqr5SVt8Xsrvq655prp1ltvTZdddpmwBaADUOECQJsTJ7fFpI9idO+k/CU6/lrsL8NUGwv9888/56qVxjZRjhPr+Ez26tXLQWWCSpUiKJlcEdzUrqABoP0TuAAAAACUzJIiAAAAgJIJXAAAgP+vvXsLDfGN4wD+jNksiuQUJSuHUA6bsxvLIURC0i6c4sIpxIXhRrlarSSKC2Myolxy4UwODaUcStmFUDMX1JjZwvbvfWtz2mbau7/h86n1vtv7vO/79F6tb7/n9wCQMIELAAAAQMIELgAAAAAJE7gAAAAAJEzgAgAAAJAwgQsAAABAwgQuAAAAAAkTuAAAAAAIXAAAAADaNxUuAAAAAAkTuAAAAAAkTOACAAAAkDCBCwAAAEDCBC4AAAAACUtN+oEAAP+Kffv2hfv377d4/PDhw8OWLVvadE4AQPuQUldXV/e7JwEA8CeaO3duOHv2bIvHT5s2LVy8eLFN5wQAtA8qXAAAWik9PT3s37//p+P69+/vWwPAP0LgAgDQ2n+oUlPD6tWrfUcAoIGmuQAAAAAJU+ECAPAbbd26NVRUVIQ5c+aEhQsXhqi93uXLl8PNmzdDWVlZGDJkSNxo99atW+Hw4cMNzXozMjLC69evw+nTp0NpaWn8jGjcsGHDGp5dW1sbrl+/Hv+Ul5fHS58GDhwYZs2aFQYPHtzsvNauXRs+fvwYFi1aFGbPnh0/6/z586GkpCS8fPkyjBkzJqxZs6bNvw8A/KkELgAAv9Hx48fDq1evQs+ePcOECRPCggULwt27d79ptBsFKU+ePAmFhYXx3woKCsKxY8fCpk2bQnV1dcPYJUuWNAQud+7ciZc5PXz48Id3pqSkxGMPHjwYunXr1ui8jhw5EmpqasKgQYPC0KFDw/z588OjR48arkdBjMAFAJomcAEAaAei4GT69Olx9ci6deviLaSjipTGGu2ePHkyrkCZOHFimDdvXujVq1ccokT3RKJqmBkzZoSqqqqQlpYWcnNzQ3Z2dvz7mTNnwo0bN+JnPH78OK6k6dKlS5Pzevv2bcjJyYnv3bhxYxy+RM/MzMxs0+8BAH8620IDALRyW+ioae7y5ct/Oj4KSaLg42t9+/aNK1y6du0a+vXrF65cuRIfv1dUVBRWrlwZn0dj8/Lyws6dO38YF1WlRKHIs2fPQo8ePcKlS5fC6NGjvxmTn58f3x9Zv359ozssde7cOX5W9K6oyuXChQtxFQ4A0DIqXAAAWunTp08Ny32aE/VO+T5wqVdZWRmHKo2FLd/LyspqNGyJnDp1Kg5bInv27PkhbIls27YtDnbOnTsXDh06FHbt2tVkmPL+/ftQXFwsbAGAXyRwAQBopWjpT2NVIt8bO3Zsk9ei3iuTJk1q0ftWrVrV5LWo4ibSvXv3eClRUzZs2BAHLlEVS1QFE/V0aUy0bGnEiBEtmhcA8IXABQCglaIlRVGD2tZoLoz5lbEPHjyIj1ElTadOnZocN3ny5Ibz+/fvNxm4/Mq8AIAvOnx1DgDAbxI1vk1i7Js3b+Jjnz59mn1G1N+lPpCpv6e18wIAvhC4AAC0A81Vo/zK2I4dO8bHz58/N/uMurq6UFtb+809rZ0XAPCFwAUA4C/Su3fv+PjixYtmx5WVlTWEMvX3AADJEbgAAPxF6nuu3Lt3L1RUVDQ57vLlyw3n48aN+1/mBgD/EoELAMBfZPHixfGxuro67N27t8ltrAsKCuLzaDvonJyc/3WOAPAvELgAAPxFZs6cGaZMmRKf7969Oxw9evSb65WVlWHp0qUNuxnt2LEjZGRk/Ja5AsDfzLbQAACtVFNT06JtoaMGtAcOHGjT752SkhJOnDgRpk6dGp4+fRpWrFgR8vPzQ1ZWVvjw4UO4evVqw65Eubm5YfPmzW06HwD4VwlcAABaKVqiU1hY+NNx6enpbR64RAYMGBBKSkpCXl5eKC4uDo8fP45/6kVNcrdv3x42bdoUBzQAQPJS6qI9AQEA+GXnz58Pz58/b/H41NTUuOLka1E1SlVVVRg1alSzzWtLS0vDtWvX4vNly5aFtLS0Fr3z3bt34fbt26G8vDy+JzMzM2RnZ4cOHZpfWV5UVBQHSePHjw8jR45s0bsAgC8ELgAAAAAJ0zQXAAAAIGECFwAAAICECVwAAAAAEiZwAQAAAEiYwAUAAAAgYQIXAAAAgIQJXAAAAAASJnABAAAASJjABQAAACBhAhcAAACAhAlcAAAAABImcAEAAABImMAFAAAAIGECFwAAAICECVwAAAAAEiZwAQAAABC4AAAAALRvKlwAAAAAEiZwAQAAAEiYwAUAAAAgYQIXAAAAgIQJXAAAAAASJnABAAAASJjABQAAACAk6z8EdXAEbrAjTwAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 470, + "width": 558 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "error.plot()" + ] + }, + { + "cell_type": "markdown", + "id": "bdc28fae", + "metadata": { + "collapsed": false + }, + "source": [ + "In the figure, the histogram gradient boosting tree is statistically equivalent to the linear regression, whereas the random forest is marked as different. The colours of `Perf.plot` come from p-values that are not corrected for multiple comparisons unless its `correction` argument is given. The p-values of the differences with respect to the best regressor, adjusted with Holm's method, are obtained as before. With the correction, neither difference is significant at the 0.05 level." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "3316f95d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'Random Forest': np.float64(0.052),\n", + " 'Hist. Grad. Boost. Tree': np.float64(0.166)}" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "error.difference().p_value(correction='holm')" + ] + }, + { + "cell_type": "markdown", + "id": "f131510f", + "metadata": { + "collapsed": false + }, + "source": [ + "[Competition Organizers](competition_organizers.ipynb) extends this workflow to ranking many participants against a gold standard, and [Multiple Testing](multiple_testing.ipynb) shows how to combine several measures in a single `Perf` and correct their p-values." + ] + } + ], + "metadata": { + "kernelspec": { + "argv": [ + "python", + "-m", + "ipykernel_launcher", + "-f", + "{connection_file}" + ], + "display_name": "Python 3 (ipykernel)", + "env": null, + "interrupt_mode": "signal", + "kernel_protocol_version": "5.5", + "language": "python", + "metadata": { + "debugger": true, + "supported_encryption": [ + "curve" + ] + }, + "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.13.15" + }, + "name": "sklearn_users.ipynb" + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/quarto/references.bib b/quarto/references.bib new file mode 100644 index 0000000..5898793 --- /dev/null +++ b/quarto/references.bib @@ -0,0 +1,105 @@ +@article{Nava-Munoz2024, + author = {Nava-Mu{\~n}oz, Sergio and Graff, Mario and Escalante, Hugo Jair}, + title = {Analysis of systems' performance in natural language processing competitions}, + journal = {Pattern Recognition Letters}, + volume = {186}, + pages = {346--353}, + year = {2024}, + doi = {10.1016/j.patrec.2024.03.010}, + note = {Preprint: \url{https://arxiv.org/abs/2403.04693}} +} + +@inproceedings{Nava-Munoz2023, + author = {Nava-Mu{\~n}oz, Sergio and Graff Guerrero, Mario and Escalante, Hugo Jair}, + title = {Comparison of Classifiers in Challenge Scheme}, + booktitle = {Pattern Recognition}, + series = {Lecture Notes in Computer Science}, + volume = {13902}, + pages = {89--98}, + year = {2023}, + publisher = {Springer Nature Switzerland}, + doi = {10.1007/978-3-031-33783-3_9} +} + +@article{Dietterich1998, + author = {Dietterich, Thomas G.}, + title = {Approximate Statistical Tests for Comparing Supervised Classification Learning Algorithms}, + journal = {Neural Computation}, + volume = {10}, + number = {7}, + pages = {1895--1923}, + year = {1998}, + doi = {10.1162/089976698300017197} +} + +@article{Demsar2006, + author = {Dem{\v{s}}ar, Janez}, + title = {Statistical Comparisons of Classifiers over Multiple Data Sets}, + journal = {Journal of Machine Learning Research}, + volume = {7}, + number = {1}, + pages = {1--30}, + year = {2006}, + url = {http://jmlr.org/papers/v7/demsar06a.html} +} + +@inproceedings{Koehn2004, + author = {Koehn, Philipp}, + title = {Statistical Significance Tests for Machine Translation Evaluation}, + booktitle = {Proceedings of the 2004 Conference on Empirical Methods in Natural Language Processing}, + pages = {388--395}, + year = {2004}, + address = {Barcelona, Spain}, + publisher = {Association for Computational Linguistics}, + url = {https://aclanthology.org/W04-3250/} +} + +@inproceedings{Berg-Kirkpatrick2012, + author = {Berg-Kirkpatrick, Taylor and Burkett, David and Klein, Dan}, + title = {An Empirical Investigation of Statistical Significance in {NLP}}, + booktitle = {Proceedings of the 2012 Joint Conference on Empirical Methods in Natural Language Processing and Computational Natural Language Learning}, + pages = {995--1005}, + year = {2012}, + address = {Jeju Island, Korea}, + publisher = {Association for Computational Linguistics}, + url = {https://aclanthology.org/D12-1091/} +} + +@book{Chernick2011, + author = {Chernick, Michael R. and LaBudde, Robert A.}, + title = {An Introduction to Bootstrap Methods with Applications to {R}}, + publisher = {Wiley}, + year = {2011}, + isbn = {978-0-470-46704-6}, + url = {https://www.wiley.com/en-us/An+Introduction+to+Bootstrap+Methods+with+Applications+to+R-p-9780470467046} +} + +@book{Efron1994, + author = {Efron, Bradley and Tibshirani, R. J.}, + title = {An Introduction to the Bootstrap}, + publisher = {{Chapman and Hall/CRC}}, + year = {1994}, + doi = {10.1201/9780429246593} +} + +@article{Holm1979, + author = {Holm, Sture}, + title = {A Simple Sequentially Rejective Multiple Test Procedure}, + journal = {Scandinavian Journal of Statistics}, + volume = {6}, + number = {2}, + pages = {65--70}, + year = {1979}, + url = {https://www.jstor.org/stable/4615733} +} + +@article{Benjamini1995, + author = {Benjamini, Yoav and Hochberg, Yosef}, + title = {Controlling the False Discovery Rate: A Practical and Powerful Approach to Multiple Testing}, + journal = {Journal of the Royal Statistical Society: Series B (Methodological)}, + volume = {57}, + number = {1}, + pages = {289--300}, + year = {1995}, + doi = {10.1111/j.2517-6161.1995.tb02031.x} +} diff --git a/quarto/style.scss b/quarto/style.scss new file mode 100644 index 0000000..b6af14a --- /dev/null +++ b/quarto/style.scss @@ -0,0 +1,107 @@ +/*-- scss:defaults --*/ + +// A software/statistics look: sans-serif, teal accent, generous whitespace. +$font-family-base: "Inter", system-ui, -apple-system, "Segoe UI", Roboto, + sans-serif; +$headings-font-family: $font-family-base; +$font-family-monospace: "SFMono-Regular", Consolas, "Liberation Mono", Menlo, + monospace; + +$body-bg: #ffffff; +$body-color: #1c1f22; +$link-color: #0f766e; +$link-decoration: none; + +$grid-body-width: 820px; +$grid-sidebar-width: 260px; +$grid-margin-width: 260px; + +/*-- scss:rules --*/ + +h1.title { + font-weight: 700; +} + +.subtitle.lead { + color: #52565b; +} + +// Landing page. +.home-lead p { + font-size: 1.2em; + line-height: 1.55; + margin: 1.4rem 0 1.8rem; +} + +.pillars { + display: grid; + grid-template-columns: repeat(3, 1fr); + gap: 1rem; + margin: 1.8rem 0 2.2rem; + + .pillar { + border: 1px solid #e2e5e8; + border-top: 3px solid #0f766e; + background: #f7faf9; + border-radius: 4px; + padding: 1rem 1.1rem 1.2rem; + + h3 { + margin: 0 0 0.5rem; + font-size: 0.95rem; + font-weight: 700; + color: #0f766e; + } + + p { + margin: 0; + font-size: 0.9em; + line-height: 1.5; + color: #3c4045; + } + } +} + +.installs { + display: grid; + grid-template-columns: repeat(2, 1fr); + gap: 1rem; + margin: 1.2rem 0 2rem; + + .install { + border: 1px solid #e2e5e8; + border-radius: 4px; + padding: 1rem 1.1rem; + + h3 { + margin: 0 0 0.6rem; + font-size: 0.85rem; + font-weight: 700; + text-transform: uppercase; + letter-spacing: 0.04em; + color: #52565b; + } + + pre { + margin: 0; + background: #f7faf9; + border-radius: 4px; + } + } +} + +@media (max-width: 768px) { + .pillars, + .installs { + grid-template-columns: 1fr; + } +} + +.navbar { + border-bottom: 1px solid #e2e5e8; +} + +.page-footer { + font-size: 0.8rem; + color: #898f94; +} diff --git a/requirements.txt b/requirements.txt index 630cee2..f94f3b0 100644 --- a/requirements.txt +++ b/requirements.txt @@ -5,4 +5,6 @@ jupyter pyyaml sphinx pytest -statsmodels \ No newline at end of file +statsmodels +sphinxcontrib-mermaid +furo diff --git a/scripts/check_package_versions.py b/scripts/check_package_versions.py new file mode 100644 index 0000000..4d9d71f --- /dev/null +++ b/scripts/check_package_versions.py @@ -0,0 +1,102 @@ +#!/usr/bin/env python3 +"""Check the package's local version against PyPI. + +``publish-pypi.yml`` only checks, at the moment a tag is pushed, that the tag +matches ``CompStats.__version__``. Nothing checks *before* that whether the +local version is actually ahead of what PyPI has, or whether it jumped more +than one release past it. This script reports PyPI's latest version, the +local version (read from the attribute ``pyproject.toml`` declares as the +dynamic version, without importing the package, so none of its dependencies +need to be installed), and whether the local version is a valid single-step +jump ahead of PyPI: the next patch, or the next minor with patch reset to 0. +A package PyPI has never published always passes. + +Usage:: + + python scripts/check_package_versions.py +""" + +import ast +import json +import sys +import tomllib +import urllib.error +import urllib.request +from pathlib import Path + +from packaging.version import Version + +ROOT = Path(__file__).resolve().parents[1] + +#: Name of the distribution on PyPI. +PACKAGE = "CompStats" + + +def pypi_latest_version(package: str = PACKAGE): + """Return the latest version PyPI reports for `package`, or `None` if it + has never been published (a 404 from PyPI's JSON API).""" + url = f"https://pypi.org/pypi/{package}/json" + try: + with urllib.request.urlopen(url, timeout=10) as response: + return json.load(response)["info"]["version"] + except urllib.error.HTTPError as error: + if error.code == 404: + return None + raise + + +def local_version(package_dir: Path = ROOT) -> str: + """Return the version ``pyproject.toml`` resolves dynamically, read + straight out of the source file its ``attr`` points at (no import).""" + with open(package_dir / "pyproject.toml", "rb") as fpt: + pyproject = tomllib.load(fpt) + attr = pyproject["tool"]["setuptools"]["dynamic"]["version"]["attr"] + module_name, attr_name = attr.rsplit(".", 1) + module_path = package_dir / module_name.replace(".", "/") / "__init__.py" + tree = ast.parse(module_path.read_text(encoding="utf-8"), + filename=str(module_path)) + for node in ast.walk(tree): + if not isinstance(node, ast.Assign): + continue + if any(isinstance(t, ast.Name) and t.id == attr_name + for t in node.targets): + return ast.literal_eval(node.value) + raise ValueError(f"{attr} not found in {module_path}") + + +def next_versions(version: Version): + """Return the two versions immediately ahead of `version`: the next + patch, and the next minor with patch reset to 0.""" + major, minor, patch = (tuple(version.release) + (0, 0, 0))[:3] + return (Version(f"{major}.{minor}.{patch + 1}"), + Version(f"{major}.{minor + 1}.0")) + + +def check_package(package: str = PACKAGE, package_dir: Path = ROOT): + """Return ``(package, pypi_version, local_version, ok, detail)``.""" + pypi = pypi_latest_version(package) + local = local_version(package_dir) + if pypi is None: + return package, pypi, local, True, "never published" + local_v, pypi_v = Version(local), Version(pypi) + if local_v <= pypi_v: + return package, pypi, local, False, f"local is not ahead of PyPI ({pypi})" + next_patch, next_minor = next_versions(pypi_v) + if local_v not in (next_patch, next_minor): + return (package, pypi, local, False, + f"jumps more than one release past PyPI ({pypi}); " + f"expected {next_patch} or {next_minor}") + return package, pypi, local, True, "ok" + + +def main() -> int: + """Print the verdict and return the process exit status.""" + package, pypi, local, ok, detail = check_package() + print(f"{'package':<12} {'pypi':<10} {'local':<10} verdict") + verdict = "OK" if ok else "FAIL" + print(f"{package:<12} {pypi or '-':<10} {local:<10} {verdict}: {detail}") + return 0 if ok else 1 + + +if __name__ == "__main__": + sys.exit(main())