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 f801f59..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 --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 cb5c348..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/ 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 4e29389..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,7 +151,10 @@ 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): @@ -157,7 +165,7 @@ 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": "iVBORw0KGgoAAAANSUhEUgAAAfkAAAHpCAYAAACBYEV/AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABKnklEQVR4nO3dd1QU5/4G8Gdou9RFJQIqggZRLCAaUUBFbGASS2xX4/WCNRpbriVqEo2aRI0l1kj8qdEYY7kaRSMJanDXArZEQY0oFrAF0CiwQOg7vz88blwpgrIsDM/nnD2HfXfKd4Zln5133hkEURRFEBERkeQYGboAIiIi0g+GPBERkUQx5ImIiCSKIU9ERCRRDHkiIiKJYsgTERFJFEOeiIhIohjyVG2Jogi1Wg3e6oGIqHgMeaq2MjIyoFAokJGRYehSiIiqJIY8ERGRRDHkiYiIJIohT0REJFEMeSIiIoliyBMREUkUQ56IiEiiGPJEREQSxZAnIiKSKIY8ERGRRDHkiYiIJIohT0REJFEMeSIiIoliyBMREUkUQ56IiEiiGPJEREQSxZAnIiKSKIY8ERGRRDHkiYiIJIohT0REJFEMeSIiIoliyBMREUkUQ56IiEiiGPJEREQSxZAnIiKSKIY8ERGRRJkYugCi6mxgaDSS0nMAAI4KOfaM9zVwRUT6wfd69cSQJ3oFSek5uJ+WbegyiPSO7/Xqid31REREEsWQJyIikih21xNRlSaKIi7cTcORKylIz86HwtwUPZrbw8vJFoIgGLo8oiqNIV8Nde7cGePGjcO7775r6FIqxJUrV9CzZ09cu3YNlpaWhi6HqpD4lAxM3x2Li/fSddpDVTfh0UCBZYM84WZvbaDqiKo+dteXIiQkBIIgaB916tRBUFAQLl68WOZlREREQBAEJCcn67Q7OjrCxcVFpy0xMRGCICAyMrLE5R04cAApKSkYMmSITvuFCxcwaNAg2NvbQy6Xo0mTJhgzZgzi4+PLXKuhNG/eHB06dMBXX31l6FKoColPycDA0OgiAf/UxXvpGBgajfiUjEqujKj6YMi/QFBQEJKSkpCUlITIyEiYmJjg7bffLvP8HTt2hImJCVQqlbYtLi4O2dnZSE1NRWJiorZdqVRCJpPBz8+vxOWtXr0aI0aMgJHRP7+6gwcPokOHDsjNzcUPP/yAuLg4bNu2DQqFAnPmzCnX9j4rLy/vpectrxEjRiA0NBQFBQWVtk6qukRRxPTdsVDnlP5+UOcUYMbuWIiiWEmVEVUvgsi/jhKFhIQgLS0NYWFh2raTJ0+iU6dOePDgAV577TUAwKVLlzBlyhScOnUKFhYWGDBgAL766itYWVkBAHx9feHh4YFvvvkGABAaGorw8HBoNBoMHjwYISEhAIDg4GDcvn1b5wvBsx4+fAh7e3tcunQJLVq0AAD8/fffcHZ2RseOHbFv374i86SlpcHW1hYAcOzYMcyYMQOxsbGoXbs2goOD8fnnn8PE5MlZmy5duqBly5YwMTHBtm3b0KpVKyiVSgiCgHXr1uHAgQNQqVRwdHTEkiVLMHDgQACASqVCQEAAUlNTteuKiYmBl5cXEhIS4OLigtu3b2PixIk4efIk8vLy4OLigqVLl+LNN98E8OQLhY2NDcLDw9GtW7cy/X7UajUUCgXS09NhY2NTpnkqmsuscJ3n9W3NDVKH1OQVavAwI7fM079mLYOZMY9Z9On5y+cSF79loEqoPHhOvhwyMzOxbds2uLq6ok6dOgCArKwsBAYGwsfHB+fOncODBw8wevRoTJw4EVu2bAEABAQEYM+ePdrlKJVKdOnSBYWFhVAqldqQV6lUGDlyZInrP3nyJCwsLODu7q5tO3ToEP766y98+OGHxc7zNHTv37+PN998EyEhIdi6dSuuXr2KMWPGQC6XY968edrpv/vuO4wfPx5RUVE6y5kzZw4WL16MVatW4fvvv8eQIUNw6dIlnVpKM2HCBOTl5eH48eOwtLTElStXtF+CAMDMzAytW7fGiRMnSgz53Nxc5Ob+88GvVqvLtO7KxOuIDaM8XwiIahKG/AscPHhQG0ZZWVlwdHTEwYMHtd3l27dvR05ODrZu3aodNLZ27Vr07t0bX375Jezt7REQEICFCxciKSkJjo6O2iPqgoIChIaGAgBu3bqFO3fuICAgoMRabt++DXt7e52u+uvXrwMAmjVrVup2rFu3Dk5OTli7di0EQUCzZs3w559/YubMmZg7d652mU2aNMGSJUuKzD9o0CCMHj0aAPDZZ5/hyJEjWLNmDdatW1em/Xjnzh0MGDAArVq1AgA0bty4yDT16tXD7du3S1zGokWLMH/+/DKtj4iIGPIvFBAQoA3i1NRUrFu3Dr169cLZs2fh7OyMuLg4eHp66owK9/Pzg0ajwbVr12Bvbw9fX1+YmZlBpVLB09MT2dnZaNOmDTQaDR4+fIiEhASoVCqYm5ujQ4cOJdaSnZ0NuVyu01bWsy1xcXHw8fHRueTIz88PmZmZuHfvHho2bAgAaNu2bbHz+/j4FHkeExNTpnUDwOTJkzF+/HgcPnwY3bt3x4ABA+Dh4aEzjbm5Of7+++8SlzF79mxMnTpV+1ytVsPJyanMNVQGdtdXDHV2PjJyyz4+w1pmAhtzUz1WROylqp4Y8i9gaWkJV1dX7fONGzdCoVBgw4YN+Pzzz8u0DAsLC3h7e0OpVOLx48fo2LEjjI2NYWxsDF9fXyiVSiiVSvj5+cHMzKzE5djZ2SE1NVWnzc3NDQBw9erVIkH8Ml7mEranvQDPfuHIz8/XmWb06NEIDAxEeHg4Dh8+jEWLFmH58uWYNGmSdprHjx/j9ddfL3E9MpkMMpms3PXpU31bc+2HX31bc0TN6mrgiqTh/J1U9F8XXebpt47yhlfDWnqsiPwWH9V5r1P1wJEq5SQIAoyMjJCd/eTN7u7ujtjYWGRlZWmniYqKgpGREZo2baptCwgIgEqlgkqlQpcuXbTtnTt3hkqlwrFjx0rtqgcALy8vJCcn6wR9z549YWdnV2wXO/Bk4N3TOk+dOqUTxFFRUbC2tkaDBg1euN2nT58u8vzp+finAxCTkpK0rxd3lO/k5IRx48Zh7969mDZtGjZs2KDz+uXLl+Hl5fXCWkj6vJxs4dFAUaZpPRso0NrJVr8FEVVTDPkXyM3NRXJyMpKTkxEXF4dJkyYhMzMTvXv3BgAMGzYMcrkcwcHBuHz5MpRKJSZNmoThw4fD3t5eu5yAgABcv34dhw4dgr+/v7bd398fYWFhuHv3bplC3s7OTmdQnKWlJTZu3Ijw8HD06dMHv/76KxITE/Hbb7/hww8/xLhx4wAA77//Pu7evYtJkybh6tWr2L9/Pz799FNMnTpV5xx/SXbv3o1vv/0W8fHx+PTTT3H27FlMnDgRAODq6gonJyfMmzcP169fR3h4OJYvX64z/wcffIBDhw4hISEB58+fh1Kp1Bm0l5iYiPv376N79+4vrIWkTxAELBvkCRt56Z2NNnITLB3kyTvfEZWAIf8CERERcHR0hKOjI9q3b49z585h9+7d2qNxCwsLHDp0CI8fP0a7du0wcOBAdOvWDWvXrtVZjo+PD2QyGURR1Dnv3b59e+Tn58PKygrt2rUrtRZjY2OMGDECP/zwg0573759ER0dDVNTU7z77rto1qwZhg4divT0dO0phfr16+Pnn3/G2bNn4enpiXHjxmHUqFH45JNPyrQf5s+fj507d8LDwwNbt27Fjh070Lx5cwCAqakpduzYgatXr8LDwwNffvllkVMZhYWFmDBhAtzd3REUFAQ3NzedQXs7duxAz5494ezsXKZ6SPrc7K2xZ7xviUf0ng0U2DPel3e8IyoFr5OvZpKTk9GiRQucP3++0gJREATs27cP/fr108vy8/Ly0KRJE2zfvr3UGwE9rypcJ//8eUqek694oigi5m4aDj9z7/qeze3Rmveur1R8r1dPHHhXzTg4OGDTpk24c+eOZI5679y5g48++qhcAU81hyAI8GpYiwPriF4CQ74a0tcRtaG4urrqXMFQnTgq5MX+TCQ1fK9XT+yup2qrKnTXExFVZRx4R0REJFEMeSIiIoliyBMREUkUQ56IiEiiGPJEREQSxZAnIiKSKIY8ERGRRDHkiYiIJIohT0REJFEMeSIiIoliyBMREUkUQ56IiEiiGPJEREQSxZAnIiKSKIY8ERGRRDHkiYiIJIohT0REJFEMeSIiIoliyBMREUkUQ56IiEiiGPJEREQSxZAnIiKSKIY8ERGRRDHkiYiIJIohT0REJFEMeSIiIoliyBMREUkUQ56IiEiiGPJEREQSxZAnIiKSKIY8ERGRRDHkiYiIJIohT0REJFEMeSIiIoliyBMREUkUQ56IiEiiGPJEREQSxZAnIiKSKIY8ERGRRDHkiYiIJIohT0REJFEMeSIiIoliyBMREUkUQ56IiEiiGPJEREQSxZAnIiKSKIY8ERGRRDHkiYiIJIohT0REJFEMeSIiIoliyBMREUkUQ56IiEiiTAxdABFVnoGh0UhKzwEAOCrk2DPe18AVEVVt1f1vhiFPVIMkpefgflq2ocsgqjaq+98Mu+uJiIgkikfyREQGIooiLtxNw5ErKUjPzofC3BQ9mtvDy8kWgiAYujySAIY8EZEBxKdkYPruWFy8l67THqq6CY8GCiwb5Ak3e2sDVUdSwe56KlVISAgEQdA+6tSpg6CgIFy8eLFM80dEREAQBCQnJ+u0Ozo6wsXFRactMTERgiAgMjKyosonqpLiUzIwMDS6SMA/dfFeOgaGRiM+JaOSKyOpYcjTCwUFBSEpKQlJSUmIjIyEiYkJ3n777TLN27FjR5iYmEClUmnb4uLikJ2djdTUVCQmJmrblUolZDIZ/Pz8KngLiKoOURQxfXcs1DkFpU6nzinAjN2xEEWxkiojKWJ3Pb2QTCaDg4MDAMDBwQGzZs1Cp06d8PDhQ7z22mu4dOkSpkyZglOnTsHCwgIDBgzAV199BSsrK1hZWaFdu3ZQqVQYMmQIAEClUqFjx47QaDRQqVQICQnRtnfo0AFyudxQmyp5z44Svp+WDb/FRw1YTc2UV6jBw4zcMk0bey8d3gsjYWbM4zFDef5vprphyFO5ZGZmYtu2bXB1dUWdOnWQlZWFwMBA+Pj44Ny5c3jw4AFGjx6NiRMnYsuWLQCAgIAA7NmzR7sMpVKJLl26oLCwEEqlUifkR44cWeK6c3NzkZv7z4ejWq3WyzbWJNXxQ6umKesXAqLi8OshvdDBgwe1R+XW1tY4cOAAdu3aBSMjI2zfvh05OTnYunUrWrZsia5du2Lt2rX4/vvvkZKSAuBJyMfHxyMpKQkAcOzYMfj7+6Nz5844duwYAODWrVu4c+cOAgICSqxj0aJFUCgU2oeTk5P+N56IqBrjkTy9UEBAAEJDQwEAqampWLduHXr16oWzZ88iLi4Onp6esLS01E7v5+cHjUaDa9euwd7eHr6+vjAzM4NKpYKnpyeys7PRpk0baDQaPHz4EAkJCVCpVDA3N0eHDh1KrGP27NmYOnWq9rlarWbQv6L6tuaGLqHGUWfnIyO39PPxz7KWmcDG3FSPFVFpqntvF0OeXsjS0hKurq7a5xs3boRCocCGDRvKNL+FhQW8vb2hVCrx+PFjdOzYEcbGxjA2Noavry+USiWUSiX8/PxgZmZW4nJkMhlkMtkrb09NVt/WXPuhVd/WHFGzuhq4oprn/J1U9F8XXebpt47yhlfDWnqsiErjt/iozt9MdcPueio3QRBgZGSE7OxsuLu7IzY2FllZWdrXo6KiYGRkhKZNm2rbAgICoFKpoFKp0KVLF217586doVKpcOzYsVK76omkwsvJFh4NFGWa1rOBAq2dbPVbEEkaQ55eKDc3F8nJyUhOTkZcXBwmTZqEzMxM9O7dG8OGDYNcLkdwcDAuX74MpVKJSZMmYfjw4bC3t9cuIyAgANevX8ehQ4fg7++vbff390dYWBju3r3LkKcaQRAELBvkCRt56R2pNnITLB3kyTvf0SthyNMLRUREwNHREY6Ojmjfvj3OnTuH3bt3o0uXLrCwsMChQ4fw+PFjtGvXDgMHDkS3bt2wdu1anWX4+PhAJpNBFEW0bdtW296+fXvk5+drL7Ujqgnc7K2xZ7xviUf0ng0U2DPel3e8o1fGc/JUqi1btmgvhStJq1atcPRo6ddby+Vy5OTkFGmXyWTIzq7eA1uIXoabvTX2T/BDzN00HH7m3vU9m9ujNe9dTxWEIU9EZCCCIMCrYS0OrCO9YcgT1SCOCnmxPxNR8ar734wg8sbIVE2p1WooFAqkp6fDxsbG0OUQEVU5HHhHREQkUQx5IiIiiWLIExERSRRDnoiISKIY8kRERBLFkCciIpIohjwREZFEMeSJiIgkiiFPREQkUQx5IiIiiWLIExERSRRDnoiISKIY8kRERBLFkCciIpIohjwREZFEMeSJiIgkiiFPREQkUQx5IiIiiWLIExERSRRDnoiISKIY8kRERBLFkCciIpIohjwREZFEMeSJiIgkiiFPREQkUQx5IiIiiWLIExERSRRDnoiISKIY8kRERBLFkCciIpIohjwREZFEMeSJiIgkiiFPREQkUQx5IiIiiWLIExERSRRDnoiISKIY8kRERBLFkCciIpIohjwREZFEMeSJiIgkiiFPREQkUQx5IiIiiWLIExERSRRDnoiISKIY8kRERBLFkCciIpIohjwREZFEMeSJiIgkiiFPREQkUQx5IiIiiWLIExERSRRDnoiISKJMDF0AEREADAyNRlJ6DgDAUSHHnvG+Bq6I6OVUpfcyQ56IqoSk9BzcT8s2dBlEr6wqvZfZXU9ERCRRPJInIqoBRFHEhbtpOHIlBenZ+VCYm6JHc3t4OdlCEARDl0d6wpAnIpK4+JQMTN8di4v30nXaQ1U34dFAgWWDPOFmb22g6kif2F1vYCEhIejXr5/2Z0EQsHjxYp1pwsLCinzTFkURGzZsgI+PD2xsbGBlZYUWLVpgypQpuHHjhna6efPmQRCEIo9mzZrpLO+PP/7A4MGD8dprr0Emk8HNzQ1z587F33//DQBQqVTFLufZh0qlwpYtW4p9TS6X66wvOTkZkyZNQuPGjSGTyeDk5ITevXsjMjKyonYtEeFJwA8MjS4S8E9dvJeOgaHRiE/JqOTKqDIw5KsYuVyOL7/8EqmpqSVOI4oi3n33XUyePBlvvvkmDh8+jCtXrmDTpk2Qy+X4/PPPdaZv0aIFkpKSdB4nT57Uvn769Gm0b98eeXl5CA8PR3x8PL744gts2bIFPXr0QF5eHnx9fXXmHzx4MIKCgnTafH2fjCC1sbEpsr7bt29r15eYmIi2bdvi6NGjWLp0KS5duoSIiAgEBARgwoQJFbxHiWouURQxfXcs1DkFpU6nzinAjN2xEEWxkiqjysLu+iqme/fuuHHjBhYtWoQlS5YUO82uXbuwc+dO7N+/H3369NG2N2zYEB06dCjyh2piYgIHB4dilyWKIkaNGgV3d3fs3bsXRkZPvvc5OzvDzc0NXl5eWLFiBWbOnKmzDHNzc+Tm5ha7XEEQSlwfALz//vsQBAFnz56FpaWltr1FixYYOXJkifORtD07Gvl+Wjb8Fh81YDXSkFeowcOM3DJNG3svHd4LI2FmzGO/V/X8e9mQGPJVjLGxMRYuXKg9Um/QoEGRaXbs2IGmTZvqBPyzyjOIJiYmBleuXMH27du1Af+Up6cnunfvjh07dmDmzJnl25ASPH78GBEREfjiiy90Av4pW1vbEufNzc1Fbu4/H1hqtbpCaqKqydAfjjVRWb8QUPXBr2xV0DvvvIPWrVvj008/Lfb1+Ph4NG3aVKftgw8+gJWVFaysrIp8Mbh06ZL2taePcePGaZcFAO7u7sWuy93dXTtNWaWnpxdZX69evQAAN27cgCiKRcYElMWiRYugUCi0Dycnp3Ivg4ioJuGRfBX15ZdfomvXrpg+fXqZpv/4448xceJE7N27FwsXLtR5rWnTpjhw4IBOm42Njc7zijwXZ21tjfPnz+u0mZubv/J6Zs+ejalTp2qfq9VqBr2E1bc1N3QJ1Z46Ox8ZuaWfj3+WtcwENuameqyoZqhKvVAM+Sqqc+fOCAwMxOzZsxESEqLzWpMmTXDt2jWdttdeew2vvfYa6tatW2RZZmZmcHV1LXY9bm5uAIC4uDh4eXkVeT0uLk47TVkZGRmVuL4mTZpAEARcvXq1XMsEAJlMBplMVu75qHqob2uu/XCsb2uOqFldDVxR9Xf+Tir6r4su8/RbR3nDq2EtPVZUM/gtPqrzXjYkdtdXYYsXL8ZPP/2EU6dO6bQPHToU165dw/79+195Ha1bt0azZs2wYsUKaDQanddiY2Px66+/YujQoa+8nqdq166NwMBAfP3118jKyiryelpaWoWti6im83KyhUcDRZmm9WygQGsnW/0WRJWOIV+FtWrVCsOGDcPq1at12ocMGYKBAwdiyJAhWLBgAc6cOYPExEQcO3YMu3btgrGxsc70BQUFSE5O1nmkpKQAeDJIb9OmTbhy5QoGDBiAs2fP4s6dO9i9ezd69+4NHx8ffPDBB+WqWxTFIutLTk7Wfon4+uuvUVhYCG9vb/z444+4fv064uLisHr1avj4+Lz8DiMiHYIgYNkgT9jIS++0tZGbYOkgT975ToLKHfKPHj3ChAkT0Lx5c9jZ2aF27do6D6pYCxYsKHKELQgCdu3ahZUrV+Lnn39Gt27d0LRpU4wcORJOTk4618ADT2504+joqPNwdnbWvu7r64vTp0/D2NgYvXr1gqurK2bPno3g4GAcOXKk3F3karW6yPocHR3x4MEDAEDjxo1x/vx5BAQEYNq0aWjZsiV69OiByMhIhIaGvuSeIqLiuNlbY8943xKP6D0bKLBnvC/veCdRgljOkVBvvvkmbty4gVGjRsHe3r7IN7/g4OAKLZCoJGq1GgqFAunp6UUGElL18/x5TJ6Tr1iiKCLmbhoOP3Pv+p7N7dGa966vcFXpvVzugXcnTpzAyZMn4enpqY96iIhIDwRBgFfDWhxYV8OUO+SbNWuG7Oyqc3kAEUmDo0Je7M9E1U1Vei+Xu7v+3LlzmDVrFubOnYuWLVvC1FT3mkp2m1JlYXc9EVHpyn0kb2trC7Vaja5ddc8xiKIIQRBQWFhYYcURERHRyyt3yA8bNgympqbYvn17sQPviIiIqGood8hfvnwZFy5cKHLvdCIiIqpayn2d/BtvvIG7d+/qoxYiIiKqQOU+kp80aRKmTJmCGTNmoFWrVkUG3nl4eFRYcURERPTyyj26/vn/OQ48uf6SA++osnF0PRFR6cp9JJ+QkKCPOoiIiKiClTvkn73nOREREVVdL/X/5K9fvw6lUokHDx4U+ecpc+fOrZDCiIiI6NWU+5z8hg0bMH78eNjZ2cHBwUHnOnlBEHD+/PkKL5KoODwnT0RUunKHvLOzM95//33MnDlTXzURlQlDnoiodOW+Tj41NRWDBg3SRy1ERERUgcod8oMGDcLhw4f1UQsRERFVoDINvFu9erX2Z1dXV8yZMwenT58u9mY4kydPrtgKiYiI6KWU6Zx8o0aNyrYwQcCtW7deuSiisuA5eSKi0pXpSJ43wCEiIqp+yn1OfsGCBfj777+LtGdnZ2PBggUVUhQRERG9unJfQmdsbIykpCTUrVtXp/3Ro0eoW7cu711PlYbd9UREpSv3kfzTf0TzvNjYWNSuXbtCiiIiIqJXV+bb2taqVQuCIEAQBLi5uekEfWFhITIzMzFu3Di9FElERETlV+aQX7lyJURRxMiRIzF//nwoFArta2ZmZnBxcYGPj49eiiQiIqLyK/c5+WPHjsHX17fI9fFElY3n5ImISlemI3m1Wq39EPXy8kJ2djays7OLnZYftkRERFVDmUK+Vq1a2hH1tra2xQ68ezogj6PriYiIqoYyhfzRo0e1I+eVSqVeCyIiIqKKUaaQ9/f3BwAUFBTg2LFjGDlyJBo0aKDXwoiIiOjVlOs6eRMTEyxduhQFBQX6qoeIiIgqSLlvhtO1a1ccO3ZMH7UQERFRBSrzdfJP9erVC7NmzcKlS5fQtm1bWFpa6rzep0+fCiuOiIiIXl65r5M3Mir54J+j66ky8Tp5IqLSlftIXqPR6KMOIiIiqmDlPidPRERE1cNLhfyxY8fQu3dvuLq6wtXVFX369MGJEycqujYiIiJ6BeUO+W3btqF79+6wsLDA5MmTMXnyZJibm6Nbt27Yvn27PmokIiKil1DugXfu7u4YO3Ys/vvf/+q0f/XVV9iwYQPi4uIqtECiknDgHRFR6cp9JH/r1i307t27SHufPn2QkJBQIUURERHRqyt3yDs5OSEyMrJI+6+//gonJ6cKKYqIiIheXbkvoZs2bRomT56MmJgY+Pr6AgCioqKwZcsWrFq1qsILJCIiopdT7nPyALBv3z4sX75ce/7d3d0dM2bMQN++fSu8QKKS8Jw8EVHpXirkiaoChjwRUel4MxwiIiKJKvc5+Vq1akEQhCLtgiBALpfD1dUVISEhGDFiRIUUSERERC+n3CE/d+5cfPHFF+jVqxe8vb0BAGfPnkVERAQmTJiAhIQEjB8/HgUFBRgzZkyFF0xERERlU+6QP3nyJD7//HOMGzdOp339+vU4fPgwfvzxR3h4eGD16tUMeSIiIgMq98A7KysrxMTEwNXVVaf9xo0baN26NTIzM3Hz5k14eHggKyurQoslehYH3hERla7cA+9q166Nn376qUj7Tz/9hNq1awMAsrKyYG1t/erVERER0Usrd3f9nDlzMH78eCiVSu05+XPnzuHnn3/GN998AwA4cuQI/P39K7ZSIiIiKpeXuk4+KioKa9euxbVr1wAATZs2xaRJk7R3wCOqDOyuJyIqHW+GQ9UWQ56IqHRl6q5Xq9VlXiA/bImIiKqGMoW8ra1tsTfAeZYoihAEAYWFhRVSGBEREb2aMoW8Uqks08IuXbr0SsUQERFRxXnlc/IZGRnYsWMHNm7ciN9//51H8lRpXuac/MDQaCSl5wAAHBVy7BnPwaJU/fF9TSUp9yV0Tx0/fhybNm3Cjz/+iHr16qF///74+uuvK7I2ogqXlJ6D+2nZhi6DqELxfU0lKVfIJycnY8uWLdi0aRPUajUGDx6M3NxchIWFoXnz5vqqkYiIiF5CmUO+d+/eOH78ON566y2sXLkSQUFBMDY21t4Ah4joKVEUceFuGo5cSUF6dj4U5qbo0dweXk4vHsRLRBWnzLe1/eWXXzBq1CjMnz8fb731FoyNjfVZl0F17twZ27dvL9c8KpUKgiAgLS1NP0UZQEhICPr161eueVxcXLBy5cpyr2vWrFmYNGlSueejqic+JQN9v45C/3XRCFXdxPYzdxCquon+66LR9+soxKdkGLpEohqjzCF/8uRJZGRkoG3btmjfvj3Wrl2Lv/7665VWHhISAkEQtI86deogKCgIFy9eLPMyIiIiIAgCkpOTddodHR3h4uKi05aYmAhBEBAZGVni8g4cOICUlBQMGTJEp/3ChQsYNGgQ7O3tIZfL0aRJE4wZMwbx8fFlrlVfOnToUOS/An7zzTcQBAFbtmzRaQ8JCUGnTp3KtNxVq1YVmf9VPf0dxMTE6LRPnz4d3333HW7dulWh66PKFZ+SgYGh0bh4L73Y1y/eS8fA0GgGPVElKXPId+jQARs2bEBSUhLee+897Ny5E/Xq1YNGo8GRI0eQkfFyf7RBQUFISkpCUlISIiMjYWJigrfffrvM83fs2BEmJiZQqVTatri4OGRnZyM1NRWJiYnadqVSCZlMBj8/vxKXt3r1aowYMQJGRv/smoMHD6JDhw7Izc3FDz/8gLi4OGzbtg0KhQJz5swp1/bqQ0BAgM72A0+21cnJqUi7SqVC165dy7RchUIBW1vbiinyBezs7BAYGIjQ0NBKWR9VPFEUMX13LNQ5BaVOp84pwIzdseDNNon075Uuobt27Ro2bdqE77//HmlpaejRowcOHDhQ5vlDQkKQlpaGsLAwbdvJkyfRqVMnPHjwAK+99hqAJ9ffT5kyBadOnYKFhQUGDBiAr776ClZWVgAAX19feHh4aMcHhIaGIjw8HBqNBoMHD0ZISAgAIDg4GLdv3y4SfE89fPgQ9vb2uHTpElq0aAEA+Pvvv+Hs7IyOHTti3759ReZJS0uDra0tVCoVAgICkJqaCltbWzx69AgTJ07E8ePHkZqaitdffx0fffQRhg4dqp13z549mD9/Pm7cuAELCwt4eXlh//79sLS0hEqlwocffog//vgDpqamaNGiBbZv3w5nZ+ciNRw+fBiBgYFISkqCg4MDAMDBwQFz587FkiVLtF90EhIS0LhxYyiVSnTp0gV3797FtGnTcPjwYRgZGaFTp05YtWqVtgfk+d9PRkYGxo0bh7CwMNjY2ODDDz/E/v370bp1a20XvYuLC8aOHYsbN25g9+7dqFWrFj755BOMHTsWAIqcj/X399f+PrZu3YqPP/4Yd+/eLfb387yXuYTOZVa4zvP6tuZlmo9eLK9Qg4cZuWWe/jVrGcyMy/2PMKkYz4+sT1z8loEqoarmpS+hA578Y5olS5Zg0aJF+Omnn/Dtt9++UjGZmZnYtm0bXF1dUadOHQBP/m1tYGAgfHx8cO7cOTx48ACjR4/GxIkTtV3JAQEB2LNnj3Y5T0OssLAQSqVSG/IqlQojR44scf0nT56EhYUF3N3dtW2HDh3CX3/9hQ8//LDYeUo60s3JyUHbtm0xc+ZM2NjYIDw8HMOHD8frr78Ob29vJCUlYejQoViyZAneeecdZGRk4MSJExBFEQUFBejXrx/GjBmDHTt2IC8vD2fPni1xwJKfnx9MTU2hVCoxdOhQXLlyBdnZ2Rg1ahRmzpyJhIQENGrUCEqlEnK5HD4+PsjPz9fu1xMnTsDExASff/659nSJmZlZkfVMnToVUVFROHDgAOzt7TF37lycP38erVu31plu+fLl+Oyzz/DRRx9hz549GD9+PPz9/dG0aVOcPXsW3t7e+PXXX9GiRQud9Xh7e+PevXtITEwscqoFAHJzc5Gb+0+IlOd2yyXhZUeGU54vBET0cirka7SxsTH69etXrqP4pw4ePAgrKytYWVnB2toaBw4cwK5du7Td5du3b0dOTg62bt2Kli1bomvXrli7di2+//57pKSkAHgS8vHx8UhKSgIAHDt2DP7+/ujcuTOOHTsGALh16xbu3LmDgICAEmu5ffs27O3tdbrqr1+/DgBo1qxZubarfv36mD59Olq3bo3GjRtj0qRJCAoKwv/+9z8AQFJSEgoKCtC/f3+4uLigVatWeP/992FlZQW1Wo309HS8/fbbeP311+Hu7o7g4GA0bNiw2HVZWlrC29tbe0SsUqnQsWNHyGQy+Pr66rT7+PhAJpNh165d0Gg02LhxI1q1agV3d3ds3rwZd+7cKbanIyMjA9999x2WLVuGbt26oWXLlti8eXOxNz9688038f7778PV1RUzZ86EnZ2d9q6JT3tn6tSpAwcHB9SuXVs7X7169QA8+T0UZ9GiRVAoFNqHk5PTi38RREQ12CsdyVeEgIAA7XnY1NRUrFu3Dr169cLZs2fh7OyMuLg4eHp6wtLSUjuPn58fNBoNrl27Bnt7e/j6+sLMzAwqlQqenp7Izs5GmzZtoNFo8PDhQyQkJEClUsHc3BwdOnQosZbs7GzI5XKdtpc9m1FYWIiFCxfif//7H+7fv4+8vDzk5ubCwsICAODp6Ylu3bqhVatWCAwMRM+ePTFw4EDUqlULtWvXRkhICAIDA9GjRw90794dgwcPhqOjY4nr69KlC3bv3g3gSZh36dIFwD/d4SNGjIBKpcKYMWMAALGxsbhx4wasra11lpOTk4ObN28WWf6tW7eQn58Pb29vbZtCoUDTpk2LTOvh4aH9WRAEODg44MGDBy/cZ+bmT7rO//7772Jfnz17NqZOnap9rlarXzno2V1fcdTZ+cjILf18/LOsZSawMTfVY0U1B3ukqCQGD3lLS0u4urpqn2/cuBEKhQIbNmzA559/XqZlWFhYwNvbG0qlEo8fP0bHjh1hbGwMY2Nj+Pr6QqlUQqlUws/Pr9hu6Kfs7OyQmpqq0+bm5gYAuHr1Knx8fMq8XUuXLsWqVauwcuVKtGrVCpaWlvjggw+Ql5cH4Envx5EjRxAdHY3Dhw9jzZo1+Pjjj3HmzBk0atQImzdvxuTJkxEREYFdu3bhk08+wZEjR0r8khIQEIAvvvgC9+/fh0qlwvTp0wE8Cfn169fj5s2buHv3rnbQXWZmJtq2bYsffvihyLKeHm2/LFNT3Q9uQRCg0WheON/jx49LXb9MJoNMJnul2urbmms/EOvbmiNqVtkGIdKLnb+Tiv7ross8/dZR3vBqWEuPFdUcfouP6ryviZ6qcqNeBEGAkZERsrOfvGHd3d0RGxuLrKws7TRRUVEwMjLSOYp8OsL82aNY4Mk17yqVCseOHSu1qx4AvLy8kJycrBP0PXv2hJ2dHZYsWVLsPCVdFx8VFYW+ffvi3//+Nzw9PdG4ceMil9sJggA/Pz/Mnz8fFy5cgJmZmc7gPi8vL8yePRvR0dFo2bJlqdfuP+3NWLdunXY8AAC0a9cODx8+xLfffqvt1geANm3a4Pr166hbty5cXV11HgqFosjyGzduDFNTU5w7d07blp6eXu5LCJ9+ySqum//y5cvaQYZU/Xg52cKjQdH3TnE8GyjQ2slWvwURkeFDPjc3F8nJyUhOTkZcXBwmTZqEzMxM9O7dGwAwbNgwyOVyBAcH4/Lly1AqlZg0aRKGDx8Oe3t77XICAgJw/fp1HDp0CP7+/tp2f39/hIWF4e7du2UKeTs7O0RFRWnbLC0tsXHjRoSHh6NPnz749ddfkZiYiN9++w0ffvhhkevTn2rSpIn2SD0uLg7vvfeedgwBAJw5cwYLFy7Eb7/9hjt37mDv3r14+PAh3N3dkZCQgNmzZ+PUqVO4ffs2Dh8+jOvXr+sMCHze01MRa9asgZ+fn/ZmRWZmZjrtT4+yhw0bBjs7O/Tt2xcnTpzQntKYPHky7t27V2T51tbWCA4OxowZM6BUKvHHH39g1KhRMDIyKtcdzOrWrQtzc3NEREQgJSUF6en/XE994sQJdOrUSdttT9WLIAhYNsgTNvLSOwht5CZYOsiTd74jqgQGD/mIiAg4OjrC0dER7du3x7lz57B7927t0biFhQUOHTqEx48fo127dhg4cCC6deuGtWvX6izn6YAyURS1R7EA0L59e+Tn58PKygrt2rUrtRZjY2OMGDGiSBd23759ER0dDVNTU7z77rto1qwZhg4divT09BJPKXzyySdo06YNAgMD0aVLFzg4OOjcPc7GxgbHjx/Hm2++CTc3N3zyySdYvnw5evXqBQsLC1y9ehUDBgyAm5sbxo4diwkTJuC9994rtf6AgABkZGTo9GQAT77oZGRk6HzJsbCwwPHjx9GwYUP0798f7u7uGDVqFHJyckq8HO2rr76Cj48P3n77bXTv3h1+fn5wd3cvMo6hNCYmJli9ejXWr1+PevXqoW/fvtrXdu7cqR0zQNWTm7019oz3LfGI3rOBAnvG+8LN3rrY14moYr3yv5qVmuTkZLRo0QLnz58v9pp0+kdWVhbq16+P5cuXY9SoUa+0rF9++QXTpk3DxYsXYWJStqEiL3Od/PPnLnlOXj9EUUTM3TQcfube9T2b26M1712vF3xfU0kMPvCuqnFwcMCmTZtw584dhvxzLly4gKtXr8Lb2xvp6elYsGABAOgcjb+srKwsbN68ucwBT1WbIAjwaliLA+uIDIyfqMUo7z9lqUmWLVuGa9euwczMDG3btsWJEydgZ2f3yssdOHBgBVT3Yo4KebE/E1VnfF9TSdhdT9XWy3TXExHVJAYfeEdERET6wZAnIiKSKIY8ERGRRDHkiYiIJIohT0REJFEMeSIiIoliyBMREUkUQ56IiEiiGPJEREQSxZAnIiKSKIY8ERGRRDHkiYiIJIohT0REJFEMeSIiIoliyBMREUkUQ56IiEiiGPJEREQSxZAnIiKSKIY8ERGRRDHkiYiIJIohT0REJFEMeSIiIoliyBMREUkUQ56IiEiiGPJEREQSxZAnIiKSKIY8ERGRRDHkiYiIJIohT0REJFEMeSIiIoliyBMREUkUQ56IiEiiGPJEREQSxZAnIiKSKIY8ERGRRDHkiYiIJIohT0REJFEMeSIiIoliyBMREUkUQ56IiEiiGPJEREQSxZAnIiKSKIY8ERGRRDHkiYiIJIohT0REJFEMeSIiIoliyBMREUkUQ56IiEiiGPJEREQSxZAnIiKSKIY8ERGRRDHkiYiIJMrE0AUQVUUDQ6ORlJ4DAHBUyLFnvK+BKyLSL77npYkhT1SMpPQc3E/LNnQZRJWG73lpYnc9ERGRRPFInoiqFFEUceFuGo5cSUF6dj4U5qbo0dweXk62EATB0OURVSsMeSKqMuJTMjB9dywu3kvXaQ9V3YRHAwWWDfKEm721gaojqn7YXU9EVUJ8SgYGhkYXCfinLt5Lx8DQaMSnZFRyZUTVF0O+hgkJCYEgCBAEAaamprC3t0ePHj3w7bffQqPRGLo8qqFEUcT03bFQ5xSUOp06pwAzdsdCFMVKqoyoemN3fQ0UFBSEzZs3o7CwECkpKYiIiMCUKVOwZ88eHDhwACYmfFs8O8r4flo2/BYfNWA10pdXqMHDjNwyTRt7Lx3eCyNhZsxjlIr0/HuepIGf5jWQTCaDg4MDAKB+/fpo06YNOnTogG7dumHLli0YPXo00tLSMH36dOzfvx+5ubl44403sGLFCnh6egIA5s2bh7CwMEybNg1z5sxBamoqevXqhQ0bNsDa+sk50z179mD+/Pm4ceMGLCws4OXlhf3798PS0hIAsHHjRixfvhwJCQlwcXHB5MmT8f7775dYd25uLnJz/wkCtVqtr11UBD/0qpayfiEgqun4VZgAAF27doWnpyf27t0LABg0aBAePHiAX375Bb///jvatGmDbt264fHjx9p5bt68ibCwMBw8eBAHDx7EsWPHsHjxYgBAUlIShg4dipEjRyIuLg4qlQr9+/fXdrP+8MMPmDt3Lr744gvExcVh4cKFmDNnDr777rsSa1y0aBEUCoX24eTkpMc9QkRU/fFInrSaNWuGixcv4uTJkzh79iwePHgAmUwGAFi2bBnCwsKwZ88ejB07FgCg0WiwZcsW7ZH78OHDERkZiS+++AJJSUkoKChA//794ezsDABo1aqVdl2ffvopli9fjv79+wMAGjVqhCtXrmD9+vUIDg4utr7Zs2dj6tSp2udqtbrSgr6+rXmlrKemUmfnIyO39PPxz7KWmcDG3FSPFdU87K2SJoY8aYmiCEEQEBsbi8zMTNSpU0fn9ezsbNy8eVP73MXFRRvwAODo6IgHDx4AADw9PdGtWze0atUKgYGB6NmzJwYOHIhatWohKysLN2/exKhRozBmzBjt/AUFBVAoFCXWJ5PJtF869K2+rbn2Q6++rTmiZnWtlPXWVOfvpKL/uugyT791lDe8GtbSY0U1j9/iozrveZIGhjxpxcXFoVGjRsjMzISjoyNUKlWRaWxtbbU/m5rqHkkJgqAdoW9sbIwjR44gOjoahw8fxpo1a/Dxxx/jzJkzsLCwAABs2LAB7du311mGsbFxxW4UVQteTrbwaKAo8fK5Z3k2UKC1k63+iyKSAIY8AQCOHj2KS5cu4b///S8aNGiA5ORkmJiYwMXF5aWXKQgC/Pz84Ofnh7lz58LZ2Rn79u3D1KlTUa9ePdy6dQvDhg2ruI2gaksQBCwb5ImBodGlXkZnIzfB0kGevPMdURkx5Gug3NxcJCcn61xCt2jRIrz99tv4z3/+AyMjI/j4+KBfv35YsmQJ3Nzc8OeffyI8PBzvvPMO3njjjReu48yZM4iMjETPnj1Rt25dnDlzBg8fPoS7uzsAYP78+Zg8eTIUCgWCgoKQm5uL3377DampqTrn3anmcLO3xp7xvsXe8Q54cgS/lHe8IyoXhnwNFBERAUdHR5iYmKBWrVrw9PTE6tWrERwcDCOjJxdc/Pzzz/j4448xYsQIPHz4EA4ODujcuTPs7e3LtA4bGxscP34cK1euhFqthrOzM5YvX45evXoBAEaPHg0LCwssXboUM2bMgKWlJVq1aoUPPvhAX5tN1YCbvTX2T/BDzN00HH7m3vU9m9ujNe9dT1RugshbR1E1pVaroVAokJ6eDhsbmwpd9vODkDjwjqSO73lp4pE8UTEcFfJifyaSKr7npYlH8lRt6fNInohICnjHOyIiIoliyBMREUkUQ56IiEiiGPJEREQSxZAnIiKSKIY8ERGRRDHkiYiIJIohT0REJFEMeSIiIoliyBMREUkUQ56IiEiiGPJEREQSxZAnIiKSKIY8ERGRRDHkiYiIJIohT0REJFEMeSIiIoliyBMREUkUQ56IiEiiGPJEREQSxZAnIiKSKIY8ERGRRDHkiYiIJIohT0REJFEMeSIiIoliyBMREUkUQ56IiEiiGPJEREQSxZAnIiKSKIY8ERGRRDHkiYiIJIohT0REJFEMeSIiIoliyBMREUkUQ56IiEiiGPJEREQSxZAnIiKSKIY8ERGRRDHkiYiIJIohT0REJFEMeSIiIoliyBMREUkUQ56IiEiiGPJEREQSxZAnIiKSKIY8ERGRRDHkiYiIJIohT0REJFEMeSIiIoliyBMREUkUQ56IiEiiGPJEREQSZWLoAoioYg0MjUZSeg4AwFEhx57xvgauiKhi8T1edgx5IolJSs/B/bRsQ5dBpDd8j5cdu+uJiIgkikfyRESvSBRFXLibhiNXUpCenQ+FuSl6NLeHl5MtBEEwdHlUgzHkiYheQXxKBqbvjsXFe+k67aGqm/BooMCyQZ5ws7c2UHVU07G7voZSqVQQBAFpaWmGLoWo2opPycDA0OgiAf/UxXvpGBgajfiUjEqujOgJhnwV8PDhQ4wfPx4NGzaETCaDg4MDAgMDERUVBQAQBAFhYWGVXpcgCNqHiYkJGjZsiKlTpyI3N7fMyxgyZAiCgoJ02iIiIiAIAubNm6fTPm/ePDRs2LAiSifSO1EUMX13LNQ5BaVOp84pwIzdsRBFsZIqI/oHu+urgAEDBiAvLw/fffcdGjdujJSUFERGRuLRo0eGLg2bN29GUFAQ8vPzERsbixEjRsDS0hKfffZZmeYPCAjA9OnTUVBQABOTJ283pVIJJycnqFQqnWmVSiUCAgIqehNqnGdHHd9Py4bf4qMGrEa68go1eJhRti+8sffS4b0wEmbGPK6qCM+/x6lkDHkDS0tLw4kTJ6BSqeDv7w8AcHZ2hre3NwDAxcUFAPDOO+9oX0tMTMTNmzcxdepUnD59GllZWXB3d8eiRYvQvXt37bJzc3Mxd+5cbN++HQ8ePICTkxNmz56NUaNGFanj77//xoABA6BWqxEeHg5bW1sAgK2tLRwcHAAATk5O6Nu3L86fP68zb2hoKJYtW4a7d++iUaNG+OSTTzB8+HAAT0I+MzMTv/32Gzp06ADgyamCWbNmYdq0acjJyYFcLkdOTg7OnDmDESNGlLivcnNzdXoR1Gp1mfdzTcYPwaqhrF8IiCoSv1YamJWVFaysrBAWFlZsN/i5c+cAPDmiTkpK0j7PzMzEm2++icjISFy4cAFBQUHo3bs37ty5o533P//5D3bs2IHVq1cjLi4O69evh5WVVZF1pKWloUePHtBoNDhy5Ig24J8XHx+Po0ePon379tq2ffv2YcqUKZg2bRouX76M9957DyNGjIBSqQQAuLm5oV69etrnGRkZOH/+PAYNGgQXFxecOnUKABAdHY3c3NxSj+QXLVoEhUKhfTg5OZW2a4mIajxB5Ikig/vxxx8xZswYZGdno02bNvD398eQIUPg4eEB4Mm58X379qFfv36lLqdly5YYN24cJk6ciPj4eDRt2hRHjhzRObp/SqVSISAgAHFxcfjXv/6FJk2aYPv27TAzM9NOIwgC5HI5jI2NUVBQgNzcXLz99tvYu3cvTE1NAQB+fn5o0aIF/u///k873+DBg5GVlYXw8HAAwL///W88fPgQhw4dws8//4wZM2bgjz/+wHvvvQcHBwfMnz8fc+fOxbZt23Dr1q0St6+4I3knJyekp6fDxsbmxTu6hnCZFa7zvL6tuYEqkTZ1dj4ycks/H/8sa5kJbMxN9VhRzfF871Ti4rcMVEnVx+76KmDAgAF46623cOLECZw+fRq//PILlixZgo0bNyIkJKTYeTIzMzFv3jyEh4cjKSkJBQUFyM7O1h7Jx8TEwNjYWHsKoCQ9evSAt7c3du3aBWNj4yKvr1ixAt27d0dhYSFu3LiBqVOnYvjw4di5cycAIC4uDmPHjtWZx8/PD6tWrdI+79KlCz744APk5+dDpVKhS5cuAAB/f3+sX78ewD9fOkojk8kgk8lKnYaehPrTD8H6tuaImtXVwBVJ0/k7qei/LrrM028d5Q2vhrX0WFHN4bf4qM57nErG7voqQi6Xo0ePHpgzZw6io6MREhKCTz/9tMTpp0+fjn379mHhwoU4ceIEYmJi0KpVK+Tl5QEAzM3L9sZ/6623cPz4cVy5cqXY1x0cHODq6oqmTZvirbfewvz587Fr1y7cuHGjzNsWEBCArKwsnDt3DkqlUvvFw9/fH2fOnMHjx49x5swZdO3KMKLqw8vJFh4NFGWa1rOBAq2dbPVbEFExGPJVVPPmzZGVlQUAMDU1RWFhoc7rUVFRCAkJwTvvvINWrVrBwcEBiYmJ2tdbtWoFjUaDY8eOlbqexYsXIzg4GN26dSsx6J/19Gg/O/vJt2h3d3ftpX7P1ta8eXPt89dffx1OTk44cOAAYmJitCFfv3591K9fH8uXL0deXh5H1lO1IggClg3yhI289A5RG7kJlg7y5J3vyCDYXW9gjx49wqBBgzBy5Eh4eHjA2toav/32G5YsWYK+ffsCeDLCPjIyEn5+fpDJZKhVqxaaNGmCvXv3onfv3hAEAXPmzIFGo9Eu18XFBcHBwRg5ciRWr14NT09P3L59Gw8ePMDgwYN1ali2bBkKCwvRtWtXqFQqNGvWTPtaWloakpOTodFocP36dSxYsABubm5wd3cHAMyYMQODBw+Gl5cXunfvjp9++gl79+7Fr7/+qrOOgIAArFu3Dq6urrC3t9e2+/v7Y82aNdoBekTViZu9NfaM9y32jnfAkyP4pbzjHRkQQ97ArKys0L59e6xYsQI3b95Efn4+nJycMGbMGHz00UcAgOXLl2Pq1KnYsGED6tevj8TERHz11VcYOXIkfH19YWdnh5kzZxa5pCw0NBQfffQR3n//fTx69AgNGzbULvN5K1as0Al6Nzc3ANBe0iYIAhwcHNC5c2csXLhQe817v379sGrVKixbtgxTpkxBo0aNsHnzZu1596cCAgKwdevWIu3+/v7YvHkz3n333VfdlUQG4WZvjf0T/BBzNw2Hn7l3fc/m9mjNe9eTgXF0PVVbarUaCoWCo+uf8/ygJA68I6nhe7zseCRPJDGOCnmxPxNJBd/jZccjeaq2eCRPRFQ6jq4nIiKSKIY8ERGRRDHkiYiIJIohT0REJFEMeSIiIoliyBMREUkUQ56IiEiiGPJEREQSxZAnIiKSKIY8ERGRRDHkiYiIJIohT0REJFEMeSIiIoliyBMREUkUQ56IiEiiGPJEREQSxZAnIiKSKIY8ERGRRDHkiYiIJIohT0REJFEMeSIiIoliyBMREUkUQ56IiEiiGPJEREQSxZAnIiKSKBNDF0D0skRRBACo1WoDV0JEVLGsra0hCMIrL4chT9VWRkYGAMDJycnAlRARVaz09HTY2Ni88nIE8enhEFE1o9Fo8Oeff1bYN96SqNVqODk54e7duxXyR1dTcL+9PO67lyOl/cYjearxjIyM0KBBg0pbn42NTbX/4DAE7reXx333crjf/sGBd0RERBLFkCciIpIohjzRC8hkMnz66aeQyWSGLqVa4X57edx3L4f7rSgOvCMiIpIoHskTERFJFEOeiIhIohjyREREEsWQJyIikiiGPNVIX3/9NVxcXCCXy9G+fXucPXu2xGn37t2LN954A7a2trC0tETr1q3x/ffflzj9uHHjIAgCVq5cqYfKDUsf+y0uLg59+vSBQqGApaUl2rVrhzt37uhzMypdRe+3zMxMTJw4EQ0aNIC5uTmaN2+Ob775Rt+bUenKs9+etXPnTgiCgH79+um0i6KIuXPnwtHREebm5ujevTuuX7+uh8qrEJGohtm5c6doZmYmfvvtt+Iff/whjhkzRrS1tRVTUlKKnV6pVIp79+4Vr1y5It64cUNcuXKlaGxsLEZERBSZdu/evaKnp6dYr149ccWKFXreksqlj/1248YNsXbt2uKMGTPE8+fPizdu3BD3799f4jKrI33stzFjxoivv/66qFQqxYSEBHH9+vWisbGxuH///sraLL0r7357KiEhQaxfv77YqVMnsW/fvjqvLV68WFQoFGJYWJgYGxsr9unTR2zUqJGYnZ2txy0xLIY81Tje3t7ihAkTtM8LCwvFevXqiYsWLSrzMry8vMRPPvlEp+3evXti/fr1xcuXL4vOzs6SC3l97Ld//etf4r///e8KrbOq0cd+a9GihbhgwQKdadq0aSN+/PHHr15wFfEy+62goED09fUVN27cKAYHB+uEvEajER0cHMSlS5dq29LS0kSZTCbu2LFDL9tQFbC7nmqUvLw8/P777+jevbu2zcjICN27d8epU6deOL8oioiMjMS1a9fQuXNnbbtGo8Hw4cMxY8YMtGjRQi+1G5I+9ptGo0F4eDjc3NwQGBiIunXron379ggLC9PXZlQ6fb3ffH19ceDAAdy/fx+iKEKpVCI+Ph49e/bUy3ZUtpfdbwsWLEDdunUxatSoIq8lJCQgOTlZZ5kKhQLt27cv0++iuuI/qKEa5a+//kJhYSHs7e112u3t7XH16tUS50tPT0f9+vWRm5sLY2NjrFu3Dj169NC+/uWXX8LExASTJ0/WW+2GpI/99uDBA2RmZmLx4sX4/PPP8eWXXyIiIgL9+/eHUqmEv7+/XrepMujr/bZmzRqMHTsWDRo0gImJCYyMjLBhwwadLwLV2cvst5MnT2LTpk2IiYkp9vXk5GTtMp5f5tPXpIghT1QG1tbWiImJQWZmJiIjIzF16lQ0btwYXbp0we+//45Vq1bh/Pnzev2Xt9VRaftNo9EAAPr27Yv//ve/AIDWrVsjOjoa33zzjSRC/mWVtt+AJyF/+vRpHDhwAM7Ozjh+/DgmTJiAevXq6Ryp1hQZGRkYPnw4NmzYADs7O0OXU6Uw5KlGsbOzg7GxMVJSUnTaU1JS4ODgUOJ8RkZGcHV1BfAkiOLi4rBo0SJ06dIFJ06cwIMHD9CwYUPt9IWFhZg2bRpWrlyJxMREvWxLZdLHfrOzs4OJiQmaN2+uM4+7uztOnjxZ8RthAPrYb9nZ2fjoo4+wb98+vPXWWwAADw8PxMTEYNmyZZII+fLut5s3byIxMRG9e/fWtj39EmliYoJr165p50tJSYGjo6POMlu3bq2HragaeE6eahQzMzO0bdsWkZGR2jaNRoPIyEj4+PiUeTkajQa5ubkAgOHDh+PixYuIiYnRPurVq4cZM2bg0KFDFb4NhqCP/WZmZoZ27drh2rVrOtPEx8fD2dm5Ygo3MH3st/z8fOTn58PISPfj29jYWBts1V1591uzZs1w6dIlnb/BPn36ICAgADExMXByckKjRo3g4OCgs0y1Wo0zZ86U63dR7Rh23B9R5du5c6cok8nELVu2iFeuXBHHjh0r2traisnJyaIoiuLw4cPFWbNmaadfuHChePjwYfHmzZvilStXxGXLlokmJibihg0bSlyHFEfX62O/7d27VzQ1NRX/7//+T7x+/bq4Zs0a0djYWDxx4kSlb5++6GO/+fv7iy1atBCVSqV469YtcfPmzaJcLhfXrVtX6dunL+Xdb897fnS9KD65hM7W1lbcv3+/ePHiRbFv3768hI5IitasWSM2bNhQNDMzE729vcXTp09rX/P39xeDg4O1zz/++GPR1dVVlMvlYq1atUQfHx9x586dpS5fiiEvivrZb5s2bdJO5+npKYaFhVXGplSqit5vSUlJYkhIiFivXj1RLpeLTZs2FZcvXy5qNJrK2qRKUZ799rziQl6j0Yhz5swR7e3tRZlMJnbr1k28du2anqqvGvivZomIiCSK5+SJiIgkiiFPREQkUQx5IiIiiWLIExERSRRDnoiISKIY8kRERBLFkCciIpIohjwREZFEMeSJiIgkiiFPRJL28OFDjB8/Hg0bNoRMJoODgwMCAwMRFRVl6NKI9I7/apaIJG3AgAHIy8vDd999h8aNGyMlJQWRkZF49OiRXtaXl5cHMzMzvSybqLx4JE9EkpWWloYTJ07gyy+/REBAAJydneHt7Y3Zs2ejT58+2mnee+892NvbQy6Xo2XLljh48KB2GT/++CNatGgBmUwGFxcXLF++XGcdLi4u+Oyzz/Cf//wHNjY2GDt2LADg5MmT6NSpE8zNzeHk5ITJkycjKyur8jaeCAx5IpIwKysrWFlZISwsTPv/2J+l0WjQq1cvREVFYdu2bbhy5QoWL14MY2NjAMDvv/+OwYMHY8iQIbh06RLmzZuHOXPmYMuWLTrLWbZsGTw9PXHhwgXMmTMHN2/eRFBQEAYMGICLFy9i165dOHnyJCZOnFgZm02kxf9CR0SS9uOPP2LMmDHIzs5GmzZt4O/vjyFDhsDDwwOHDx9Gr169EBcXBzc3tyLzDhs2DA8fPsThw4e1bR9++CHCw8Pxxx9/AHhyJO/l5YV9+/Zppxk9ejSMjY2xfv16bdvJkyfh7++PrKwsyOVyPW4x0T94JE9EkjZgwAD8+eefOHDgAIKCgqBSqdCmTRts2bIFMTExaNCgQbEBDwBxcXHw8/PTafPz88P169dRWFiobXvjjTd0pomNjcWWLVu0PQlWVlYIDAyERqNBQkJCxW8kUQk48I6IJE8ul6NHjx7o0aMH5syZg9GjR+PTTz/F9OnTK2T5lpaWOs8zMzPx3nvvYfLkyUWmbdiwYYWsk6gsGPJEVOM0b94cYWFh8PDwwL179xAfH1/s0by7u3uRS+2ioqLg5uamPW9fnDZt2uDKlStwdXWt8NqJyoPd9UQkWY8ePULXrl2xbds2XLx4EQkJCdi9ezeWLFmCvn37wt/fH507d8aAAQNw5MgRJCQk4JdffkFERAQAYNq0aYiMjMRnn32G+Ph4fPfdd1i7du0LewBmzpyJ6OhoTJw4ETExMbh+/Tr279/PgXdU6XgkT0SSZWVlhfbt22PFihW4efMm8vPz4eTkhDFjxuCjjz4C8GRg3vTp0zF06FBkZWXB1dUVixcvBvDkiPx///sf5s6di88++wyOjo5YsGABQkJCSl2vh4cHjh07ho8//hidOnWCKIp4/fXX8a9//Uvfm0ykg6PriYiIJIrd9URERBLFkCciIpIohjwREZFEMeSJiIgkiiFPREQkUQx5IiIiiWLIExERSRRDnoiISKIY8kRERBLFkCciIpIohjwREZFE/T/cswbb2Z+WrwAAAABJRU5ErkJggg==\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 bed3d66..a151430 100644 --- a/docs/source/conf.py +++ b/docs/source/conf.py @@ -1,180 +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', - 'sphinxcontrib.mermaid' + '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 b9b3993..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,27 +25,115 @@ 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 +Version |compstats_version|. -.. image:: https://colab.research.google.com/assets/colab-badge.svg - :target: https://colab.research.google.com/github/INGEOTEC/CompStats/blob/docs/docs/CompStats.ipynb +.. note:: + 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/. -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. +Introduction +==================================== -.. note:: +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 +==================================== + +Each concept below is stated with its formula and the symbol of the package that computes it. + +**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. + +**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. + +**Standard error.** The standard deviation of the bootstrap distribution, + +.. math:: + + \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}, + +computed by :py:func:`~CompStats.measurements.SE` and exposed as the ``se`` property of +:py:class:`~CompStats.interface.Perf`. + +**Confidence interval.** The percentile interval + +.. math:: + + \left[ q_{\alpha/2}(s_j^{*}),\; q_{1-\alpha/2}(s_j^{*}) \right], + +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`. + +**Paired difference.** For a reference system :math:`A` (by default the best one) and another +system :math:`B`, the bootstrap distribution of + +.. math:: + + \delta^{*} = s^{*}(y, \hat{y}_A) - s^{*}(y, \hat{y}_B) + +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`. + +**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)`, + +.. math:: + + \hat{p} = \frac{1}{B} \sum_{b=1}^{B} \mathbb{1}\left[\delta^{*b} \geq 2\delta(x)\right], + +(: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. + +**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. + +**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, + +.. math:: - This page is the **development documentation** for :py:class:`CompStats`: the internal - architecture and the full API reference, aimed at people extending or contributing to the - package. If you are looking to learn how to *use* CompStats -- installation, and tutorials for - scikit-learn users, competition organizers, and correcting for multiple comparisons -- visit the - `CompStats website `_ instead. + CV = 100 \, \frac{s_x}{\bar{x}}, + +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. Architecture ==================================== -:py:class:`CompStats` is organized around one core data flow: raw predictions from one or more +**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. @@ -135,7 +224,7 @@ Module and class relationships :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:`StatisticSamples` + 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 @@ -190,28 +279,89 @@ Invariants to preserve ``CompStats.performance.difference``). Plain re-instantiation silently redraws new bootstrap samples and breaks paired comparisons. +Development +==================================== + +Install the package with its test dependencies and the documentation dependencies: + +.. code:: bash + + pip install -e ".[test]" + pip install -r docs/requirements.txt + +Run the test suite: + +.. code:: bash + + pytest CompStats + +Build the developer reference; the HTML is written to ``docs/build/html/index.html``: + +.. code:: bash + + python -m sphinx -n -W --keep-going -b html docs/source docs/build/html + +The same strict build runs in continuous integration, and any warning (for example, a +cross-reference that does not resolve) makes it fail. + +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. + +User site +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +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 ==================================== @@ -219,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/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/_freeze/index/execute-results/html.json b/quarto/_freeze/index/execute-results/html.json deleted file mode 100644 index e11bade..0000000 --- a/quarto/_freeze/index/execute-results/html.json +++ /dev/null @@ -1,12 +0,0 @@ -{ - "hash": "598cc5d3e70c421a413e69023838688b", - "result": { - "engine": "jupyter", - "markdown": "---\ntitle: \"CompStats\"\nsubtitle: \"A bootstrap-based methodology for comparing algorithms in competitions\"\ntoc: false\nnumber-sections: false\n---\n\n::: {.home-lead}\nCollaborative competitions are now a standard way to evaluate scientific and\ntechnological progress: organizers define a task, participants submit\npredictions for a held-out dataset, and the systems are ranked by\nperformance. The last step -- ranking -- is harder than it looks. **CompStats**,\ndeveloped by [INGEOTEC](https://github.com/INGEOTEC), gives organizers and\nparticipants the statistical tools to do it rigorously.\n:::\n\nTraditional statistical tests are routinely used to decide whether one\nsystem outperforms another, but they often fail to capture decisive\ndifferences between systems' performance, particularly when many\nparticipants must be compared and ranked at once. Nava-Muñoz, Graff and\nEscalante address this in [*Analysis of Systems' Performance in Natural\nLanguage Processing Competitions*](https://arxiv.org/abs/2403.04693), which\nintroduces a bootstrap-based evaluation methodology and validates it on eight\nNLP competitions spanning classification and regression tasks. `CompStats` is\nthe implementation of that methodology: it draws paired bootstrap resamples\nof the held-out set, evaluates every system's predictions on the same\nresamples, and derives standard errors, confidence intervals, and p-values\nfor the difference against the best system directly from the resulting\ndistributions -- without the assumptions a parametric test would require.\n\n::: {.pillars}\n::: {.pillar}\n### Off-the-shelf comparisons\n\nFollows the `sklearn.metrics` convention -- a score function takes\n`(y_true, y_pred)` -- so evaluating a new system is a one-line change.\n:::\n::: {.pillar}\n### Confidence intervals\n\nStandard error and percentile confidence intervals for every metric come\nfrom the bootstrap distribution, with no extra configuration.\n:::\n::: {.pillar}\n### Paired significance testing\n\nEvery system is resampled with the same bootstrap indices, so the p-value\nof a difference against the best system is valid by construction.\n:::\n:::\n\n## Installation\n\n::: {.installs}\n::: {.install}\n### conda\n\n```bash\nconda install --channel conda-forge CompStats\n```\n:::\n::: {.install}\n### pip\n\n```bash\npip install CompStats\n```\n:::\n:::\n\n## Getting started\n\nThis site is organized as one notebook per topic: [scikit-learn\nUsers](pages/sklearn_users.ipynb) walks through wrapping predictions from\nseveral classifiers in a `Perf` instance, [Competition\nOrganizers](pages/competition_organizers.ipynb) shows how to rank\nparticipants and report confidence intervals against a gold standard, and\n[Multiple Testing](pages/multiple_testing.ipynb) covers comparing several\nmeasures at once with correction for multiple comparisons. Every page,\nincluding this one, is a real Jupyter notebook that can also be run outside\nthe site.\n\n## Colophon {.unnumbered}\n\nAs with the rest of the project, this site was built by the CompStats team\ntogether with Claude, Anthropic's coding assistant, through [Claude\nCode](https://claude.com/claude-code): the assistant helped set up the Quarto\nsite and draft this page, with the authors reviewing and validating every\nchange before it was committed.\n\n", - "supporting": [ - "index_files" - ], - "filters": [], - "includes": {} - } -} \ 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 index 15c9f6c..7f79447 100644 --- a/quarto/_freeze/pages/competition_organizers/execute-results/html.json +++ b/quarto/_freeze/pages/competition_organizers/execute-results/html.json @@ -1,8 +1,8 @@ { - "hash": "9810d02b045dad5cf6cffef0af999f11", + "hash": "8af51dfa09cb9b3f14d2c9317d4277f8", "result": { "engine": "jupyter", - "markdown": "---\ntitle: \"Competition Organizers\"\nsubtitle: \"Ranking participants and reporting significance with CompStats\"\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 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=1}\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), so 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: 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=2}\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 -- `(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=3}\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-display execution_count=3}\n```\n\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=4}\n``` {.python .cell-code}\nleaderboard.ci\n```\n\n::: {.cell-output .cell-output-display execution_count=4}\n```\n{'Team Beta': (np.float64(0.8540010141987829), np.float64(0.9493902439024389)),\n 'Team Delta': (np.float64(0.6771539721539722),\n np.float64(0.8111514168658245)),\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 Epsilon': (np.float64(0.6517443762781187),\n np.float64(0.7978723404255319))}\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: 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=5}\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=6}\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 -- 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 -- 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=7}\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=8}\n``` {.python .cell-code}\nleaderboard.plot()\n```\n\n::: {.cell-output .cell-output-display}\n![](competition_organizers_files/figure-html/cell-9-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=9}\n``` {.python .cell-code}\ncomparison.plot()\n```\n\n::: {.cell-output .cell-output-display}\n![](competition_organizers_files/figure-html/cell-10-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=10}\n``` {.python .cell-code}\nleaderboard.plot(correction='bonferroni')\n```\n\n::: {.cell-output .cell-output-display}\n![](competition_organizers_files/figure-html/cell-11-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=11}\n``` {.python .cell-code}\ncomparison.plot(correction='bonferroni')\n```\n\n::: {.cell-output .cell-output-display}\n![](competition_organizers_files/figure-html/cell-12-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", + "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" ], 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 index e7c66b3..329593d 100644 Binary files a/quarto/_freeze/pages/competition_organizers/figure-html/cell-10-output-1.png 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 index d78945b..892901c 100644 Binary files a/quarto/_freeze/pages/competition_organizers/figure-html/cell-11-output-1.png 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 index f1efe7d..126fe04 100644 Binary files a/quarto/_freeze/pages/competition_organizers/figure-html/cell-12-output-1.png 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/competition_organizers/figure-html/cell-8-output-1.png b/quarto/_freeze/pages/competition_organizers/figure-html/cell-8-output-1.png deleted file mode 100644 index da028b8..0000000 Binary files a/quarto/_freeze/pages/competition_organizers/figure-html/cell-8-output-1.png and /dev/null differ diff --git a/quarto/_freeze/pages/competition_organizers/figure-html/cell-9-output-1.png b/quarto/_freeze/pages/competition_organizers/figure-html/cell-9-output-1.png deleted file mode 100644 index 34dd8bb..0000000 Binary files a/quarto/_freeze/pages/competition_organizers/figure-html/cell-9-output-1.png and /dev/null differ diff --git a/quarto/_freeze/pages/multiple_testing/execute-results/html.json b/quarto/_freeze/pages/multiple_testing/execute-results/html.json index 6657724..fcc1a74 100644 --- a/quarto/_freeze/pages/multiple_testing/execute-results/html.json +++ b/quarto/_freeze/pages/multiple_testing/execute-results/html.json @@ -1,10 +1,10 @@ { - "hash": "74f3d31904c10480be8fe110a5dfda5a", + "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\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=1}\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 built with its `.measure` factory so 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=2}\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-display execution_count=2}\n```\n\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=3}\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=5}\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 -- so 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=6}\n``` {.python .cell-code}\nperf.plot()\n```\n\n::: {.cell-output .cell-output-display}\n![](multiple_testing_files/figure-html/cell-7-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=7}\n``` {.python .cell-code}\ndiff.plot()\n```\n\n::: {.cell-output .cell-output-display}\n![](multiple_testing_files/figure-html/cell-8-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=8}\n``` {.python .cell-code}\nperf.plot(correction='bonferroni')\n```\n\n::: {.cell-output .cell-output-display}\n![](multiple_testing_files/figure-html/cell-9-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=9}\n``` {.python .cell-code}\ndiff.plot(correction='bonferroni')\n```\n\n::: {.cell-output .cell-output-display}\n![](multiple_testing_files/figure-html/cell-10-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", + "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" + "multiple_testing_files/figure-html" ], "filters": [], "includes": { 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 index 19a8114..3efa2de 100644 Binary files a/quarto/_freeze/pages/multiple_testing/figure-html/cell-10-output-1.png 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-7-output-1.png b/quarto/_freeze/pages/multiple_testing/figure-html/cell-7-output-1.png deleted file mode 100644 index 259f255..0000000 Binary files a/quarto/_freeze/pages/multiple_testing/figure-html/cell-7-output-1.png and /dev/null 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 index 9668240..88f2be8 100644 Binary files a/quarto/_freeze/pages/multiple_testing/figure-html/cell-8-output-1.png 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 index f6486e4..db45ad6 100644 Binary files a/quarto/_freeze/pages/multiple_testing/figure-html/cell-9-output-1.png 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 index f9507a0..10a10c4 100644 --- a/quarto/_freeze/pages/sklearn_users/execute-results/html.json +++ b/quarto/_freeze/pages/sklearn_users/execute-results/html.json @@ -1,10 +1,10 @@ { - "hash": "9cd73bbf1ba4532c113e9a9c119a29d0", + "hash": "9f3e516aeb66e02d354933c7d3e40713", "result": { "engine": "jupyter", - "markdown": "---\ntitle: \"scikit-learn Users\"\nsubtitle: \"A quick guide to comparing classifiers' predictions with CompStats\"\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.\n\n## Dataset and libraries\n\nThe first step is to load the digits dataset and split it into a training and a validation set.\n\n::: {#bbb251c3 .cell execution_count=1}\n``` {.python .cell-code}\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)\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=2}\n``` {.python .cell-code}\nm = LinearSVC().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 -- 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=3}\n``` {.python .cell-code}\nscore = f1_score(y_val, hy, name='Linear SVM', average='macro')\nscore\n```\n\n::: {.cell-output .cell-output-display execution_count=3}\n```\n\n```\n:::\n:::\n\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=4}\n``` {.python .cell-code}\nens = RandomForestClassifier().fit(X_train, y_train)\nscore(ens.predict(X_val), name='Random Forest')\n```\n\n::: {.cell-output .cell-output-display execution_count=4}\n```\n\nStatistic with its standard error (se)\nstatistic (se)\n0.9832 (0.0058) <= Random Forest\n0.9576 (0.0088) <= 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=5}\n``` {.python .cell-code}\nnb = GaussianNB().fit(X_train, y_train)\n_ = score(nb.predict(X_val), name='Naive Bayes')\nhist = HistGradientBoostingClassifier().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-display}\n![](sklearn_users_files/figure-html/cell-6-output-1.png){width=558 height=470}\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", + "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" + "sklearn_users_files/figure-html" ], "filters": [], "includes": {} 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-6-output-1.png b/quarto/_freeze/pages/sklearn_users/figure-html/cell-6-output-1.png deleted file mode 100644 index 401181f..0000000 Binary files a/quarto/_freeze/pages/sklearn_users/figure-html/cell-6-output-1.png and /dev/null 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/_quarto.yml b/quarto/_quarto.yml index 1f47f94..7e04c08 100644 --- a/quarto/_quarto.yml +++ b/quarto/_quarto.yml @@ -4,6 +4,9 @@ project: lang: en +bibliography: references.bib +csl: compstats.csl + execute: enabled: true freeze: auto @@ -15,24 +18,29 @@ website: navbar: logo: images/ingeotec.png left: - - href: index.ipynb + - href: index.qmd text: Home + - href: pages/install.qmd + text: Install + - href: pages/methodology.qmd + text: Methodology - href: pages/sklearn_users.ipynb text: scikit-learn Users - href: pages/competition_organizers.ipynb text: Competition Organizers - href: pages/multiple_testing.ipynb text: Multiple Testing + - href: pages/citing.qmd + text: Citing + - href: https://ingeotec.github.io/CompStats/dev/ + text: Developer docs right: - - text: "API Docs" - href: https://compstats.readthedocs.io/en/latest/ - aria-label: "API documentation on ReadTheDocs" - icon: github href: https://github.com/INGEOTEC/CompStats aria-label: GitHub page-footer: center: > - CompStats · [INGEOTEC](https://github.com/INGEOTEC) · + CompStats · Sergio Nava-Muñoz, Mario Graff and Hugo Jair Escalante · Code under the Apache 2.0 license format: @@ -40,5 +48,4 @@ format: theme: [cosmo, style.scss] toc: true number-sections: true - code-fold: 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.ipynb b/quarto/index.ipynb deleted file mode 100644 index 127db5f..0000000 --- a/quarto/index.ipynb +++ /dev/null @@ -1,165 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "970fe30e", - "metadata": {}, - "source": [ - "---\n", - "title: \"CompStats\"\n", - "subtitle: \"A bootstrap-based methodology for comparing algorithms in competitions\"\n", - "toc: false\n", - "number-sections: false\n", - "---" - ] - }, - { - "cell_type": "markdown", - "id": "404ab4a4", - "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/index.ipynb)" - ] - }, - { - "cell_type": "markdown", - "id": "9bde58bd", - "metadata": {}, - "source": [ - "::: {.home-lead}\n", - "Collaborative competitions are now a standard way to evaluate scientific and\n", - "technological progress: organizers define a task, participants submit\n", - "predictions for a held-out dataset, and the systems are ranked by\n", - "performance. The last step -- ranking -- is harder than it looks. **CompStats**,\n", - "developed by [INGEOTEC](https://github.com/INGEOTEC), gives organizers and\n", - "participants the statistical tools to do it rigorously.\n", - ":::" - ] - }, - { - "cell_type": "markdown", - "id": "a151494e", - "metadata": {}, - "source": [ - "Traditional statistical tests are routinely used to decide whether one\n", - "system outperforms another, but they often fail to capture decisive\n", - "differences between systems' performance, particularly when many\n", - "participants must be compared and ranked at once. Nava-Muñoz, Graff and\n", - "Escalante address this in [*Analysis of Systems' Performance in Natural\n", - "Language Processing Competitions*](https://arxiv.org/abs/2403.04693), which\n", - "introduces a bootstrap-based evaluation methodology and validates it on eight\n", - "NLP competitions spanning classification and regression tasks. `CompStats` is\n", - "the implementation of that methodology: it draws paired bootstrap resamples\n", - "of the held-out set, evaluates every system's predictions on the same\n", - "resamples, and derives standard errors, confidence intervals, and p-values\n", - "for the difference against the best system directly from the resulting\n", - "distributions -- without the assumptions a parametric test would require." - ] - }, - { - "cell_type": "markdown", - "id": "d9cc7eed", - "metadata": {}, - "source": [ - "::: {.pillars}\n", - "::: {.pillar}\n", - "### Off-the-shelf comparisons\n", - "\n", - "Follows the `sklearn.metrics` convention -- a score function takes\n", - "`(y_true, y_pred)` -- so evaluating a new system is a one-line change.\n", - ":::\n", - "::: {.pillar}\n", - "### Confidence intervals\n", - "\n", - "Standard error and percentile confidence intervals for every metric come\n", - "from the bootstrap distribution, with no extra configuration.\n", - ":::\n", - "::: {.pillar}\n", - "### Paired significance testing\n", - "\n", - "Every system is resampled with the same bootstrap indices, so the p-value\n", - "of a difference against the best system is valid by construction.\n", - ":::\n", - ":::" - ] - }, - { - "cell_type": "markdown", - "id": "da178386", - "metadata": {}, - "source": [ - "## Installation\n", - "\n", - "::: {.installs}\n", - "::: {.install}\n", - "### conda\n", - "\n", - "```bash\n", - "conda install --channel conda-forge CompStats\n", - "```\n", - ":::\n", - "::: {.install}\n", - "### pip\n", - "\n", - "```bash\n", - "pip install CompStats\n", - "```\n", - ":::\n", - ":::" - ] - }, - { - "cell_type": "markdown", - "id": "5283306c", - "metadata": {}, - "source": [ - "## Getting started\n", - "\n", - "This site is organized as one notebook per topic: [scikit-learn\n", - "Users](pages/sklearn_users.ipynb) walks through wrapping predictions from\n", - "several classifiers in a `Perf` instance, [Competition\n", - "Organizers](pages/competition_organizers.ipynb) shows how to rank\n", - "participants and report confidence intervals against a gold standard, and\n", - "[Multiple Testing](pages/multiple_testing.ipynb) covers comparing several\n", - "measures at once with correction for multiple comparisons. Every page,\n", - "including this one, is a real Jupyter notebook that can also be run outside\n", - "the site." - ] - }, - { - "cell_type": "markdown", - "id": "c908486b", - "metadata": {}, - "source": [ - "## Colophon {.unnumbered}\n", - "\n", - "As with the rest of the project, this site was built by the CompStats team\n", - "together with Claude, Anthropic's coding assistant, through [Claude\n", - "Code](https://claude.com/claude-code): the assistant helped set up the Quarto\n", - "site and draft this page, with the authors reviewing and validating every\n", - "change before it was committed." - ] - } - ], - "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.14" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} 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/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 index 516e88f..32a9244 100644 --- a/quarto/pages/competition_organizers.ipynb +++ b/quarto/pages/competition_organizers.ipynb @@ -21,13 +21,18 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "id": "e1d14076", "metadata": {}, "outputs": [], "source": [ - "# Colab does not have CompStats preinstalled\n", - "!pip install -q CompStats" + "#| 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" ] }, { @@ -35,7 +40,7 @@ "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 from the same paired bootstrap distribution, so the comparisons stay valid even when many participants are involved." + "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." ] }, { @@ -45,12 +50,12 @@ "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." + "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": 1, + "execution_count": 2, "id": "1c5370fe", "metadata": { "execution": { @@ -92,12 +97,12 @@ "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), so 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: one column per participant, aligned with the same gold standard." + "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": 2, + "execution_count": 3, "id": "7ac8d275", "metadata": { "execution": { @@ -133,12 +138,12 @@ "source": [ "## Ranking the submissions\n", "\n", - "`CompStats.metrics.f1_score` follows the `sklearn.metrics` convention -- `(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." + "`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": 3, + "execution_count": 4, "id": "2978cb04", "metadata": { "execution": { @@ -149,6 +154,69 @@ } }, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 0%| | 0/5 [00:00" + "" ] }, "execution_count": 8, @@ -450,7 +518,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -470,7 +538,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 10, "id": "984b6647", "metadata": { "execution": { @@ -484,7 +552,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 9, @@ -493,7 +561,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -516,12 +584,12 @@ "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." + "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": 10, + "execution_count": 11, "id": "bfb5a2c1", "metadata": { "execution": { @@ -535,7 +603,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 10, @@ -544,7 +612,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -564,7 +632,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 12, "id": "5c47a798", "metadata": { "execution": { @@ -578,7 +646,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 11, @@ -587,7 +655,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -630,7 +698,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.13.14" + "version": "3.13.15" } }, "nbformat": 4, 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 index df929d6..96f0ad9 100644 --- a/quarto/pages/multiple_testing.ipynb +++ b/quarto/pages/multiple_testing.ipynb @@ -21,13 +21,18 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "id": "5302df5d", "metadata": {}, "outputs": [], "source": [ - "# Colab does not have CompStats preinstalled\n", - "!pip install -q CompStats" + "#| 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" ] }, { @@ -35,7 +40,7 @@ "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." + "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." ] }, { @@ -50,7 +55,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "id": "cf911317", "metadata": { "execution": { @@ -88,12 +93,12 @@ "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 built with its `.measure` factory so 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." + "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": 2, + "execution_count": 3, "id": "bc6f40c9", "metadata": { "execution": { @@ -104,6 +109,53 @@ } }, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 0%| | 0/3 [00:00" + "" ] }, "execution_count": 6, @@ -410,7 +462,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -438,7 +490,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "id": "617dab24", "metadata": { "execution": { @@ -452,7 +504,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 7, @@ -461,7 +513,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -484,12 +536,12 @@ "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." + "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": 8, + "execution_count": 9, "id": "0c68902c", "metadata": { "execution": { @@ -503,7 +555,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 8, @@ -512,7 +564,7 @@ }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAADBsAAAOqCAYAAABnsLzfAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjIsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvgI3uAAAAAAlwSFlzAAAdhwAAHYcBj+XxZQABAABJREFUeJzs3QW4HdXVMOAdAUIS4ri7Q3F3L9riLsWlUFxLgQ8o7triUooVd4cCIQkhuLuFhAQiQALJ/Z+1v//c787NOdeSXEne93nOc0/O2D4zc2DWzF57tauqqqpKAAAAAAAAAAAAAAAA/1/70hsAAAAAAAAAAAAAAADJBgAAAAAAAAAAAAAAwARUNgAAAAAAAAAAAAAAAAokGwAAAAAAAAAAAAAAAAWSDQAAAAAAAAAAAAAAgALJBgAAAAAAAAAAAAAAQIFkAwAAAAAAAAAAAAAAoECyAQAAAAAAAAAAAAAAUCDZAAAAAAAAAAAAAAAAKJBsAAAAAAAAAAAAAAAAFEg2AAAAAAAAAAAAAAAACiQbAAAAAAAAAAAAAAAABZINAAAAAAAAAAAAAACAAskGAAAAAAAAAAAAAABAgWQDAAAAAAAAAAAAAACgQLIBAAAAAAAAAAAAAABQINkAAAAAAAAAAAAAAAAo6Fj8JwAwJRk+fHi655570jvvvJNGjhyZqqqq0jrrrJO23377lm4aTDWeeeaZdNttt+X3V155ZatfLwAAU4fRo0ene++9N73++utpxIgRafz48WnZZZdN++67b0s3Dajh0UcfTf/5z39Sp06d0oUXXtjo6QAAMKm8+OKL+dnEt99+m8aOHZs/O++881KXLl3sZAAAmIK1q4pehwBAvU477bT01VdfTfD5tNNOm3r16pUWX3zxtP7666eePXu2ir35xBNPpG222Sb9+OOPhc8POuigdOmll7ZYu6Dk/fffT+eff/4EO6Rdu3apa9euadZZZ00rrbRSWnXVVfNnbVX83g455JD8flJeek+u9QIA0HgXXXRRTvKubZpppkk9evRIiy66aFpvvfXSzDPP3Cp2b//+/dNmm22WBg8eXPh86623TnfeeWeLtQtK4tw8+eSTJ9ghERtOP/30qU+fPmmppZbKv6v495Ts73//ezruuONyB65Ro0Y1ejoAAK3PwIED01VXXVX2eneGGWZIs88+e342ssIKK6TW4Ndff03bbrttTlivbciQIfn6HFpaPHOMZ48NEbFknNPljBkzJr322mupb9++6d13382DM3Tu3LnsM00AgKmFygYA0ED//ve/01tvvVXnPPGA+9BDD02nnnpq7lTSUn7++ee044475kSDOeaYI+25556543bcpFxiiSVarF1Q09dff132ZnptCy+8cJ5vrbXWsgMBAGiV7r///vTkk0/WOU/EiHvvvXc655xzWnTUx3hIvtNOO+XO3NEhJNo055xzpvbt26f555+/xdoFtSs1NiRe7NatWzrppJPSkUceaQcCANBmfPTRRw263l166aXTNddck5ZbbrnU0gn2pUSD6KC9yiqrVCf9xuBR0Brcd9996dlnn23QvFEZrnayQVSNi/hy0KBB1ZU7Srp37y7ZAACYqkk2AIBGmm222fKNhpqjG8SoBv/6179y5/4YUe7TTz/N/27JqgZDhw7N7+Pm37LLLttibYGGiM5Oa6yxRqFjSZzHTz31VHrvvffSBhtskG/yrbPOOm1uh0abr7jiijazXgAAmi6SCM4999zC6I/RieTWW2/Noz3G9VuMshfXth06dGiRXT1gwID0wQcf5Pc33HBD+v3vf98i7YCG2nTTTXMljpLvvvsuvfnmm+nuu+9OI0aMSEcddVT+GwM/AABAW7PvvvumZZZZprqKcTzfe+SRR9KLL76YOz2vueaa6fnnn2/RZ32lZ56bb755uv3221usHdAQkZR+1lln1TlPVMqrLSpW9uvXL0077bS5qsiKK66Ynn766fT222/b8QDAVE+yAQA0Us+ePdP+++8/wecnnnhiWnvttdOHH36YbrvttrTHHnukjTbaqEX2b6lEZMeOHatvUEJrFokGtX9Xxx13XB6xJ0ZajU5aMT1u9MWIq23J4osvnl9tZb0AADRdjIxXLl7861//mhNoX3311VwB4eabb0677757i8aLIR6cQ2u3/PLLl/1dvfbaa2m11VZLP/30Ux74ITppRXVHAABoSyJW3GabbQqfxaBn0Vn62GOPzde7Bx10UHrppZdarI2lOFIMSVsQVTfKxZD12XjjjdOqq66afve73+WEgxCJ75INAABSals9tQCgFZt99tnTBRdcUP3vlqxsMGrUqOpRNdu1a9di7YCJ9ac//ak6aSduZkfnLAAAaGt69eqVrrrqqlYVL4auXbu2WDtgYkUHkEMPPTS/jwT1GP0VAACmFMccc0xabrnl8vuXX345V1Vv6ThSDMmUbJFFFskJNaVEAwAA/o/KBgAwCa2//vq5c3+UOX3jjTfKzhM3Ax977LH0ySef5NFIZpxxxjxKwlprrZU6dOhQcd0xasm4cePy6CaxndjG448/nl555ZX0zTff5PKp3377bfriiy9S//798zI///xzYeSGzp07p/PPP3+CdY8fPz6XY33hhRfyOqabbro077zz5k7e8bcuDWlXdBh/4okn0p133pm/42WXXZaX/eqrr9Jdd92VPvvss9SnT5+8fJSlrC32V6wvSsfON998adttt02zzjprne2K7/Hss8+mzz//PLcjqjzECIfrrLNOWnLJJetctlxbhwwZku6444700Ucf5f0TIyvGaBYNueH022+/5f0bo8589913uS1zzTVX3jerrLJKnctGh4kojxs3kmPZ2Pb888+fR9eIdUwNNtxww/Too4/m9/G7in0fjjzyyHyD+/e//33aYost8mfPPPNM3tdff/11WnjhhdMhhxxSWNeYMWPyeRHnUxzTGN1kwQUXTJtsskmabbbZGtSesWPH5t9K37598zGJ0WvjWMS5W2pbTdGmqHYSrrzyyorrff311/O88XuI39Qss8yS27TeeuvlZKamrjfEbyA63nzwwQdp9OjR+b87K620Uq7GMs0001Rc7r777ksPPfRQfoBw7rnnVq8rfgvx37L4b0rceI1jEOc1AACVxbViVMobPnx4xXgxrmMj/onrtpEjR6bevXvn6624Jqwr9oiqYLHeGBFz6623zp9FHBHXrbHOiOviuu+tt94qjMgX18s149BLL7207HVdxJhPP/10vhaM+eP6N7YVD+Lr0pB2HX744fn6/Nprr83TzzvvvJw4H/FfKQbr3r17WnPNNXPcXFtpfYMHD05zzjln3s4888xTZ7uGDRuWv09ce0dcGnF8XHvHNspd09dUrq0//vhjbut7772X98/SSy+dY5SYVp+Ix2Od//3vf/P+jbbE94i4Nb5vXZXdIm6IWLEUy8exi+8eMVTEOVODiKtLIv6vS9wjieMe5/P333+f45k4hyO+nnnmmRu0vV9++SWfc6V7FLGOOF4rr7xyTn6oJM61WO7LL7/MxyriyDhWcR9kgQUWaMQ3BgBgahLX9gMGDMjvI46sHevE84rnnnsuP6+IZx7xDCligbjGravq18MPP5zuvffefF164YUX5s/iOvXuu+/Ozy8jHt1uu+3S7bffXlgu4p533323+t8xz7rrrjvB+iM+i2cSESPFM4l4BhixbTyjqyu2bUi7TjnllHz9fthhh+Xr8y233DI/44nYKpbv169f3uaiiy6adthhh3zNXlM814lngB9//HHeXxEH1lepvhR7xTGIWPaHH37I8X1Ul49r+vqSMGq3NUTVw4gDIz6NmGLzzTdPCy20UGqIiGPjWWbp3kHsjzg34rjHYAd1ibgp7jvE9y8dm4hn4th4zgMAQEVVAECDLL744lXxv874W5fOnTvn+RZccMHC5999913V9ttvX9WuXbs8vfZr4YUXrvrvf/9bcb0dOnTI851zzjlVH330UdWSSy5ZWD7WvfTSS5ddd+nVvXv3Cdb7yiuvVC211FJl52/fvn3VbrvtVjVy5MiJaleI6fHvmD+ce+65VR07dpxgmwcccED1ur/88suq5ZdffoJ5unbtWnXvvfeWbc8nn3xStdxyy1Xcz/HaeOONqwYPHlzxO9Vu6z/+8Y+qTp06TbCeOMbvv/9+VV1uv/32qnnnnbdiW+abb76qN998s+yyd955Z9Xcc89ddrlo2/7771/1yy+/VLVVTz/9dPX3ueKKKyrOd+2111bPd9FFF1V/3rt37/zZCSeckM+VFVdcsbCPNtpoo8J6brjhhqrZZput7P6cdtppq4444oiqX3/9tc42X3/99VWzzz57xeMZv+M4B2u65JJLqqeXE+fiBhtsUHGdcS6vvfbaEyxX33rD2LFjqw477LCqaaaZpuL59+ijj1ZcPvZtzBf7Opx//vll1xW/+88//7zOfQcAMCVbb731CtdNlcT1V8w3wwwzFD4fMWJE1T777FM2RorXXHPNVfXQQw9VXG/pGjWuab/99tuq1VZbrbD8Wmutla+P64oX4/Xzzz8X1vv2229XrbLKKhXn32qrrXKsOzHtCjfddFP1Z0OGDMnX3eVisG233bb6mn3YsGFV66677gTzTDfddDmGKCeWWXXVVavj2HKvmF77mr6m2m29++678/GsvZ747v3796+qS1yLL7bYYhXbEut4/vnnyy772GOPVS2yyCIVY4gdd9yx6scff6xqq955553q73PyySdXnO/GG2+snu/MM8+sON9VV11VNdNMM5XdX3GuRewzbty4Ott05ZVXVs0888wVj1fcL/rmm28Ky8Q5ULqfVNexiv8GVBLfK+bt0qVLk6YDAND63HHHHdXXhPG+krPPPrt6vltuuaUw7dZbb62aY445yl5nRmz55z//uWrMmDFl13vaaacVriHPOOOMCe7913wGUel1wQUXFNYb8drRRx+d47Jy88czrwceeKDi921IuyJWCDFP/DuW+eyzz8o+I5111lmrBg4cWL3+Cy+8sGysGfHyTz/9VLZNp556alXPnj0r7oNevXpVXXfddRW/U+22xjOh2rFxvCJOPemkk+pcz9ChQ6t22WWXijFtPOuKZ0LlfP/991U777xzfvZbbtkFFlig6plnnqlqy+IeQ3yXiNsmlU033bTiM3YAgKmJ4UcBYBKK0QyjWkGIES1qjjCxxhpr5FE3YpTDTTfdNI8SEaMcxiiNt9xySx7dI0b/iJEsVltttYrbGDFiRB6NPLYTVQVi9PYYoTJGwouRNGJkvQceeCA9+OCDedT2mpUMYoSOmmLEjBgVJdYVI4lsv/32eRSO+Pf999+fR0K58cYb88iXMTJKrK8p7artH//4Rx6VPkYKie8cIzfec889eUT6K664Ilcv2HffffM+i30ao23GeqJqQywbn8VoJNGu2qO4xPePUV5i5JbVV189j04Zo7jHSCNRWSBGEozRVGKEjhjNsK7vFOLY7LPPPrkt0d4YnSTaGaO3xIghUd0gRqSvvW/DGWeckU444YT8Ppb7wx/+kEenjO8boxq++uqreV0xeuXiiy9eWDZGyIx9FGLU0D/+8Y951M/YvzESY4w6EqPZx8gjMVJLXaNdtnWxf0pq/q5KYjSYGOk15ttvv/3yaDVxPGpWfvjrX/+aTjvttPw+KkNstdVWeXpURoh9GdUOYp/HcYljW6lk8dlnn53fx8iqcUwWW2yxPFpOLBej5cQrzsH6RlItiUogMeJp/Nbivw0x4mtUHIiRZ2IUohj18qmnnsrnbWNFu2KUnDg/Qpx70ebYhzGi7a233prPn/jvUYxOFOdnXaLKR4w6G6P0xO82fjtRXSFGGYrRfGKfxuiedVVoAQCYmsX1WYygWPu6NuK4GEkxrqkiVogYLeKPuOaM68yoZhUjD8Yoh1EZLq7xKolRLeOaMmLPiGMizohr44iLYoTCuGaLa8u4FgyXXHJJYeTCmlWvIt6KmCoqE0S8EdeSEcdG9bW4ho64JOK4uLaMER7rGj2xrnbVFrHoXnvtlfdBjPgY80UMFxX04lo9ruMj1ooYIGKyUgwQ+/aaa67JI2juvffeeZT5iG9rilEbIwaLdUT8GtuPESDj2jviw/heMT2+d8R59Y0IGW3aZZdd8nbi+PTo0SO99tpr6eabb873AeJaO0b9jM9r++c//5nbHudFfMeIC5Zbbrl8DOJ4x/kQ19tRUSzaU9NNN92U9txzzzy65kwzzZQrDUYMHMcm4vzYh//617/S+++/n6sexKigU6rYRyURn5UTccwFF1yQ38e9itjXMXJo3FuIeCmO+emnn57jr+uvv77sOuI+x+WXX57fx3kRv4eoihCVDON3Gr+BgQMH5t9zVKkrifsY8RuJeCxivajSGMvHtuI3FPcF4ljFPYuI/abk2B4AgEn3fKTm86d4HhH39+NvxDwx4n1cW1588cU5Bot7+BFrVhLXyscff3yurBbxaCkOiqrs8cwuHHDAAflvVB6vWcmg5vPMeN4R0yNOLF2fR+W5qNj3zjvv5Dg0rp0jpo1nb/FMsi6V2lXzejvEc7N4bhHPKePaf+65587PPiI+jP0XlZnjGewNN9yQKwxELBjP++K5aMROEVNEde1YtvR9a4rnN1ElLdYTzypLceyHH36YY9SoTBDxWVzL77bbbnV+p3ieFW2NeODAAw/MlQyi6lo8i419E8+x4hnpHnvsMcGyNZ81h4hDo5JB7I+IaePziJ3jOVVtESdHXBltLj2njuM7wwwz5H0VxyamRdwe6yhXrQIAgKlcS2c7AMCUVNmg5gjsBx10UPXna6yxRv4sRlV/7bXXyo5EscIKK+R5YhT8cqOrl0ap6NatW9Xvfve7PIJiJTHqX32jLMSIlTE6Zmn0zVdffXWCeU455ZTq7/OXv/yl7Hoa2q5StYAYtS/mvfnmmwvTx48fX7XFFlvkeWK0wT322KNqiSWWmKACwRtvvJFH5oj5Dj300LL7ctCgQRW/91133VW9/FlnndWgtl599dUTzHP55ZdX75sYMb/cCJWl6goxEmjt0Q1LohpE7WnPPfdc9cgiUb2g3Mgzt912W/U8l156aVVTRFWE/fbbb6Je9Y2yMrGVDeK8iEoVtUesqVnZII5RVBSI6gblxCg5peWPOuqoqt9++22CeeIYl+apfW6WKlSUpq+//vp5BJhy3n333XwONrQCwQsvvFDndkv7IOZrbGWDqEJQmn7wwQdP8L0/+OCD6lGPevToUbbaR6myQYxCFCPvxHlXW4wsVNpOpYojAABTuoZUNojKBKXrpq233rr682222ab6muzZZ5+dYLlRo0ZVbbjhhtUjJpYbAb1UQSCujaN6QozqWElce1eqZFDzGrQ0KmRU74tr97rWEyOzl9PQdtWsFhDzxrVsbVH5IaZPP/30VYccckgeEfPjjz8uzBPrjzi4ZpW9mkaPHp2r+1Xy1FNPVVcpqBQD12xrbCtGpqwtqh2U5ikXdw4YMKB6dM64x1D7e5REjPPpp58WPovKeKWROKPSQ5wftT3++OPVI4meeOKJVU0VMffExIvlYvZJVdkgztEYPbQUd88///xlY72IYWqup1z1gpqx0z333FPnvZ7NNtus6ocffijb5jg2tad98cUXFSsixneI31HpO9QeqbZEZQMAgKmzskE8K4zr3NLzqtI9/LjeL11DRvWCcs8U47lVaZ5//vOfFSsIRAWEiPmiwnddKlUyqPTcbN99952gXVFBbp555snTI+4q90ynMe0qVQuIGDIqXw8fPrwwPWK/0jPMeEYS67vssssmWE/Es6Vtlqvc169fv4oV4ON5UKmKYMTrlaojlNoaMWQ8S639PCbiiIUWWijPE7FzxAq1laohRDuvueaaitWuo721xXOt0vPXctNj30WVv5gn4vimVlWPiu0T+9yxb9++VRNb2SDuG9S1jYsvvrjB61TZAADgf0k2AIBJlGzw4osv5htJpZt+/fv3z58//PDD1TfX6io/+eGHH1Z3Ho+OCbWVbojFut9+++0629qQZIOaD8tvvPHGivOts8461R1Mhg0b1uR2lTrwx2vPPfcsO0/c4KpZsrNS0sB2222Xpy+44IJVTREdHmL5SGaor6277rpr2XniRl8khsQ80Z7a4sZmTJtxxhnrTAyp62ZYJCmUu6FYEjfEYr64AdkUcXO05v5uyitudE+uZIO4KRodfErzxI3OmkrJBvF6+eWXK24nbtzGPBtvvHGd7YnOSDFfHLua4hhEMkNMiwSdcp276lJXUkB0jonP47cf33dSrTc62URyU0xbaqmlyna6CY888kj1Ov72t79VTDaIV3ToKiceGPTp06f6AQIAwNSovmSDSJqec845q6+tIvEgDBw4sPqzcomdJRFTlDonRAeOSp3664s7G5psUDMx4uyzz664rh122KH6erZch/mGtqtmB/5NNtmk7Dyff/55IRZ57LHHys4XnW1KHU7qiqcqKXXsjmvc+tq6wQYbVFzPyiuvnOdZc801J5hWSrSPOLtSokF9cUvEgeUS02vfF+jZs2fFeKA+pXOuqa9YflIkG0QCes2OIX/4wx/y/YDS9Ih93nrrrQnWEYkFpQ47kdTTkA4k6667buHz2HelgRpiXZU6D02MSD6qK2aVbAAAMPUlG0SsFs/SSvNEDFGy0kor5c/WXnvtOrex++67Vz8jqNSpP14R19WnvmSDiL1KiQTxPKXS846IC0vrOvbYYyeqXaV4JZ5TxsBedV3nx+uPf/xj2Xni2WZpnkoJwHWJxIFSMnl0tq+vre+9917Zea6//vrqdtR+3lozRo+B4pr6LC6eCVUSyful73HrrbdWNcURRxwx0c8dI+ZuqtLz1fpekSDSUJINAAD+1//VyAYAGiRK2++///7V/x47dmx6991300svvVT92YknnpiWW265/P7222/PfxdZZJFc6rOS+eefP5e8HDBgQHr66adzydNyoiTpoosuOtFH68EHH8x/o+zoDjvsUHG+Qw45JLcnypDG3z/+8Y8T3a6999677Ofx/aeZZpr066+/phVWWCEttdRSZedbeeWV83796KOP8ryxTGNEGdCLLroovf3227mkbJcuXSrOu++++5b9PErOlsqVRvnXmqL86SuvvFK9fJ8+fRrctu+++y49++yz+f1+++1XZ2nbbbbZJl111VXp/fffz+dlqXRrQ3Xq1KlsSdjG6N69e5oUokTra6+9Vv3vH374IT3//PP5e5XO0yh5W84SSyyRVlpppbLTYt+U1lvzd1tpf/773/9O/fv3TyNHjszlY8Nbb72VS+yWfg+lzyeFWWedNf8dP358Lm28ySabTJL1Dhw4sHrfxXkUZXHLiVLBUaY39lP8N+Hkk09u9G+hY8eOudzufffdN8FvAQBgahPxRc3rzt9++y3HLXFtO27cuPzZPvvsU33dV4oXe/funa9HK4mYYu21187XbBGXHXDAAWXnW2CBBeqMOxsbL0asVek6MPz5z39Ot912W76effjhh9OBBx440e2qFC/OOeecOeaJ69y55porx3WV4sWLL744jRgxIs87++yzp8aI9R533HFp6NChOd6bd955K85b175Zc80108svvzzBNXLE1o888kh+v+OOO9a5/tri/kNcd4e99torTTvttBXnjfPplFNOScOHD0+DBg1Kyy67bGqsiJsj5m6qxsbqlcR9kniVE/cz/vGPf6SuXbtOMC1iwYh1GhoPxnn/3//+t3CfoV+/funzzz/P7//yl7+k6aefPk1qcc7ddddd1fcRAACYulx99dX5+UDJ999/n58TDRkyJP874qBLL700v//iiy9S3759G3yNe8MNN6TXX389rzPizsbEYI0Rz1E+/fTT6jipUiwQcWE8+4s2xfX3mWeeWXGdDW3Xuuuum+abb76y0+LZUSm+/dOf/lR2nni22a1btxxDNuUZx0wzzZSWXnrp/Gwprum33nrrivNGXB/PZCrFkCXRjprPXCNeKD3XO+ywwxrVvtJ9h3nmmSc/E6ok4uwVV1wxx0Rx3yHi1caKcy7i/4lR6XlfY8TxPOuss+r8rgAANI5kAwBopHhQHx28y4kbRNFZd6eddqr+rPSweMyYMenggw/O7/93EJD/+1t6X7pxGDcLK4lO+JNCdDYIyy+/fJ0dAKITcc0H9ZWSDRrTrrjpVk50iI5O5YMHD06/+93vKi4/44wz5r/RoSVu/pW7Qfrzzz/nm2FvvPFG7sAfHTpK+/vbb7+tXj62VekmZKirHbPMMkv1OVFT3FCseeOwMWp2Lrj//vtzx4Zy50z8HTZsWPW8cc40NtkgOonXdzO6uUTnq3iVa+OWW26ZzjvvvDT33HM3+tyruT/jhurjjz9ecX9+88031edFdEpaeOGFJ/p41ic6QsWN6DhHt9hii5xkFN83bipHZ6qJ/X2HVVZZpc554zceHXBqLlNb/Ddi8cUXb/RvAQBgavPLL79UjBfjYfaxxx5buAYvXa/Gde+hhx5aNk4s/Y2kheaOF6NzQ10JxhFPRof36ARfM3l4csSLpVgwrtXrm6dmEnO5ZINo73PPPZe/Z8QBES9GHBAixiyJaXUlAzQlXoxONbH9psQXsWzEuiE6H5XOhXLxTWm+EPM1JdmgUmec5rbpppumzTbbLL+PRIDPPvssJ4pHon8ku8RxOOaYY+qMB2+66ab0n//8p+L+KiUUxL2biM9K582kigfjvHrqqadyJ6zo6BXHp7T90m87Yvw4N+pKIgEAYMpTem5RW1wXbrfdduncc89NM888c/6slGgQ4vq29Fyl3DVuXNeWxLVzpWSDSRFHNvaZRMQ2cW0cCfoRD09MuxoaH9b33DGu2SOGrCQGpXrhhRfSxx9/nOetmZhder5U+jsxMWRdzx1joLvoSN8YpbgoBkCo/Zy65vv4WxrEqq77DvU984pXS4sk8dby/BMAYEoh2QAAGik6dJ900kmFTrg9e/bMHXFLnZNrKt3MixERL7vssgZtY9SoUQ26MTYxSh3Va968Kic6Qrdv3z53vKjZub2p7YqEgroqCZRuKtZ1s6zmjcdyoyyeffbZ6X/+53/y6PQTs6/je5cbHbGklKRRuw0xAmZJYxMAat78LY1U0hB1fY+2IBJ0olJEiGoOnTt3zvsubpz26NGjzmXrOvdq7s+ontCU/Tkxx7M+0XHr5ptvTttuu2368ccf0x133JFfpc5oG264YR6xtL6b87XV/K3W9xsvVVeITi3xvcud81HNoa4qG5V+CwAAU5uIdaIjSM3rpLjmi0p3iy22WI4xyl2vRhJ0W4wX4/tFh5XoUDEp4sVQV3LDpIgXY9TQE044oXCd39Q4q662lq6Ro/PM5IgXo5LE1BIvRlJL7Y4iZ5xxRu54de+99+Yknui0U3uUzpr7K0Z0bYl4MI5/nG9RbSOSkRqy7RiEAQCAqUdUAojK3yHuw8c9+kh+jecjtSst17zGjQTciY0JIqGhsZ3XJ9UziXjuGJ37y1UHb0y7GhJDNjSOLBdDRpJBVCgsN2DW5Ighy7WjFJc0JSYpnTORQDAp7jsAADB1kmwAAI0UiQVNGQ0hRurYddddGzTvHHPMUXFaXVUIGiM6/ZdGsqhLjGRRGtWitMzkbNfE+utf/5pOO+206ptu66+/fpp//vlzh/XS6IAxamCpA1Bp9Mpy6upcXZea+6m+/VuXU045JSd7NER0XmqsGLGxNHpqU0X7Tj311DSxItGgqaOMNPTciySU2jfmG1JCdVIdz0o22GCDfE5ef/316aGHHkovvfRSHuUyRtb85z//mV+RcPCPf/xjgs5plTSmzTU7P1X6jTf1twAAMLXp1KlTk65rI3m9NMJgferqiNzc8WLN68m2EC9efvnl6aCDDsrvI0kiOqcvuOCCOc6fbrrp8udRcTDiyvrixaZeJ0+q+OKII45ICyywQIPmXXHFFZu0jcMOO6xBHeTr+j1ceOGFaXKI+P7GG2/Mgz5E9cIDDjggdwKqdK5FZ/+GnoelUWMnxfGKjmPXXXddfh9VMtZdd938N2LT0j2KGKX0mmuuadA5BwDAlCeeEWyzzTaNXi4ScCOWaYh4TtYcMeSkeibRWmLIGBggnl9FnBjPZ6IqdSSBREJFDJpVemZz0UUXpXfffXeyxJCNjdEriUoR8aypIUoJIY0Vg6hVqtTRUNHGpsawAABMPpINAGAyi4fUcROqqZ1OJpcYWTLaVV8pzCitWko2aGjH95YSlQzOOeec/D5uzN5yyy3VD+9rig7dNUcbndRqjtry2WefpSWXXLLBy9bs1BCj2cdN5sklRka56qqrJmodcYN6UiQbTC419+faa6/dpHLAtY/nnHPOmSa16OgUnYXiFcdl4MCB6bHHHssJBpF0cO211+a2N/S/ITVHjo3feF0JTPEbL43CG6VlAQBo3uvVN954I8dcrS1eDPXFiz/99FP1CJatPV6MThmR0B3WWWeddP/995etuvfqq69WJxtMDrXji6bGN0svvXSDBzRoqkh8Hj16dJOXj/07uZINSiOTRtWAQw45JFeTjPjpwAMPLLu/YiCCRRdddKKPV0M7c4VoUynRIJKJogNSuQTyqLZRSjYAAIC61LzGXX311asrRre02s8k6kqMLj2TiOd3dY303xpE0nI8S43k9KeffrpiFep4hjM5RVwSz4oaG0OWzpk4JpHAMbnvO8RgWhP73DHOa8kGAACtj2QDAJjMVltttfTmm2+m//73v2n48OGNejA9OS2//PLp7bffziPoRTnMKMtazlNPPVVYpjV7/fXXq0ddPOaYY8omGoR+/fpN1nbEzcboQBAjmDz88MNps802a9KyDzzwwGRNNogEmCuuuGKi1tHabwTH768k9mdTkg1qriOOZ9zonJzihm/cSI1XjM4ZVSuiRG50hmrojeCav9Vnnnmm4g3w6HD17LPP5vdN2TcAAEycuNZ84okncmz28ccfp/nmm69V7NK4noxY8IMPPkhfffVVmn322cvO99xzz1WPrNja48VPP/00fffdd/n94YcfXjbRoDnixUhGj1HtI1k+4ou99967wcsutdRSOXaPGD7im8mdbBCd4yMZuqmaYzTS2H9R3TCObQw+EJUEOnbsWDYebEqyQe148He/+12Dl33llVeq30dSRKVKdZP7nAMAYMpR+xq3tSQb1H4mEQne5USifUwPyy67bIOrObeU0jV9JC9Xes4SlarjOfDkPu7RlkGDBqVvvvmmUZUHYtl4FhzLR+JEzcSQSS0GgmtoBb5KVlpppUnWHgAAJh3JBgAwme2xxx55FIcxY8akk046KV166aWtYp9vu+226cYbb8wjUV522WW5c365UqbnnXdefh83n9Zaa63UmtUsHxqdL8qJhI+JHVWjPj169Eibb755uvfee9P111+fDjvssLTgggs2aNlevXpVLxujSB500EFpoYUWmiztjA4YrWn01MlhnnnmyedtdKi/5JJLckeUxlYmmGuuuarXEckZkQBQV6WASV3xIDqcRbJBKZGmIaITzeKLL57eeuutdPnll+eRPsslFN10003p66+/rv5vAgAAzWuXXXZJp59+eo69Iia74447WsUhiGvDs88+O3cEiapwF1xwQdn5zjrrrPw3KmRtuummqa3Hi9FJZHKOxF+Kw3baaaccl0bcFx0+GjpqY3Te33nnnfOyd911V+rbt+9k7Yjxpz/9KbV2kUQf8U7cb4mEkttvvz3v37DEEkvkTk/RsSbubey2226FkWAbYrHFFqteR5wbEVM2tHNOQ865GJn01ltvbVSbAACYesUI9xtttFF69NFH8/OK/fbbr1Ukrc8777xpueWWSwMGDMjxSiR4lxus6t///neuANZWnkmUrukrXc+XkrQjlpycIpaJuDzuHUQlvqjq1lC77757rtAQyx533HH52ePksvLKK+cXAABTntadJgwAU4C4qRIdSEJ06o+O5z/++GPZeaOM5dVXX51HpZjcoiNIaSTzeCh/2223FaaPHj06j5JYGo3j+OOPzw/xW7MYIbI0guHJJ588wX6Oh/i///3vK1Y8mJSiw1Dnzp1zMkdUJ3jxxRcnmGfs2LHpnnvuyaOF1vT3v/89dwyPZWO0lCeffLLsNuLGYHSAr33sKIpOJVHiNhJN1l133VxlpJw4HrGv77777gmmRUer6NgT64hj8uqrr04wTyQDRMeWUgnghojRYu+7776KN6offPDB6m01tmzs3/72t/w32hOjyQwbNqww/bHHHsudckI8jIjEKAAAmleM+BcxYrjzzjtzJ4AYabCcwYMHpxtuuGGC+GFyiM7VpeSB6DgRsWzta+eDDz64ekTKP//5z6lPnz6pNYvOL5EYHs4444zqKgc19+8f/vCHyd5JJJx44ok5sTg6rkQlvEceeWSCeWJadCB67bXXCp9Hx5KZZpopT49j9J///CcnhdQW1fJefvnldN1116Up3YEHHlhdqaKUAFMSHXLiPkEc3xhdNZIGyol4LvZ3VJSrLSomdOjQIZ8z6623XtlRSyN+j6SBmudVjNRaEp16ap9bsZ6NN954so4sCgDAlCeuT+P5U1RLi+vTUvXi2qJK2dNPP91sSe2lZxKl2CoGUaop2hLJESEGhWpMlbeWUrqmf/7553PCd+2YKxI+TjnllIrVACeVqLAW9wtCJAtEMkc8x60tKibWfma4zDLLVCeSX3PNNTl+imdd5URlw1h/PK8GAICaVDYAgGYQCQRxUy06EERHjbhRs+qqq+bR0eNhc9x4ixs3H374YZ4/pjWmBGZTtGvXLt9wWnvttfO2d9xxx3TmmWfmm07xkDw6QX///fd53ph26KGHptauZ8+eucNLjDb43HPPpbnnnjuPSB+dOCLRIG4GRqeMGMFj6623nqxtiVHlo6NB7LvYdpQpXWqppXJCRPj8889zx4K4off4448XKh8sssgi+aZljOoSxyY6t0cnpBgVJjpQROejOGfefffdNGLEiNzBZIcddpis36cti/0WxyKSZ+I3tvrqq+eR/+PmbIzAGp1Bvv3227w/o9N/jBT6xz/+sbCO6Oh/7bXXpr322iu99957ufNV/FbiOEcnnzjGb7zxRj4e/fr1a3DlgzhP40Z0JMDEiJnxu4+RNuO/C1GVoNSJJTpGHXXUUY363pFgcMQRR+Rki+g0E+uIZIvoYPX2229Xl/+NahrxsCEeTgAA0Pwi2TgSzm+55ZZcfS5GelxllVVyla7oHBLXqvHAP65Do1N57fhhconr34gX33nnnRxnRRwVo+hH0nMkGZSS5CO5+tRTT02tXSQPH3vssfkV1+5xfRydzyNGjGpfcW0eScoRJ0cH8Mkp4oVIct5yyy1zfLfJJpukhRdeOHdkiXZGvBjxQEyLamQRu5TMNttsuUN8VMSLWCZil6jGFjFLt27dcpJxnDPvv/9+fh/x0J577pmmZBHTROeZOEdff/31fO+ldAwj/ouKgzE9zuUYdCEqHkR8Hse7FA/GtLgXEp2fYt/WFL+DqBgXnXLi3Fl66aXzfo24MhJv4njFdiOejPXEOVWK7SMui0SieMU5FvcGIiaL4/PSSy/ldUQCSVuoIgEAQOsQz5kiboznT1HdK65XI56IZxZxnz/iiNIzj0hIiOdhzVFFIBKpTzjhhDwYVyQWRMwVyRBxvR5tiWToiGmj4kEM3BTxS2sXifXxTDcGN4tr+4gD4llOxOpxPR/PhuL7xjPViNsnp4hJYnCpGDQrkqojcWCNNdbIz5TimEeiQcSREXPUfmYYAwhE7BODX0WCRAxkEPcdIpaMxOt45hjrjjglxHOuxlYJnxLEs7m//OUvhc8iBixNq10tPs6POB8AAKYGkg0AoBlEh+YYoTxKh5577rn5hk90EKktOpNE+dPoPNAcYjTzvn375k7M0aEiHo7HqyRGpoyKBjHSZiQntAWxf2PEwUsuuSTf/IsbZyXRCSZGdSyVaJ3couNI3GyMzizR2bv2/o2ODTG6y0ILLTTBshtuuGEe0T4qNMRN1+gkX0pGKYkO6tE5Jm4oU7fogBMdPaITx7333ps7gMSrpqjcEedIpUSUqFASxyqOZ9woj+NTs8JB/M633377Rt2AjRvtgwYNyjeiY8TS2qOWxjkSN4WjskLckG/K7yEePET1kkhciUoaJfGbjkSVuCkdySwAALSMiF9uvvnm3Dk6EsAjMbRUMaCmiBMjTigXP0wO0WE6qoJFTBiJB9HpoNTxIETHkHgIH51JooN8W3DMMcfkZInYzzEKZMTpJdHRIjqlt2/fPMWA11xzzdyBI0a8j+oEkUwSr5IYjT+SEKLDUG2RWDBw4MCcuBzJCNHZPV61z6sYyKBUaXFKFyN7RuebOL5R3aBmwkgklEeCQcSDccwjqbt2dYLolBX7e4sttii7/n333Td3Iol4MH4XceziVRIDA8R2oqNPTdGJZ4YZZsiJRNG5J451iPMsYs8YnKJcZQsAAKivY/+AAQPyNW4kMteOJ0rPF+IZxHbbbddsO/N//ud/8nVzxImRCBHPY2o+k4hnoDFgWDyvaQuiM/4TTzyRqwpErB77PF6lZ6gRgxxwwAH5Gc/kFjFLxA7nn39+HmQq4ouaMW2IgQl22mmnCZaN54nxfCgSJ+J5UzxvLFdVPb5vHKP4OzUaM2ZMfpZfTiSa15621VZbSTYAAKYa7arK1VgGACYQHb5jVMDo8DuxN+bihl/clIpR7bt27ZofRseNmxjlo5J4AB0lOaMDRIyiV5f+/fvnV9xIbOgIhj/88EPuGB+jV8RNp2hLdGCIDgp1aWi7okN1rD8eqMdD+kqik02MBhgjN6688spl5/noo4+qkzXiBl908q4tqjK8+OKL+WZbVDaIDtfzzz9/nhYjupQ6XcdoLjG9KW2NjgVxUzFu8O22226pLlHZIhI7YnSRmD9KqkZnhxjBpT4xumKMQh+josTNrOj0E+dMjIAYHRraqhg9tJQMEh1tGjv6R3TaiJFEYiSZGJ2yoWIkn9ifMRJrVCWouT/LnUvlxDkUxz+Oa3QcieMZ51j8nmuLkWSiqkaoPepJSXSIif8mxMgx8RuMjkWRtBDfLdZfTkPWWxKX/JHIEJ3DolPVjDPOmEelLY24Wd85HvulVKK3nBdeeCF31onqIpFwAQAwtXnggQfytVx9100NEcnREZNE/BmxQ1yrxkj4dVUzaEgcVRLXnTHCethnn33qjflCrDtipLiGj/kjfo3tROxYl4a264MPPqju6LDHHnvkROByohNNxHiRcBFVu+qLM8rFeyEqkkWH8YgJIiaLWCTigdK0qIwWIjm3djJxQ9vamOv1iMdjlM9SPB7HO9pUru3lOkPEdXskF8eIlNHhJc6ZGNm0IfFmaxX7JAZFCFFZLl71iY78sQ+jE1P8DssdmxiUIOLBiOniXkbsq3jF/o57KA0RsXnESXHfIZJu4nhFPFhXtbg41+I3FN8r4rGoYhFxZO17HOXOqYjl4vyIpJ5yFRDqmw4AQOsTg5I99thj+X0klcfgYE0V9/zj+VNcc8aI+zWfeVS6Ro2BlOK6uKHXkFdeeWX+G6Pmlyp41/dMIuLaeB4a7Ys4JZ45zjLLLHUu15h2xcj+8X1jvXF9XU5UVCgl8++999752Us5USkintlGNeuoFlDu+0TbIp6O9xETR3J3KSYu3ROIZ6vRWb8pbY31ljqz1/fMLGKZaE/EEvEMMapmx4B2DU3iiLi2VH299Jw6Yt+JOQ9bg7gXEPcEGvLctpx4BhuDLTRUuXsGAABTKskGAAAAAAAAAAAAAABAQfPUhAYAAAAAAAAAAAAAANoMyQYAAAAAAAAAAAAAAECBZAMAAAAAAAAAAAAAAKBAsgEAAAAAAAAAAAAAAFAg2QAAAAAAAAAAAAAAACiQbAAAAAAAAAAAAAAAABRINgAAAAAAAAAAAAAAAAokGwAAAAAAAAAAAAAAAAWSDQAAAAAAAAAAAAAAgALJBgAAAAAAAAAAAAAAQIFkAwAAAAAAAAAAAAAAoECyAQAAAAAAAAAAAAAAUNCx+E+gZPz48enHH3/M77t3757at5ebAwAA0BaJ7wAAAKYcYjwAAACA5qP3NFQQiQa9evXKr1LSAQAAAG2P+A4AAGDKIcYDAAAAaD6SDQAAAAAAAAAAAAAAgALJBgAAAAAAAAAAAAAAQIFkAwAAAAAAAAAAAAAAoECyAQAAAAAAAAAAAAAAUCDZAAAAAAAAAAAAAAAAKJBsAAAAAAAAAAAAAAAAFEg2AAAAAAAAAAAAAAAACiQbAAAAAAAAAAAAAAAABZINAAAAAAAAAAAAAACAAskGAAAAAAAAAAAAAABAgWQDAAAAAAAAAAAAAACgQLIBAAAAAAAAAAAAAABQINkAAAAAAAAAAAAAAAAokGwAAAAAAAAAAAAAAAAUSDYAAAAAAAAAAAAAAAAKJBsAAAAAAAAAAAAAAAAFkg0AAAAAAAAAAAAAAIACyQYAAAAAAAAAAAAAAECBZAMAAAAAAAAAAAAAAECyAQAAAAAAAAAAAAAAUJnKBgAAAAAAAAAAAAAAQIFkAwAAAAAAAAAAAAAAoECyAQAAAAAAAAAAAAAAUCDZAAAAAAAAAAAAAAAAKJBsAAAAAAAAAAAAAAAAFEg2AAAAAAAAAAAAAAAACiQbAAAAAAAAAAAAAAAABZINAAAAAAAAAAAAAACAAskGAAAAAAAAAAAAAABAgWQDAAAAAAAAAAAAAACgQLIBAAAAAAAAAAAAAABQINkAAAAAAAAAAAAAAAAokGwAAAAAAAAAAAAAAAAUSDYAAAAAAAAAAAAAAAAKJBsAAAAAAAAAAAAAAAAFkg0AAAAAAAAAAAAAAIACyQYAAAAAAAAAAAAAAECBZAMAAAAAAAAAAAAAAKBAsgEAAAAAAAAAAAAAAFAg2QAAAAAAAAAAAAAAACiQbAAAAAAAAAAAAAAAABRINgAAAAAAAAAAAAAAAAokGwAAAAAAAAAAAAAAAAWSDQAAAAAAAAAAAAAAgALJBgAAAAAAAAAAAAAAQIFkAwAAAAAAAAAAAAAAoECyAQAAAAAAAAAAAAAAUCDZAAAAAAAAAAAAAAAAKJBsAAAAAAAAAAAAAAAAFEg2AAAAAAAAAAAAAAAACiQbAAAAAAAAAAAAAAAABZINAAAAAAAAAAAAAACAAskGAAAAAAAAAAAAAABAgWQDAAAAAAAAAAAAAACgQLIBAAAAAAAAAAAAAABQINkAAAAAAAAAAAAAAACQbAAAAAAAAAAAAAAAAFSmsgEAAAAAAAAAAAAAAFAg2QAAAAAAAAAAAAAAACiQbAAAAAAAAAAAAAAAABRINgAAAAAAAAAAAAAAAAokGwAAAAAAAAAAAAAAAAWSDQAAAAAAAAAAAAAAgALJBgAAAAAAAAAAAAAAQIFkAwAAAAAAAAAAAAAAoECyAQAAAAAAAAAAAAAAUCDZAAAAAAAAAAAAAAAAKJBsAAAAAAAAAAAAAAAAFEg2AAAAAAAAAAAAAAAACiQbAAAAAAAAAAAAAAAABZINAAAAAAAAAAAAAACAAskGAAAAAAAAAAAAAABAgWQDAAAAAAAAAAAAAACgQLIBAAAAAAAAAAAAAABQINkAAAAAAAAAAAAAAAAokGwAAAAAAAAAAAAAAAAUSDYAAAAAAAAAAAAAAAAKJBsAAAAAAAAAAAAAAAAFkg0AAAAAAAAAAAAAAIACyQYAAAAAAAAAAAAAAECBZAMAAAAAAAAAAAAAAKBAsgEAAAAAAAAAAAAAAFAg2QAAAAAAAAAAAAAAACiQbAAAAAAAAAAAAAAAABRINgAAAAAAAAAAAAAAAAokGwAAAAAAAAAAAAAAAAWSDQAAAAAAAAAAAAAAgALJBgAAAAAAAAAAAAAAQIFkAwAAAAAAAAAAAAAAoECyAQAAAAAAAAAAAAAAUCDZAAAAAAAAAAAAAAAAKJBsAAAAAAAAAAAAAAAAFEg2AAAAAAAAAAAAAAAACiQbAAAAAAAAAAAAAAAABZINAAAAAAAAAAAAAACAAskGAAAAAAAAAAAAAABAgWQDAAAAAAAAAAAAAACgQLIBAAAAAAAAAAAAAABQINkAAAAAAAAAAAAAAAAokGwAAAAAAAAAAAAAAAAUdCz+EwAAiqrGjUvjhwypuFvazzhjatehg90G9fBbAgCgJbkeBb8rAABoiHHjq9LQUWMqTu/TdbrUoX07O5Nm4XwEgJYn2QAAgDpFosE3y61QcfqsA/qlDrPMYi9CPfyWAABoSa5Hwe8KAAAaIhINVjrzyYrT+x63Xpq5Wyc7k2bhfASAlte+pRsAAAAAAAAAAAAAAAC0LpINAAAAAAAAAAAAAACAAskGAAAAAAAAAAAAAABAgWQDAAAAAAAAAAAAAACgQLIBAAAAAAAAAAAAAABQINkAAAAAAAAAAAAAAAAokGwAAAAAAAAAAAAAAAAUSDYAAAAAAAAAAAAAAAAKJBsAAAAAAAAAAAAAAAAFkg0AAAAAAAAAAAAAAIACyQYAAAAAAAAAAAAAAECBZAMAAAAAAAAAAAAAAKBAsgEAAAAAAAAAAAAAAFAg2QAAAAAAAAAAAAAAACiQbAAAAAAAAAAAAAAAABRINgAAAAAAAAAAAAAAAAo6Fv8JAAC0deOGDU/jh3yXxo/+KbXv0jm1n3Gm1KFXz5ZuFgAAAJOIuA8AAKDtGj56bBoyakwaPea31GW6jmnGrtOlnl2mbelmAQCUNVUlG4wdOzYNGzYsv59xxhlThw4dWqQdv/32Wxo6dGh+37t37zTNNNO0SDumFKNHj04jR45M7du3TzPNNFNLNwcAoEWMHzUq/XTX3Wn0TTenX995Z4Lp0yy6aOqy6y6p89Z/TO27dm2RNgIAANB04j4AAIC2a9SY39J/Bn6Vbun7WXr325ETTF9klhnSzivNnf6wzOyp63RTVZc+AKCVa5+mIk899VSaddZZ8+uDDz5osXa8+eab1e3o27dvi7VjSnHJJZfkfTnffPO1dFMAAJrd+B9+SD/89W/pm2WXTz8cf0LZRIMQn8f0PN9f/5aXAwAAoPUT9wEAALRdP/78azrl/rfSSmc8kU66982yiQYhPo/pMV/MH8sBALQGU1WyAQAATEl+++ST9N2mm6dR11yTqkaPbtAyMV/M/91mW6TfPv10srcRAACAphP3AQAAtF2fDh2dtrzshXTdi5+m0WPHNWiZmC/m3+qy/6bPvm/Y8z8AgMlJsgEAALTVDidb/bHJCQN5+S3/kP8CAADQ+oj7AAAA2naiwTZXvZg+/f6nJi3/yfej09ZXvpjXAwDQkiQbAABAGzP+hx/S0F12S+OHDp249QwdmobuunteHwAAAK2HuA8AAKDt+vHnX9Me17+Sho4aO1HrieX3vL5fXh8AQEuRbAAAAG3MiPMvbHJFg3IjZcb6AAAAaD3EfQAAAG3XhU+83+SKBuUqHMT6AABaimSD/2/06NHpl19+afKyI0aMmJTHZaK3MXbs2PTtt9/m17hx4wrTfvrpp/xqqlh25MiRTVo2lmvqsiH2wW+//dbk5QEA2rrxo0al0bfdNknXOfrf/87rBQAAoOWJ+wAAANquUWN+S7f3/2KSrvOOAV/m9QIAtISOaSoWHfhPP/30dP3116dvvvkmf7bwwgun/fbbLx1yyCGpY8fyu+fZZ59NDz30UHrsscfSJ598kn788cf8eefOndNqq62WDjrooLTllltOVNsmdhtPPfVU2mSTTfL7d955Jy2wwALpvPPOS1deeWX69P+PgjvPPPOkffbZJx111FFpmmmmqbM99913X/rnP/+Znnvuueq2dO/ePS222GJphx12SDvvvHPq3bt32WXvvffedNVVV+VlY5+HHj16pA022CAdffTRafnll69z23FsTj755HTnnXem4cOHpw4dOqSllloqt3vHHXesc1kAYOJVjRtf5/Rxgwfbzc1o9B13pqr/f001qVSNGpVGXX9D6rLN1pN0vTTut1Lfbw0AACaG2K7tEPe1HeI8AACmROPGV9U5ffCIpg3mOrW4c8CXafTY4sCwEysSDW586dO09bJzpKlNfedbfecrADDx2lVVVU01/8d95JFHqjvg9+vXLx1wwAGpf//+uaN9dOIvdaIP0RE+Oth36tSpsI6ofjD99NMXPotO96NGjSpUEIiEhejYX85rr72Wlllmmfz++eefT6uvvvok30bN7zpo0KDcMT8SFyKBYoYZZkg//PBDKh36rbfeOnfkr1RJIBIJHnjggerPpptuurxfau6vCy64IB122GGFZSOxYKeddsr7saRbt255u6XqBu3bt0/nn39+OvTQQ8tuP9q+/vrrp6FDh+Z/R6JBtD+2Hes5/vjj87+PO+641KVLl7yPJpVIbOjVq1d+P2zYsNSzZ89Jtm4AaEvGDhqUvvv9Zi3dDJjizfTQA2napZdu6WbAFEl8BwBiO2gJ4jyYPMR4ADB5vf7lD2mLy/5rN9Mm3HfQammpOXq0dDMAYIrWPk2lonN6jPD/r3/9K3dQj873X3zxRdpjjz3y9McffzwdfvjhEyzXrl27tN5666XLL788ffDBB+mnn37Ky/78889pwIABabPN/rcjXozkf8MNNzSpbZN6G9Eh//XXX0///ve/83eNjvNffvlldWWEu+66K79qGz9+fNpmm22qEw2igsHAgQNzMkS0JxIRXnrppfTnP/859enTp7BsJAJE1YFINJh22mnT3/72t/TVV1/lJIFY7u23305bbLFF3sZf/vKXXMWhtkhIiDZGokEkEkRiRSwbNxAHDx6cqyKceeaZ6cknn0xNFeuq9IrvCAAAQNsgvgMAAJhyiPEAAAAAWoeptrJBjJD/4osvphVXXHGC+WI0/khCiE7/7777blpooYUatZ3tttsu3XHHHWnRRRfNneobW9lgUmyj5neNKgmRpBDz1hRJAwsuuGBOPPj973+fHnzwwcL06667Lu211175/THHHJP+/ve/N7h9t912W042CPfff391gkRNcepFGx999NG0+OKLpzfffLMw/fTTT08nnnhifn/vvffm5IRyiRSRcBCaUtkgjnFDqGwAwNRMZQNoHka8hIkjvgOAuontoPmJ86DpxHgA0HJUNqAtUdkAACa/qbaywbbbbls20SCcffbZqX379rkz/I033tjodR9xxBH57zvvvJM78k8OjdnG3nvvPUGiQejUqVPeD+Hll1+eYPqll16a/84999zpf/7nfxrVvksuuST/jWSCcokGpZuEJ598cn7/1ltv5cSOmkpVGyIZo1yiQTjppJNS9+7dG9U2AAAAAAAAAAAAAADq1jFNpTbffPOK0+aYY45ceSCqAUT1g/qMHj06v8aPH5//PcMMM1RPi2SAWN/EmphtbLzxxhWnLbLIItUj90elg0hAKJUmHThwYH4fCQkdOzb8VBk5cmTq27dvfr/aaquloUOH5velIho1/9Zsd2yv1J5Y5oMPPqj3WEXVhvXXXz/dddddqSnie1fyww8/pPnmm69J6wUAAKB5ie8AAACmHGI8AAAAgNZhqk02WGihheqdHskGn3/++QTTxo4dm6655pp0++235w7yP/74Y8X1RKf9ppiU26grEaFm0kIkM5SSDeJ7l5ICllhiiUa1/dNPP03jxo3L70888cT8auxNw5r7vSHHqql69uzZ5GUBAABoPcR3AAAAUw4xHgAAAEDrMNUmG8SI+HXp3LlzdQf8moYMGZI22GCDNGjQoOrP2rdvn7p165amnXba1K5du9xJ/7vvvqtOGmisSb2NWKaSWFdJKbkgjBo1qvp9165dG9X+ESNGFG4E1rX9Su386aefGn2sAAAAAAAAAAAAAACYNKbaZIOaHeLrmh4d/Gs6/PDDcxLANNNMk4477ri0/fbb55H1O3b8v105dOjQNOOMMza5bc2xjfr06NGjydUZunfvXv3+4osvTrvsskujt1+z4kJDjxUAMHm071P3NcdMDz2QOsw8s93fTEbfcWca8fezJvl6ux13bOqyzdaTfL38n3GDB6fvfr9Zk39rAAAwMcR2bYe4r+0Q5wEAMCXq03W6Oqffd9BqaeZunZqtPW3NnQO+TOc89t4kX+/RGy2ctl52jjS1GTzil7TFZf9t8vkKAEy8qTbZ4M0330yrrLJKxelvvPFG/rvAAgtUf/bbb7+lO++8M78/4ogj0imnnFJ22c8//7zJ7WqObTTEfPPNlysNRNWEAQMGpL333rvBy84777w5UeLXX39N/fv3b1KyQWw/qjmMHz8+H6ttt9223mMFAEwe7Tq0r3N6JBp0mGUWu7+ZdN1zjzTykktTVa0KXBOjXdeuqeseu6f2jaxoRfP+1gAAYHJeb4rtWg9x35RDnAcAQFvUoX27OqdHooFkg8p2X3WedPkzH6bRY8dNsmPSdbqOabdV5sl/adz5CgBMvKm2N8sdd9xRZ+f1d999N79fe+21qz8fNmxY+uWXX/L7JZdcsuLyd999d5Pb1RzbaIjpp58+rbXWWvn97bffnkaOHNngZbt06VK97K233ppGjRrVpMoGyy67bH5/1113paqqqrLzRYWHp59+utHrBwBoqyIhoMsOO0zSdXbZfnuJBgAAAK2EuA8AAKDtioSA7Zafc5Kuc9vl5pBoAAC0mKk22eDxxx+vriBQU4zkf/DBB+f3nTp1Srvttlv1tB49euQR+8NTTz1Vdr19+/ZN559/fpPb1RzbaKijjz66OgFir732ypUKKhk3rpiNe9xxx+W/Q4YMyftwzJgxdW6r9vJhn332yX/feuutdNFFF00wPRIQDjnkkHrXDQAwpel2+GGp47zzTpJ1xXpifQAAALQe4j4AAIC267D1F0rz9u4ySdYV64n1AQC0lKk22SA6z++8887p+OOPT4MGDUqfffZZevDBB3Mlg+eeey7Pc+qpp6aZZ565eplpp502bb755vn9Nddckw444ID08ssvp88//zz1798/nXjiiWmdddZJe+65Z5Pb1RzbaKj1118/d+YPkZix4oorphtvvDFXffj000/TCy+8kK666qq8zy677LLCsuuuu251ssJ//vOftMwyy6Qrr7wyvf766+nLL7/MfyPh4/LLL09bbLFFWnrppSfY/p/+9Ke8zXD44Yengw46KPXr1y/vi0jE2HTTTXOFh1122WWy7wsAgNakfY8eqc9NN6T2ffpM3Hr69El9br4xrw8AAIDWQ9wHAADQdnWffpp03R4rpD5dp52o9cTy1++5Ql4fAEBL6ZimUtF5/aeffkpnnnlmftV22GGHpaOOOmqCz2OE/ddeey19/PHHufN8vGraaaed0t/+9rfcib6pmmMbjWnLDDPMkM4666zcpt13373sfNtss80En8UyM844YzrppJPSO++8kxMnKllggQUm+KxDhw7p/vvvTxtttFHednzfmt+5Y8eO6dprr01fffVVk78fAEBbFRUJZrrn7jR0193Tb5980qTlI9Gg4zzzTJb2AQAAMHHEfQAAAG3XPH26pDv3WzXteX2/9Mn3o5tU0SASDeaeRBUSAACaaqpKNphuuumqKxXE+1tvvTVXEYjR+j/88MPcef13v/td2m+//XL1gHLmmGOO9Oqrr6ZLLrkkPfTQQ3mU/uiMv/DCC6fddtstbbXVVmnEiBHV25l++uknWMc000xTPT0qGUyObdT8rvG9KollS/O1bz9hoYt27dql008/Pe2xxx65Y//zzz+fvv7667zO2WefPS222GJphx12SKuvvnrZ9R955JFp1113Tdddd1165plncgWJ0aNHp969e+ftLrLIImnDDTfM1RHKmWmmmdIrr7ySrr766nTXXXelTz75JO+LZZddNv35z3/Ofy+99NK8ri5dXFwDAFNhx5MH7ksjzr8wjf73v1PVqFH1LtOua9fUZfvtU7fDD1PRAAAAoJUT9wEAALTthIN7DlotXfjE++mOAV+mUWN+q3eZrtN1TNsuN0c6bP2FVDQAAFqFdlVVVVUt3QhojYYPH5569eqV3w8bNiz17NmzpZsEAC1i3Lffpm+WW6Hi9FkH9EsdZpmlWdvEhMaPGpV+uvs/afRNN6df3357gunTLLZY6rLrLqnzH/+Q2nftahe2AL8laDniOwBwPTolEPe1PuI8aBliPACYvAaP+CWtdOaTFaf3PW69NHO3Tg5DI0WiwT2vfZVu6ft5euebERNMX3TWbmnnleZKW/1u9pxwgPMRAFoLVyYAADAFiASCrrvtml/jhg1P44cOSeNHjU7tu3ZJ7fvMmDr0kjgJAADQlon7AAAA2q5IINhlpbnza/josWnoqDE5ASE+79N1utSzy7Qt3UQAgLIkGwAAwBQmEgskFwAAAEy5xH0AAABtVyQWSC4AANqK9i3dAAAAAAAAAAAAAAAAoHWRbAAAAAAAAAAAAAAAABRINgAAAAAAAAAAAAAAAAokGwAAAAAAAAAAAAAAAAWSDQAAAAAAAAAAAAAAgALJBgAAAAAAAAAAAAAAQIFkAwAAAAAAAAAAAAAAoECyAQAAAAAAAAAAAAAAUCDZAAAAAAAAAAAAAAAAKJBsAAAAAAAAAAAAAAAAFEg2AAAAAAAAAAAAAAAACiQbAAAAAAAAAAAAAAAABZINAAAAAAAAAAAAAACAAskGAAAAAAAAAAAAAABAgWQDAAAAAAAAAAAAAACgQLIBAAAAAAAAAAAAAABQ0K6qqqqq+BEQhg8fnnr16pXfDxs2LPXs2dOOAWCqVDVuXBo/ZEjF6e1nnDG169ChWdsEbZHfErQc8R0AuB6FyUGcBy1DjAcAk9e48VVp6KgxFaf36Tpd6tC+ncNAs3A+AkDL69jSDQAAoHWLRIIOs8zS0s2ANs9vCQCAluR6FPyuAACgISKRYOZunewsWgXnIwC0vPYt3QAAAAAAAAAAAAAAAKB1kWwAAAAAAAAAAAAAAAAUSDYAAAAAAAAAAAAAAAAKJBsAAAAAAAAAAAAAAAAFkg0AAAAAAAAAAAAAAIACyQYAAAAAAAAAAAAAAECBZAMAAAAAAAAAAAAAAKBAsgEAAAAAAAAAAAAAAFAg2QAAAAAAAAAAAAAAACiQbAAAAAAAAAAAAAAAABRINgAAAAAAAAAAAAAAAAokGwAAAAAAAAAAAAAAAAWSDQAAAAAAAAAAAAAAgALJBgAAAAAAAAAAAAAAQIFkAwAAAAAAAAAAAAAAoECyAQAAAAAAAAAAAAAAUCDZAAAAAAAAAAAAAAAAKJBsAAAAAAAAAAAAAAAAFEg2AAAAAAAAAAAAAAAACiQbAAAAAAAAAAAAAAAABZINAAAAAAAAAAAAAACAAskGAAAAAAAAAAAAAABAgWQDAAAAAAAAAAAAAACgQLIBAAAAAAAAAAAAAABQINkAAAAAAAAAAAAAAAAokGwAAAAAAAAAAAAAAAAUSDYAAAAAAAAAAAAAAAAKJBsAAAAAAAAAAAAAAAAFkg0AAAAAAAAAAAAAAIACyQYAAAAAAAAAAAAAAECBZAMAAAAAAAAAAAAAAKBAsgEAAAAAAAAAAAAAAFAg2QAAAAAAAAAAAAAAACiQbAAAAAAAAAAAAAAAABRINgAAAAAAAAAAAAAAAAokGwAAAAAAAAAAAAAAAAWSDQAAAAAAAAAAAAAAgALJBgAAAAAAAAAAAAAAQIFkAwAAAAAAAAAAAAAAoECyAQAAAAAAAAAAAAAAUCDZAAAAAAAAAAAAAAAAKJBsAAAAAAAAAAAAAAAAFEg2AAAAAAAAAAAAAAAACiQbAAAAAAAAAAAAAAAABZINAAAAAAAAAAAAAACAAskGAAAAAAAAAAAAAABAgWQDAAAAAAAAAAAAAACgQLIBAAAAAAAAAAAAAABQINkAAAAAAAAAAAAAAAAokGwAAAAAAAAAAAAAAAAUSDYAAAAAAAAAAAAAAAAKJBsAAAAAAAAAAAAAAAAFkg0AAAAAAAAAAAAAAIACyQYAAAAAAAAAAAAAAECBZAMAAAAAAAAAAAAAAKBAsgEAAAAAAAAAAAAAAFAg2QAAAAAAAAAAAAAAACiQbAAAAAAAAAAAAAAAABRINgAAAAAAAAAAAAAAAAokGwAAAAAAAAAAAAAAAAWSDQAAAAAAAAAAAAAAgALJBgAAAAAAAAAAAAAAQIFkAwAAAAAAAAAAAAAAoECyAQAAAAAAAAAAAAAAUCDZAAAAAAAAAAAAAAAAKJBsAAAAAAAAAAAAAAAAFEg2AAAAAAAAAAAAAAAACiQbAAAAAAAAAAAAAAAABZINAAAAAAAAAAAAAACAAskGAAAAAAAAAAAAAABAgWQDAAAAAAAAAAAAAACgQLIBAAAAAAAAAAAAAABQINkAAAAAAAAAAAAAAAAokGwAAAAAAAAAAAAAAAAUSDYAAAAAAAAAAAAAAAAKJBsAAAAAAAAAAAAAAAAFkg0AAAAAAAAAAAAAAIACyQYAAAAAAAAAAAAAAECBZAMAAAAAAAAAAAAAAKBAsgEAAAAAAAAAAAAAAFAg2QAAAAAAAAAAAAAAACiQbAAAAAAAAAAAAAAAABRINgAAAAAAAAAAAAAAAAokGwAAAAAAAAAAAAAAAAWSDQAAAAAAAAAAAAAAgALJBgAAAAAAAAAAAAAAQIFkAwAAAAAAAAAAAAAAoECyAQAAAAAAAAAAAAAAUCDZAAAAAAAAAAAAAAAAKJBsAAAAAAAAAAAAAAAAFEg2AAAAAAAAAAAAAAAACiQbAAAAAAAAAAAAAAAABZINAAAAAAAAAAAAAACAAskGAAAAAAAAAAAAAABAgWQDAAAAAAAAAAAAAACgQLIBAAAAAAAAAAAAAABQINkAAAAAAAAAAAAAAAAokGwAAAAAAAAAAAAAAAAUSDYAAAAAAAAAAAAAAAAKJBsAAAAAAAAAAAAAAAAFkg0AAAAAAAAAAAAAAIACyQYAAAAAAAAAAAAAAECBZAMAAAAAAAAAAAAAAKBAsgEAAAAAAAAAAAAAAFAg2QAAAAAAAAAAAAAAACiQbAAAAAAAAAAAAAAAABRINgAAAAAAAAAAAAAAAAokGwAAAAAAAAAAAAAAAAWSDQAAAAAAAAAAAAAAgALJBgAAAAAAAAAAAAAAQIFkAwAAAAAAAAAAAAAAoECyAQAAAAAAAAAAAAAAUCDZAAAAAAAAAAAAAAAAKJBsAAAAAAAAAAAAAAAAFEg2AAAAAAAAAAAAAAAACiQbAAAAAAAAAAAAAAAABZINAAAAAAAAAAAAAACAAskGAAAAAAAAAAAAAABAgWQDAAAAAAAAAAAAAACgQLIBAAAAAAAAAAAAAABQINkAAAAAAAAAAAAAAAAokGwAAAAAAAAAAAAAAAAUSDYAAAAAAAAAAAAAAAAKJBsAAAAAAAAAAAAAAAAFkg0AAAAAAAAAAAAAAIACyQYAAAAAAAAAAAAAAECBZAMAAAAAAAAAAAAAAKBAsgEAAAAAAAAAAAAAAFAg2QAAAAAAAAAAAAAAACiQbAAAAAAAAAAAAAAAABRINgAAAAAAAAAAAAAAAAokGwAAAAAAAAAAAAAAAAWSDQAAAAAAAAAAAAAAgALJBgAAAAAAAAAAAAAAQIFkAwAAAAAAAAAAAAAAoECyAQAAAAAAAAAAAAAAUCDZAAAAAAAAAAAAAAAAKJBsAAAAAAAAAAAAAAAAFEg2AAAAAAAAAAAAAAAACiQbAAAAAAAAAAAAAAAABZINAAAAAAAAAAAAAACAAskGAAAAAAAAAAAAAABAgWQDAAAAAAAAAAAAAACgQLIBAAAAAAAAAAAAAABQINkAAAAAAAAAAAAAAAAokGwAAAAAAAAAAAAAAAAUSDYAAAAAAAAAAAAAAAAKJBsAAAAAAAAAAAAAAAAFkg0AAAAAAAAAAAAAAIACyQYAAAAAAAAAAAAAAECBZAMAAAAAAAAAAAAAAKBAsgEAAAAAAAAAAAAAAFAg2QAAAAAAAAAAAAAAACiQbAAAAAAAAAAAAAAAABRINgAAAAAAAAAAAAAAAAokGwAAAAAAAAAAAAAAAAWSDQAAAAAAAAAAAAAAgALJBgAAAAAAAAAAAAAAQIFkAwAAAAAAAAAAAAAAoECyAQAAAAAAAAAAAAAAUCDZAAAAAAAAAAAAAAAAKJBsAAAAAAAAAAAAAAAAFEg2AAAAAAAAAAAAAAAACjqmFjJ69Og0YsSING7cuDrnm3nmmdM000zTbO0CAAAAAAAAAAAAAICpXbMmG7z44ovpkksuSc8880z69ttvG7RMv3790vLLLz/Z2wYAAAAAAAAAAAAAADRzssEpp5yS/va3vzXX5gAAAAAAAAAAAAAAgNacbPDkk09WJxr07t07bbfddmnppZdOPXv2TO3bt69z2fnnn785mggAAAAAAAAAAAAAADRnssF1112X/y611FLp6aefTr169WqOzQIAAAAAAAAAAAAAAE1Qd1mBSeTTTz/Nf0888USJBgAAAAAAAAAAAAAA0Mo1S7JB796989855pijOTYHAAAAAAAAAAAAAAC09mSDlVdeOf/98MMPm2NzAAAAAAAAAAAAAABAa0822H///XN1g4svvjj99ttvzbFJAAAAAAAAAAAAAACgNScb9OzZMz344IPp/fffT1tuuWX66quvmmOzAAAAAAAAAAAAAABAE3RMzWSllVZKb775Ztp1113TPPPMk1ZbbbW00EILpc6dO9e53BFHHJHmnHPO5momAAAAAAAAAAAAAABM9Zot2WD06NHpjDPOSH379k2//fZbevbZZ/OrPrvssotkAwAAAAAAAAAAAAAAmNKSDcaOHZvWXnvt1L9//+rPZphhhtSjR4/Uvn37OpedbrrpmqGFAAAAAAAAAAAAAABAsyYbXH311TnRoF27dumoo45K+++/f5p33nmbY9MAAAAAAAAAAAAAALQiY8aMSQMHDszvF1100dS9e/eWbhItlWzwxBNP5L+HHXZYOuuss5pjkwAAAAAAAAAAAAAA2YgRI9J3332X/0bH9tlnnz116tTJ3mkhX3zxRVpllVXy+4cffjhtvPHGjsXUmmwwbNiw/HfLLbdsjs0BAAAAAAAAAAAAAFO5b775Jl144YXpwQcfTG+99VZh2rTTTpuWW265tMsuu6Tddtstde3atcXaCa1V++bYyDzzzJP/jh8/vjk2BwAAAAAAAAAAAABMxc4777w033zzpbPPPjsnGnTo0CH3aV5mmWXSnHPOmcaNG5deeumldNBBB6WFFloo3XfffS3d5KlKVJVYaaWV8qtHjx4t3RxaMtlgxx13zH+ffPLJ5tgcAAAAAAAAAAAAADCVOvDAA9ORRx6Zfvnll5xgcN1116WhQ4emTz75JL366qvp888/T4MHD06XXXZZmm222XIFhKuvvrqlmz1VmWOOOdLLL7+cXyuvvHJLN4eWTDbYZJNNcomRKEPSr1+/5tgkAAAAAAAAAAAAADCViaSBK664Ir9fe+2106BBg9Iee+wxwej5vXv3zkkJ77zzTtppp51aqLXQunVsrg1de+21aa655krrrLNOOvjgg9P222+fFl544dS5c+fmagIAAAAAAAAAAAAAMIUaMWJEOvroo/P7WWedNd11112pW7dudS4T02+++eZ077331jnf+PHjc0WEYcOGpe7du+d+0dNMM02dy4wcOTK99dZb+f2SSy6ZunTpkt///PPP6dNPP03TTTddrrzQvn358eOHDBmSvvrqqzTTTDPlCgyN3c5PP/2UtxPrj+106tQpNdSPP/6Yvv766/Trr7+mmWeeOb/qU6kdY8eOTV988UWuLjHvvPPm7zNmzJg0cODAPH3RRRfN+7SSWD6qUowaNSr16dMnzTLLLHnfNcSkPG5jxozJ7Rg3blz+HlNDP/hmqWyw/PLLp2mnnTadccYZafTo0emss85Kyy67bN7x7dq1q/PVv3//5mgiAAAAAAAAAAAAANDGqxpEJ/lw7LHHpl69ejVoueizvNVWW5WdNnjw4HTIIYfkDvLRwXy55ZZLCyywQF73zjvvnD788MOK642qCqusskp+RQWFaNvee++dl11sscXS/PPPn5MIYlD3mh566KG0zDLL5G3G39lnnz2tvPLK6fXXX2/QdqJj/e6775569uyZFl988dyZf8YZZ0wHHHBAGj58eMX23nLLLbnKQ3Toj0oQ0call146d+6fb7750tlnn52TDxr6fSP5I6pHRBWJ2GfxHe6+++48byQflOZ96aWXyq7v1VdfTZtttlnq2rVrWmSRRXKf9FLSxFJLLZVOP/30it9nUh63n3/+OR122GH5e8S+XGKJJfJ6omJG7OspWbNVNgAAAAAAAAAAAAAAmFwefPDB6uSBXXbZZaLX98Ybb6SNNtooffPNN/nf0cF87rnnzv/+9ttv06233pruu+++9J///Cetv/769Y6Wv8Yaa+R1Ruf3GGU/OrJHp/g//elPuRP/fvvtlxMP9tlnnzxyf3Sojw77UZ2gb9++aZ111skd8KMNlfzwww9p1VVXTe+9916aY445cuLAxx9/nNdz5ZVXpmeffTY9/fTTZSsVRIJCjNof+y+SE6I6RKzvyy+/zCP6H3PMMemRRx5Jjz76aL3VAWJ70Y6oEBAJFdFJPyosNKRCQog2brLJJrmaQIjlIukhBr6Pag+xH+O10korTbDvJ+Vx+/nnn/N+j/0fSR8LLbRQ3hexX2644Ya8rUiWiIH5p0TNkmxwxBFH5B9CU0SpCgAAAAAAAAAAAACASsaPH59efvnl/D46hDe0qkFdneW33HLL3EF9+umnT1dddVUe9b9Dhw7V1Qeic/7QoUPTNttsk1577bU86n4l0VH/t99+y8kCUa0gfP/992nrrbfOCQAxPT6P6gMxiv6pp56aunTpkue7//778zZiFP2TTjop3XjjjXVu56effsrrXHPNNfNnY8eOTRdeeGGu9hAJDnvuuWduf23xfaLCwwYbbJCrB5RE9YCoInD++efnJIAzzzwz/fWvf61z/x199NE5MaBmOxrj0EMPzYkGCy64YLrtttvSsssuW5j+9ttv56SB2sd5Uh+3o48+Os/7/PPPp9VXXz1/FokhJ5xwQjrnnHPy8bziiitye6dE7aqqqqpauhHQGsV/GEv/AYr/OEcpGQAAANoe8R0AAMCUQ4wHAABAJdEhPEbjDxtvvHF6+OGHJ2pnRYf6448/Pr+Pzu7bb7/9BPO88MILuSN9dMeODvxRlaD29KhmELp165ZH+Y9qAzVF1YEFFlggr6Nr165pu+22S9dcc80E2zrooIPS5Zdfnjp37pzj45oj6dfcTlQcGDBgQFpyySUnWMeJJ56YkwZCU5IAouN9dLCP/Ryd+Usd+Mu1IyozDBo0KC288MJl1/Xhhx/mRIIQxyqOWbn4v9K+b67j1rVr1/T666/nahQ1xbKRABHJCiussEJ65ZVX0pSofUs3AAAAAAAAAAAAAABgYsTA0iXdu3ef6J158803579LLLFExc7uMdL9pptuWt2xPUa8ryQ6tddONAjzzTdfWnTRRfP7UaNG5coF5Wy22Wb5b1QtePfddytuJyollEs0CFHZoFQt4ZZbbkmNte++++a/Q4YMyYkTdYmkiUqJBvVp3/7/urj/8ssvLXrc9thjjwkSDUK7du1yZYQQSRVRtWJKJNkAAAAAAAAAAAAAAGjTYiT9krFjx07Uun788cf0zjvv5PebbLJJnfOWOq3//PPPudN5JWuvvXbFafPMM0/139L7SvOEb7/9tuK6Ntpoo4rTYpT+VVddNb/v27dvqm8fvP3226lfv37p5Zdfzq+oZlDy/vvv17n8+uuvn5oqkkWi2kM4/PDD01VXXVVIJmnO47buuutWnFZqY5xvUY1hStSxpRsAAAAAAAAAAAAAADAxevfuXf2+IR3T6xKd+auqqvL7+eefv855Sx3Ow9dff11xvllmmaXitOmnnz7/nXnmmeudp9RBvpKolFCX0vRybf3hhx/Seeedl/71r3+ljz76qN6O/XWplDTRUBdddFHafPPN87Hcf//904EHHpiWXnrptNpqq+UEgI033riwTybXcZt11lkrTitViShVnJgSNWuywXfffZeuv/769PTTT6cPP/wwjRgxIo0bN67OZZ588sl8YgAAAAAAAAAAAAAAVBq1f84550xffPFFev311ydqJ/3yyy9lKyaUU3N6zeVq69ix/m7bDZknlDrU19eecjp16lS2rV999VVac80108cff5z/3a5duzT77LPnJI5YZ/y7ZkWEX3/9tc7tdO7cOU2M3//+9+m5555Lp512WnriiSdyn/OBAwfm16WXXpp69uyZTjzxxFz5oKWPW33HpC1rtmSDBx98MO2yyy4546Ux6jsRAQAAAAAAAAAAAADWWmutdPPNN6fhw4en/v37p+WXX75JO6VHjx4NrpJQc3rN5VpKfPeGtLd2W4888sicaBDJCBdeeGHacccdU7du3QrzxOj9NUfzn9yiisEjjzySB7h/4YUX8uuZZ55JL7/8cv6eRxxxRBo7dmw69thj2/xxm6qTDT755JO0zTbbVGd9xA93hRVWyJkuHTp0qHPZ2WabrTmaCAAAAAAAAAAAAAC0YbvttltONggx+v3111/f4GWj0/q0006b388xxxy5UsKoUaPSq6++WudyAwYMqH6/6KKLppYWI/9vvPHGdU4PiyyySOHz++67L//9y1/+kvbbb7+yy3700UepJUTSQ1Q6iFd477330oYbbpg+//zzdP7551cnG7Tl4zZVJxtcccUVOdGge/fu6Z577klrr712c2wWAAAAAAAAAAAAAJhKbLDBBmnllVfOI9/feOONeXT+jTbaqN7l3n333Tya/5VXXpn/HYOpr7POOun+++/PnfBjFP2ePXtOsNyvv/5andyw8MILpznnnDO1tFtvvTUdc8wxqX379hNMe+2119Kbb76Z36+//vqFigXxCnV9h1tuuSW1BrGv99hjj3TqqaemIUOGpJ9//jlNP/30bfq4tVYTnkWTQSkz5KSTTpJoAAAAAAAAAAAAAABMFtGJPAZIr6qqSn/4wx9y5/u6RPWDVVddNX355ZeFzw899ND8d+TIkWnfffdN48ePn2DZGFH/k08+ye8PO+yw1Bq888476e9///sEn48ePTp/j9ClS5fcWb+kc+fOqVevXvn9vffem/ddbY8++mi6+OKLU3OIxIdobyXRvlL/9D59+uREg7Z+3KbqygaR/REiUwgAAAAAAAAAAAAAYHKYf/7500MPPZQTDb777ru08847p3PPPTdtvfXWaamllko9evRIQ4cOTW+88Ua67bbbcuf8Ugf8mtZbb73cWf3qq69Od955Z05IOOCAA9K8886bvv3223TttdfmDvilKgGljvwt7cgjj0wnnHBC7oy/0047pd69e+fKDRdccEF677338jznnHNOmmmmmQrL7bLLLjmZIL5TVIjYa6+90hxzzJH3VVQKuOmmm9Jf//rXdPLJJ0/27/D666/nAe7XXHPNXKkg2jHrrLPmag2fffZZTiB54okn8rwHH3zwFHHcpupkg/jRPvfcc3VmmAAAAAAAAAAAAAAATKzoYN6/f/90/PHHp3/9619p4MCB+VVOJB8ccsgh6bjjjptg2hVXXJG6du2aLrrootS3b9/8qm377bfPHdijI3xrsM022+TEiUgMuOuuuwrTOnTokE477bTc+b62M844Iw0aNCg9++yz6cknn8yvmqJiQFQEaI5kg2h/x44d0+OPP55f5cT+jjadeOKJU8Rxm6qTDXbfffd03XXXpUceeSRtuOGGzbFJAAAAAAAAAAAAAGAqNeecc+bR+E8//fTch/mll15KgwcPTiNHjkzdu3dP8803X1pjjTXSZpttlqaffvqy64iO6Oedd14e/T6qIES1gOHDh6cZZpghLbHEErlawoorrlixDd26dUsrrbRSfh+d3ytZaKGF8nyLL754xXmmm2666nX16tWrzu9+0kknpY033jhdf/316f3338/fY8kll0x77rlnxW1EB/9IMIhqAA888ED6/PPPU+fOndOCCy6Ydt1117TCCiukcePGVbdh5plnbvL3DZ06daqeNxI+aoq2Dhs2LL3wwgvp6aefTp9++mn65ptv0q+//porMiyzzDJp2223zW1ryePWs2fP6vni+EyJ2lVVVVU1x4YOOuignP0RJ2FkC0FrF/9RKf3HOP6DFf9BAACAKcW48VVp6KgxFaf36Tpd6tC+XbO2ifo5blNOfFc1blwaP2RIxentZ5wxtevQoVnbBEzZ/HcHAJhStMYYD6CljBs/Lg375fuK03t16p06tHePiSmf3wIApNwpPxInQr9+/dLyyy9vt9B2KhuESy65JGewbLDBBjnxYIcddkiLLLJIzngBAACgeUWiwUpnFkse1tT3uPXSzN06NWubqJ/jNuWIRINvlluh4vRZB/RLHWaZpVnbBEzZ/HcHAABgyhOJBpvcsV7F6Q9v+2SasfNMzdomaAl+CwAAk0/7SbmyyIJp165d2VeHDh3SySefnH766ad0zjnnpOWWWy6X26g0f+nVv3//SdlEAAAAAAAAAAAAAACgOZMNAAAAAAAAAAAAAACAtq/jpFzZEUcckQYPHjwpV5nmmmuuSbo+AAD4f+zdCZxd4/0/8G9mss+I7IIQa2KvPdTSaoKmtthiTWxdbEW1lKKlVWu1aOmCSlHETokWQWtfEtQSiRCyyL6aiezzfz2nv5l/jswkEbPP+/163dc5955znvPcc+8dbu7zeb4AAAAAAAAAAADUYtjgqKOOqs7mAAAAAAAAAAAAAABYgXbt2kXv3r2z9eLiYteK+hk2AAAAAAAAAAAAAACg9myzzTbx8ssvu+RUu4KoBZ9//nmUlJTE0qVLa/QYAAAAAAAAAAAAAACggYQN9thjj1hjjTVixIgRNXoMAAAAAAAAAAAAAADQQMIGAAAAAAAAAAAAAABAw1FvwwZLly7NloWFhXXdFQAAAAAAAAAAAAAAaFLqbdhg0qRJ2XKNNdao664AAAAAAAAAAAAAAECT0rwmGv38889jyZIly1UpSI+XlJRUeVzab8aMGXHbbbfF5MmTo2XLltGjR4+a6CIAAAAAAAAAAAAAAFCbYYM99tgjhg8fvtzje+6555dq56CDDooWLVpUY88AAAAAAAAAAAAAAICVKYh6avfdd4/rrruurrsBAAAAAAAAAAAAAABNTo1UNrjoooti2rRpFfcvvfTS+OSTT+LCCy+MHj16VHlcYWFhrLnmmrH11lvHpptuWhNdAwAAAAAAAAAAAAAA6iJscNBBB+Xu/+lPf8rCBunxHXfcsSZOCQAAAAAAAAAAAAAA1OewwRcNGTIkPv/889hkk01q43QAAAAAAAAAAAAAAEB9DxtsvPHGtXEaAAAAWKFZpQtjWsmCKF2wOIpaNY8uxa2iQ1FLVw1o8JbMnBVLp02NpaXzoqCobRR06RqFHTvUdbcAAAAAmqTZ82fHjM+nx+eL50Wb5m2jU5vO0b51+7ruFgAA1M+wAY3bokWLYsqUKdl6165do2VLA3UAAID6o2TB4njwjYnx91c+ifcnf7bc9s26rRHH9O4RB2+3bhS38jUZaDiWlpTEvPsfiNLb74hFI0cut73F5ptH0cBjo+2hh0RBcXGd9BEAAACgqShdVBqPf/ho3D/6nvhg1ujltm/aoWcc2nNA9Nt4/yhqUVQnfQSAxsZkTCt36623ZmN8v/a1r0W/fv2q3K+srCxefPHF+O9//xufffZZLF26NLbYYos48MADc/u9/vrrMWLEiJg9e3a2z/rrrx9HH310Nbya1FfVOopizpw52cDzpH379tG8efPlHv+ylm2H+undd9+N7bbbLlt/7rnnYvfdd6/rLgEAAMSczxfFtU+NjnteHx+lC5dUeUVSAOGih9+JKx4fGQN2XC/O6tsz1mzTwhUE6q2ls2fH3N9eG6V33x1lpaVV7pcCCLN/dkHM+fVlUXTkkdHu7LOioL0Z9AAAAACq09wFc+Kmt/4UD3/wQMxbPK/K/VIA4YpXLo3rh/82Dtr0kPje106Odq3W9GIAwJfUmCdjuu+++2LMmDG5x5o1axZFRUXRrl276Ny5c2y77baxzjrrrHKb1113Xbz11ltx0kknVRk2+PDDD+Pggw+Ot99+O/f4EUccURE2mDx5chx66KFZIGFZ3/jGN4QNGrlqHcXfp0+fGD58eLb+2muvxY477rjc41/Wsu0AAADAqvh4emkcP/jV+HhG1T/sfFEKJNz64sfx7KhpMfiEnaJHJzNLAfXP4rFjY/qxg2Lxxx+v8jEpkFByyy0x/+mno/Mdt0XzDTao0T4CAAAANBXj546LM546JcZ/Nm6Vj0mBhLtG3hEvTHwuru/zx+jebr0a7SMANBZNYTKmwYMHx2OPPbbS/dZee+046qij4vvf/3706tXrK583hQpS0KB169ZZ6KB79+5RUFCQVUMol8IKKWiQJpA/6KCDYsMNN4zCwsLYaKONoil79dVX4+mnn86u17nnnhuNkZIBfGUtW7aMddddN1tv1aqVKwoAANR50OCwP78Y00sWrtbxY2eUxqF/ejHu+8HXY4POAgdA/QoaTO1/SCydPn31jz/o4Oj60APRfMMNq71/AAAAAE0taHDS4wNj5vyZq3X8uLmfxImPHxu39Ls91mu3frX3DwAak6Y2GVOLFi3i7LPPrri/aNGimDVrVowdOzabxH3SpEnx29/+Nq6//vq44IIL4sILL8xCAJU58cQT49NPP42dd9650u2p6kH5hPK33357HHbYYcvtk6oaDB06NFv/3e9+F6effno1PdOG7z//+U+cf/75WfBC2GAVXHbZZTFz5v/+B3rjjTeu9PEva9l2qJ+22GKLmDBhQl13AwAAIOZ8viiraLC6QYNy6fgTBr8WD522W6zZpoUrC9SL2XrSP6KvbtCgop3p02P6wOOi66OPNJhZfAAAAADqm7kL5mQVDVY3aFAuHX/msFNj8Hf+Hu1arVlt/QOAxqQpTsaUJgG/4oorKt22cOHCuPvuu+Oiiy6KcePGxSWXXJIt//rXv1a6/xlnnLHCc6WKBuX22muvSvd55513VroPjVe1VjbYZ599vtTjAAAAUJ2ufWp0fDxjXrW0lSocpPZ+ccCW1dIewFeRygJ/mdl6VvaP6qm99r+82IsCAAAAsBpueutPMf6zcdVy7VKFg9Tej3f+qdcCAL7AZEyVBxEGDRoU++23XzY+e8SIEXHrrbfG17/+9fjud7/7pd9Dc+fOrVhfc801V3sfGq9qDRtUZeTIkVFaWprNgN+2bdtoCmbMmBGff/55tGrVKrp06VLx+NKlS7MqDx06dMhKZqxOG8n06dOzdNI666xT6bFlZWUxe/bsbL19+/bRrFmz1Xoe6Q/EkiVLsv5WJZVnmTJlSrbetWvX7A/ZipSUlMS8efOiY8eOVZZtqUp1PS8AAKDxKVmwOO55fXy1tnnv8Anx4316RXGrWvn6DFCppSUlUXr33dV6dUqHDIl25/4kCoqLXXUAAACAL/PvKotK4+EPHqjWa/bImAfj5O1Oj6IWRV4LAFiGyZiq1qlTp7jnnntiyy23jAULFsSvfvWrOO6446JFixa5/VIQIY3x/drXvhb9+vWreDxVR/j444/jpZdeqnjsqquuioKCghVWNrjxxhujXbt2FfdPO+20WGONNZY7Jo1xfuGFF2LMmDHx2WefRefOnWPnnXeOzTbbbIXv8T/84Q/ZOONdd901vvGNb2SPjR07Nuvnp59+Gt27d48jjzxyueM++OCDeOWVV7Lx1a1bt45NN900dtttt2y9Ks8//3x2S/ucddZZ2WPz58+PJ598MjtnmzZtsj6na/dFEyZMiDvuuCOee+65ivHNX6xGka7lueeeGw1drYyWGDhwYAwfPjxee+212HHHHaMpOOmkk+Lhhx/O3ujPPvtsvPrqq/Hzn/88nn766Wxwfhpk/61vfSsuvvji7AOxKm289dZb2R+DoUOHZiGEoqKi7ANVLr1RH3jggfjzn/+cvXnTGz5JH+K+fftmb9hddtllhf1ObTz44INx8803Z22Ut5/OlcIi6QOaXs9lww/vvvtubLfddtl6Omb33Xdfrt0PP/wwLr/88njsscdi8uTJ2WMpKJDa6d27d9buIYccUumHujqeFwAAkLdkadkKL8mUuf/7/+6G5L7hE6J04ZJqDzDc9tLHcej23aM+WNnrsrLXlfqjbMnSFW5f8n+hfkhK770vykpLq/c9WFISJYP/FkWHHeoiNxEr+7uysr9LAAAA1D9Lylb8XW7avGm11pem5NExj8S8xdVTYXfZAMM9798d+298QLW221Ss7L2+ss8KAPWTyZhWbuONN87G3/7tb3+LcePGZWOU991339w+1113XTb+OI1JXjZskMYJDxs2LLfvBRdcsNJzprHAyzr22GNzYYM0RjoNur/mmmtizpw5yx2fKjCkwEJlA/iTSy+9NAtH/PSnP40ddtghvve972WhijTZe9KnT59c2ODf//53/OQnP4nXX399ubbSpOhp7PaZZ55Z6bmeeuqpuOSSS7JqDSls8NBDD8X3v//9mDYt//8W++67b9x11125idtTUOP888+vuJ/6t+z9JE1KL2ywipZNsDRFKRyQBtKn5FB6o6W0Tqr08MQTT2Rv1PSBPeGEE1bYxr/+9a+sjVQRIL2p0wcgBQDKpdRP+vCkc5VL+6SB+rNmzcoCBCm4cPXVV8fZZ59d6TnShzq18c9//rPisVSJIiVzUpWFFBZJt5S0KU/wrIqUJkqlWsqDC+n41Ld0f+rUqfGPf/wju6X9vhgaqI7nBQAALG96yYIVXpYDb3jBZfs/V/1rVHZrKK/rOu3b1HU3WAVLp6/4x6+p39nfdaTGzb38iuwGFX+X1q28iioAAAD108zPZ6xw+6DHlp/xlfrrhhHXZjdq5rPSraibSwvQwMy7/4EamYxp3gMPRvGggdFYHHjggVnYoHzg/RfDBlU56qijsgnkR4wYkc3kn6SB8Wki8S8aNWpUNhA/OfXUU3PhgmXHiKeJ1Pfff/8s9JCkKgZpAvO0Txqc//jjj8eLL76YVRxIQYc0WXlV0uD973znO9n+aWLyNGF6q1atsooF5f76179m4YAlS5Zkfdp7772jR48e2fjk1Ic0UXoa75yqK/z+979f4fVIz+/QQw/NAhwHH3xwNnb6P//5T7zxxhvZGO60rfx5Jeutt14WiEiT0T/zzDPZdftisCCFDRqDWqlssOGGG2YXMg1Yb2rScz7++OOzJM21116bvcnTQPlUqeAHP/hBVrYjpW623nrrKqs+pDYGDRqUtZEG1ffq1Su3PbVXPiA/VQa48MILsza7du2abU/nOO+887LqAD/+8Y+zPhxwQD4JnT5o6YNQnlJKSaP0Idhqq62y+ynk8N5772XJnGWrGqyK9EFOH9z0wUrVCdKHOVV2SFK5kvRBu/POO7MPZnU/r5VJgYWqzJ49+0u1BQAAQN3x/Q4AAKDx8B0PAACA0tvvqLF2G1PYIM3+X+7tt99e5eNSpYPkD3/4Q0XY4Ne//nXF+N5l3XfffRVhgzR7f/fu3SttM1UQSAPyUyjg1ltvzQINy5owYUIWRkiVFtL44BRiaNmyZaVt3Xbbbdk44jTGePvtt19u+yuvvBInn3xyNv758MMPj5tuuimbzH3ZsMLFF18cv/rVr7LnmCZNr2qM8fz587Pr8ctf/jJ7fmlS9XJnnXVWVh0ijYNPk8yndpIUakgVHH7zm99k29Ix6X5j9P+vRg064ogjsmVKpDQ177zzThYOSLPvl6dpUnplr732yj5Q7du3z97oKyqTkdpIYYT0Qf1i0CBJAYDymf/TwPtUxqR8QH6Szps+6Cnhk6QB+l80ePDgiqDBz372s7j99tsrggblFQ5SGCKVNTnmmGNW+fl/+umnWf+T3/3ud1kJlmX/EHXu3Dnr1x133LFcSZTqeF4rk6okVHXbaKONvnR7AAAA1A3f7wAAABoP3/EAAACatiUzZ8WikSNrpO1F772Xtd9YLDuudubMmXXWjxQcuOWWW7L166+/frmgQZJCCmk8cIsWLbJKB2kMcFWmTJmStVdZ0CBJoYBFixZlY5vTeONlgwZJGvyfwgPlY4zTZO9VWbBgQTaRehqnvGzQILniiiuysd5JeeCiqamVsEFKcRx99NHxxz/+MUtvNDWXXXZZpUmf9KFJKZ4kXZdx48ZV2call1663Bu4XHlpj/322y8bzF+ZFHC46KKLsvVUoWDkF/4I33DDDdlygw02yD5c1WXx4sW5wMKXUR3PCwAAAAAAAAAAAICGY+m0qTXb/vRp0Vi0adMmCgsLs/W5c+fWWT/+/ve/Z9UE0sD8E044ocr90kTgu+22W7ZeXlGhMqlyQKqCUNVE6OXj0dM47PLnX5lBgwZly5deeilKSkqq3K98PPcXtW7dOvbYY48vXTmiMVl+BHwNSeUw0uD6NGg8vXCp/EWayT69qVb0Ijd0KSmz++67V7k9leS45JJLKt7I66+//nL7pGu0yy67VHr8Z599Fq+99lq23rt375g8eXK2nkqHfHG51lprVRz35ptvxuabb15RhjTdT1Ipkep8PdZbb73o0KFDdo4zzjgjbrzxxujTp0+VwYnqfF6rYkUprtmzZ6tuAAAA0ED4fgcAANB4+I4HAADQtC0tnVez7ZeURmORZuVfsmRJtr7GGmvUWT/SGOikXbt2cd111+XG+i67npZz5szJ1seOHVtle7vuuutKz5WMGDFihWOMP/nkk4rJ0ydMmBCbbbZZpROfpwoJVVl33XXrvHJEow8bpBdg+PDhFfdvuumm7LYq0oDzFb2A9d0mm2ySvQmr0rNnz4r18ePHV7rPxhtvXOXxqYxI+R+Jn//859ltVSz7hk8VFco/WFtttVVUp/TcU2WHU045JcaMGZNVuejUqVOW8knJpBQ82G677Wrkea2KFIQAAACg4fP9DgAAoPHwHQ8AAKBpKyhqW7PtFxdFYzF16v+vAtGxY8c668ekSZMqxiSfc845q3RMeeigMt26dVvpuZLf/e53q9zHqs5XXFwcLVq0qPK4Vq1aVQQ7mqJaq2zQVKXyJCvStu3//4NYWlp5UqqoqOo/asuWPEmD+FO5jlWx7H7LlgVZ0blW18knn5ylpX71q1/FqFGjYsaMGfHQQw9ltyRVIrj88svjoIMOqtbnBQAAAAAAAAAAAEDDUtCla82237lLNBbLTga/5ZZb1lk/UuWAZNNNN41DDjlklY5ZZ511VjrAf0XnSk4//fRVHvtc1fkKCgpW6fimqlbCBj/+8Y9jypQpq3Xs+uuvHw3ZsoPmKzN79uyK9TXXXLPSfVZUGWHZY6699to49thjv3Qf27dvX7E+a9asqAnHHHNMdhs5cmQ8++yz8cILL2TLiRMnZo/1798/7rrrrjjyyCOr7XkBAABV61xc9Rfz5JHTdou12jWsMO99wyfE1U+MqvZ2z923Vxy6ffeoD6bMnR8H3vBCldtX9rpSf6zsHzC7Dn00Ctdaq9b6Q/1Weu99MfeKK6u93XbnnxdFhx1a7e1SPy2ZMiWmfmf/JvHDCgAAQFPRsU2nFW6/bb+7o0tb3/eq26NjHokb3riu2ts9bfuzYv+ND6j2dpuCafOmxaDH/jfmaHU+KwDUP4UdO0SLzTePRSNHVnvbLbbYImu/sXjssccq1vfcc88660eXLl2yCcnTmOQrrriixs9V7oQTTojtt9++Rs/X1NVK2OCoo46Kpip9cBYuXBgtW7asdPvbb79dsb7JJpt86fY33HDDrO10jldffXW1BuVvtNFGWQIolfd4/fXX47vf/W7UlFTFIN1OOeWUKCsri3/+859ZwCCFMi655JKKsEF1PC8AAKBqhQVVh5qTFDRoaGGD476+Qdz47JgoXbik2tosbtU8Bu26QbZsDK8r9UezwhXPjpGCBoUrKA1K01J8wvHx2e//EGVVVMVcHc2Ki6P4+OOioLi42tqkcf9dAgAAoP4pbLbi73IpaNClbc3OCtwUDdj8qLj17Zti3uJ51dZmUYuiGLDZkdmS2v+sAFA/FQ08Nmb/7IIaabexmDBhQvz973+vmLW/b9++ddaX3r17x/PPPx8jRoyI6dOnR+fOnWv0XOWeeOKJOg0bNFvBhPKNhf+TqmFpAP8jjzxS5fYhQ4ZkyxYtWsTXv/71L91+Kv3xjW98I1tPlQFWVkmhMm3atIlvfvOb2fo999yzWm2s7gesX79+ceKJJ2b3P/jgg2p9XgAAQNOSAgEDdlyvWts8fIfuDSZoADReKRBQ9H8TNFSXoiOOEDQAAAAAWJ1/V2lRFAdteki1XrsDNzlY0AAAvqDtoYdEs6LqDeKlyZjaHnJwo7jWJSUl2QTfn3/+eXb/vPPOyyYeryvlk40vWbIkfvnLX9boudLk7jvuuGO2ft1118XMmTOjrrRt27bieacx442RsEEtSB/gyt7IL7/8ctxyyy3Z+oABA6Jjx46r1f7PfvazbJmSQIMGDYr58+evcP9FixYt99i5556bLWfNmhXHH398pfuUW7x48Sr3bVX2/eijj7Jl165dq/15AQAATctZfXvGhp2q5x+cUjupPYD6oN3ZZ0XzDTeslrZSO6k9AAAAAFbP9752cqzfrke1XL7UTmoPAMgzGVPlysrK4tFHH42ddtopXnjhheyxww8/PE4//fQ6fQulwf9HHXVUtv773/8+LrnkkirH9abHn3322Zg4ceJqn++qq66KgoKCmDx5cnz729+OsWPHrnCc8n/+85+oCRtssEHF+uuvvx6NUZ1Oz5gG4M+ePTubWb9Tp07RsmXLaGx23XXXbFb+VLLjF7/4RbZMg+aHDh0av/71r7MPTIcOHeLKK69c7XOkqgTnn39+XH755fHwww/H1772tfjhD3+YVUpIAYZ0nadMmZJVDvjnP/8ZH3/8cbz33nu5Nr71rW/FWWedFddee208+OCDscMOO2T3d95552jdunVWauXdd9/NqgykP0pnnnnmKvUt/TE44YQTsg9yqlSw3nrrRbdu3bJtqR+DBw+uqPxw0kknVfvzAgAAmpY127SIW4/fKQ7784sxvWTharfTubhlDD5hp6w9gPqgoH376Hz732Jq/0Ni6fTpq99O587R+Y7bsvYAAAAAWD3tWq0Z1/W5MU56fGDMnL/6M+l2bN0xru/zx6w9AKCS/+aefVbMf/rpWLyCgeSNcTKmNLb4iiuuyN2fM2dONqD+xRdfzAbYJ82aNYszzjgjG4Oc1uvaTTfdFOPHj4/nn38+Lr744vjzn/+cjR/u0aNHLFy4MBvzmwIG6TmksdXPPPNMrLvuuqt1rr322iv+8Ic/ZOOKX3vttejZs2f07ds3tt1226zawNSpU7PzvfXWWzF69Og44ogjYs8996z257znnntGu3btsudz2GGHZRUe0uTr6fVIYYjyyeAbsloPG7z00ktx/fXXx7Bhw2LatGkVj6egQRrgftxxx2Uz69dlKY/qlJ7XPffcE/vss08MHDhwue2dO3fOEkar+2Epd9lll2VvzlQNIH0o0oenKptuummlj//2t7/N3vCprbfffnu5wf/lypNHq6JFixZZUOHmm2/OblVJlQsuuuiiGnleAABA07JB56K47wdfjxMGvxZjZ5SuVkWDFDToUU0VEgCqS/pH8K4PPRDTBx63Wv+ono5PQYPmy8ywAgAAAMDqWa/d+nFLv9vjzGGnxri5n6xWRYMUNOjebj0vAQBUoalOxpQG5qfJuqtSXFycTRx+6qmnZhUF6ouioqJ4+umns0nG0+TnkyZNiltvvbXSsdUpLNC9e/evdL5TTjklNt9882xAfwocpInL0+2LNtlkk2wC9Jp6zrfccks2/j2FQNLzLldYWChs8GXLdpx99tm5i/jFD0YKIqTbjTfeGA888EBsvPHG0RhsscUWMWLEiKwsSApZpKRMGkC/9957Z4miFDioTHo8hRC6dOmySudJlQiOOeaY+Nvf/pZVFPjkk0+itLQ0qxqx1lprxWabbZaFHqpK5qQUTSpbkt7w6cP93HPPxaeffhrNmzfP+pGeR0rcpGoNX/zQl4clvhgSSdUMUtjgiSeeqOhT+uOxZMmSrE/bb799HH300cu1WZ3PCwAAaJqBg4dO2y2ufWp03Dt8QpQsWLzSY4pbNY/Dd+geZ/XtqaIBUL8DB48+EnN/e22UDhkSZSUlKz2mWXFxFB1xRDZbT0P5R3QAAACAhhI4GPydv8dNb/0pHhnzYJQuWvkEOEUtiuLATQ6O733tZBUNAGAVNKXJmFKAYKuttlpubG+bNm2yycTTeOI0c38aN5sGsq+KE088MRsLvPPOO1e6PU0U/9Of/jRbTzPxVyadr3yf1I+VTVL+85//PBtknyoY/Pe//41Zs2Zl1QbSmN8UMEhjhtMg/cqkSck/++yzVQ4HpP1effXVGDVqVLzwwgvZc128eHE2Tjudb7vttouNNtqo0mN333337Hml67siffv2jdatW1c53jtVNOjTp088+eST8cEHH2RjnJcuXbrKr1F916wspQBqQXoxrrrqqoo3Urrw6Q2aBozPnz8/xowZE48//nj2IifphR0+fHi0b6A/gPbv3z8efvjhbLB9GiBPw5P+uHXs2DFbnzlzZnTo0KGuuwQAANVmytz50fvyYVVuf+X8PrFWu9aN4oqnoMFDb06Mv78yLkZOmrvc9s3XbhfH9F4/+m+7bhY4qM+a0uvW2L/fLZk8OSbtsFOV29ce/loUdutWq32i4VlaUhLzHngwSm+/Ixa9995y21tssUUUDTw22h5ycBQUF9dJH6k//N0BABqL+vgdD6CuTJs3Nfrd26fK7Y8fPiy6tO1aq31qylLQ4PGPHosHRt0To2eNWm57zw694pBeA6LfRvtlgQOqj88CQNOwdPZskzFBHaiVURSjR4+Oa665JltPIYO//vWvsd56y5cAS7PdX3/99XHOOefERx99lJXRuPLKK2ujiwAAADRSKUBwbO8e2W1W6cKYXrIgCyCkxzsXt4oORS3ruosAqyUFCIoHDcxuS2bOiqXTp8XSktIoKC6Kgs5dorCjQVcAAAAAtSUFCA7rNSC7zZ4/O2bOnxHzFpVG2xZF0bF1p2jfumFOuAoA9UWq3tz+lxdHu3N/YjImaGxhgzvvvDMLEqTSHUOHDs0qG1QmlYv40Y9+lC3PPPPMuOOOO4QNAAAAqDYpWCBcADRGKVggXAAAAABQP6RggXABANQMkzFB7SqojZO8/vrr2fKss86qMmiwrJNPPjnWWGON+PTTT2PixIm10EMAAAAAAAAAAAAAoKFIEzG16NkzWm2/XbY0MRM00LDBzJkzs+Wmm266Svu3bNkyevToka3PmDGjRvsGAAAAAAAAAAAAAADUQdiguLg4W06bNm2Vj5k+fXq2TBUOGqLOnTvHuuuuG126dKnrrgAAAAAAAAAAAAAAQP0LG2y22WbZ8o477lil/YcNGxaTJ0/OQgrdu3ePhujmm2+OCRMmxL333lvXXQEAAAAAAAAAAAAAgPoXNjjkkEOy5X333RdXXnlllJWVVbnvO++8E8cff3y2vv/++0eLFi1qo4sAAAAAAAAAAAAAAMD/aR614Jvf/Gbss88+8cQTT8R5552XzfY/cODA2H777aNDhw6xYMGCGDNmTDz++ONx5513xqJFi6JNmzZx8cUX10b3AAAAAAAAAAAAAACA2g4bJHfffXf07ds3RowYEcOHD89uVWnbtm22f69evWqrewAAAAAAAAAAAAAAwP8piFqSKhi89NJLcemll8baa69d6T7NmzePww8/PAskHHDAAbXVNQAAAAAAAAAAAAAAoC4qGyQtW7aMCy64IH72s5/Fu+++G++//37MmTMnWrduHeuss07stNNOUVxcXJtdAgAAAAAAAAAAAAAA6jJsUK5Zs2ax1VZbZTcAAAAAAAAAAAAAAKB+KajrDgAAAAAAAAAAAAAAAPWLsAEAAAAAAAAAAAAAAJDTPGrBoEGD4r333vtSxxQWFka7du1i7bXXju233z769+8fG2ywQY31EQAAAAAAAAAAAAAAqMWwQQoaDB8+fLWPv/322+Pss8+OgQMHxnXXXRft27ev1v4BAAAAAAAAAAAAAAC1HDY44IADYquttorS0tJ48MEHY8mSJdG9e/fYZpttokOHDjF//vz46KOP4u23347FixfHtttuG1/72tdi3rx5MW7cuHjjjTdi4cKFcdttt8WoUaPi2WefjdatW9dG1wEAAAAAAAAAAAAAoMkpqI2T/OIXv4gf//jH8frrr8eWW24Z//73v2P8+PHx2GOPxR133BH33XdfjBgxIiZMmBCnnXZavPPOO7HZZpvFPffcEy+//HJ8+umnccYZZ2RtvfLKK3H99dfXRrcBAAAAAAAAAAAAAKBJalZWVlZW0yeZNWtWbL311tGmTZsYPnx4tGvXboX7X3jhhfHrX/86q2QwcODAisdPPfXU+OMf/xg9e/bMKhxATb9vO3bsmK3PnDkzq8IBAACNxZKlZTG9ZEGV2zsXt4rCgma12idWzuvWeL7flS1ZEkunTatye0GXLtGssLBW+wQ0bv7uAACNRX38jgdQV5YsXRIz58+ocnvH1p2isMC/MdH4+SwANF2zShfGtJIFUbpgcRS1ah5diltFh6KWdd0taFRqJWxw9dVXx7nnnpsFBU4++eSV7j9v3rzo3LlzrLvuujF69Oho1ux/A1wmTZqUPZa6PH369OjUqVNNd50mzD9UAgAANA6+3wEAADQevuMBAAA0bSULFseDb0yMv7/ySbw/+bPltm/WbY04pnePOHi7daO4VfNoSNJk7S+//HKl21q2bJmF77faaqs48MADY4sttqj1/tE01cqn6Pnnn8+WqbrBqmjbtm1stNFG8e6778aUKVOiW7du2eNrr7129OjRIz7++OOYOnWqsAEAAAAAAAAAAAAANHJzPl8U1z41Ou55fXyULlxS5X4pgHDRw+/EFY+PjAE7rhdn9e0Za7ZpEQ3Bm2++GcOGDVvpfueff34cffTRcdNNN2Vjruub4447LiZOnBj9+/eP008/va67Q0MIG6QqBMlnny2fIKrK3LlzK44tDxskxcXF2bKwUJk3AAAAAAAAAAAAAGjMPp5eGscPfjU+njFvlY9JgYRbX/w4nh01LQafsFP06FQUDUXr1q3jH//4R+6xmTNnxocffhg333xzfPTRR3HnnXfGvHnz4sEHH4z65oUXXsj6utlmm9V1V2goYYNUkSBJb+hvf/vbK91/xIgRMX78+Nyx5VLSJVlnnXVqpK8AAAAAAAAAAAAAQP0IGhz25xdjesnC1Tp+7IzSOPRPL8Z9P/h6bNC5YQQO0oTsffv2rXTb2WefHbvttlsMHz48Hnroofjvf/8b22yzTa33kaajoDZO0q9fv2x5yy23xN13373CfVOYYODAgdn6zjvvHJ06darYNnv27Jg1a1Z06dKlosIBAAAAAAAAAAAAANC4zPl8UVbRYHWDBuXS8ScMfi1rr6Fr1apVnH766RX3X3/99TrtD41frVQ2SOGBa665JkaOHBlHHXVU3HbbbXHkkUdmSZoOHTrE/PnzY+zYsfHkk09m5T3mzp0bzZo1i8suuyzXzj//+c9suc8++9RGtwEAAAAAAAAAAACAOnDtU6Pj4xnzqqWtVOEgtfeLA7aMhq5r164V6wUFK593/oUXXoihQ4fGmDFj4rPPPovOnTtnE8IfccQR2QTwK5tE/t57740RI0bE9OnTo6ioKNZee+3YZJNN4pBDDonu3btX7HvFFVfEU089FZ9++ml2/+GHH473338/117//v1zYQnqv1oJG7Rs2TJ7k+69997ZG/Xxxx/PblV2qnnz+OMf/xh9+vTJPT5z5sw47rjjvMkAAAAAAAAAAAAAoJEqWbA47nl9fLW2ee/wCfHjfXpFcataGT5dY15++eWK9S222KLK/caNG5dNGP+f//xnuW233357nHfeedlk8j/4wQ8qPf4Pf/hD/OQnP4kFCxZUuv2ss86KX/ziF9kteeedd2LYsGEV2ydMmJDdlrXZZputwjOkPqm1T8sGG2wQb775Zlx++eVx0003xdSpU5fbp7CwMPbbb7+45JJLYtttt11u+6mnnprdAAAAAAAAAAAAAIDG6cE3JkbpwiXVHmB46M2JcWzvHtEQLV26NIYMGRJXXXVVdn/33XfPKhRU5pNPPonevXvHlClTori4OJvsfY899oh27drFxx9/HH/961/j9ddfj5NPPjmaNWsW3//+93PHpwoFP/zhD7P1rbbaKgYNGhQbbbRRtGjRIgsQpMnn77///pg0aVLFMeeff34cf/zx2blSdYODDjpouQnm11tvvRq4MtSkZmVlZWVRB2/2lF4ZPXp0zJkzJ1q1ahXrrrtu7LDDDtmbGOqDWbNmRceOHSuqanTo0KGuuwQAAMBq8P0OAACg8fAdDwAAoGn49nX/ifcnf1bt7W6+drt4/Iw9oj7af//947HHHssmb//mN7+Z2zZ79uwsJDBjxoxo3bp1HHzwwXHjjTdG+/btK21rt912ixdffDGbLD5VG0hBgWUtWbIkTjjhhKzCQdu2bbNwQufOnSu2H3XUUXH33XfH5ptvHsOHD482bdosd440BD2FGbp165Z7fJNNNokPP/wwTjvttKw6Ag1bndQBKSgoiG222Sa7AQAAAAAAAAAAAAAks0oX1kjQIBk5aW7WfoeilvX2YqcgQAoIVCVVLDjiiCOqDBqkY1PQILn11luXCxokKdCQwgr/+Mc/siBDCh386Ec/qtg+fvz4bLnrrrtWGjRIUkWELwYNaHwK6roDAAAAAAAAAAAAAADJtJIFNXohptdw+19Vqlzw5JNP5m5Dhw6Nm2++Ofr37x///ve/s+UPfvCDLJjwRQ899FC2XH/99ZerkLCs4uLi2GOP/1V5eOGFF3LbevTokS3/9a9/xbhx46r5GdKQ1EllAwAAAAAAAAAAAACALypdsLhGL0pJDbf/VaWqA3379q1020knnRR//vOf4+STT46//OUvscEGG8T555+f22fEiBHZ8rPPPotvf/vb2XpZWVnF9vL1tHz33Xez9UmTJuXaGDhwYNx5550xceLE6NWrV+y3336xzz77xO677x6bb755VtWApqFawwZz5syJRYsWVWeTWYmP5s1lIgAAAAAAAAAAAACgsStqVbPjhotruP2alioaXHvttfH+++/Hb3/72/jpT38aBQUFFdtnzJiRLWfNmpVVJlgV8+bNy91PIYUrr7wyfv7zn8f8+fPj/vvvz25J586d46CDDoozzzwztt5662p9btQ/1fpp6dOnTwwfPrw6m4zXXnstdtxxx2ptEwAAAAAAAAAAAACof7oUt6rR9jvXcPu1YZdddsnCBtOnT49Ro0Zl1QbKlU/y3rt377j00ktXqb011lhjucfOPffcGDRoUAwZMiSefvrpeP7552PmzJnZOW+55ZYYPHhw3HDDDVn4gcarYUdzAAAAAAAAAAAAAIBGo0NRy9is2xrx/uTPqr3tzddul7Xf0LVt27ZiPVUwWNa6664b7777bvZ43759v9J5unXrllUwSLeysrJ477334sEHH4xrrrkmZs+eHWeccUYccMABsc4663yl89BEwgaXXXZZllipThtvvHG1tgcAAAAAAAAAAAAA1F/H9O4RFz38Tg20u340BuPGjatY79ixY27bN77xjXjiiSdi9OjR8c4778RWW21VLeds1qxZbLnlltkttXnwwQfHwoULs4oHAwYMqNivsLAwW6ZwAg1ftYYN9tlnn+psDgAAAAAAAAAAAABoYg7ebt244vGRUbpwSbW1WdyqefTfdt1o6KZMmRJPP/10tt65c+fo2bNnbvvxxx8fv/rVr2L+/PlZ5YEUPGjevFqHjMf661cd2mjXrl2lFRdomAqiHps4cWJWYgMAAAAAAAAAAAAAaBpSMGDAjutVa5uH79A9a7chGzlyZBxwwAExb9687P6PfvSjKCjIDwdfZ511srBB8swzz2STyb/11lvLtbVkyZJ44YUX4sILL8wqICzr3HPPjXvuuafSwEAa333OOedk6y1atIg99tgjt32LLbbIls8++6zAQSNQ7z4xKUXz0EMPxeDBg+PJJ5+MV155JXbccce67hYAAAAAAAAAAAAAUEvO6tsznh01LcbOKP3KbW3YqShrryFIY6n79u2be2zx4sXx6aefxgcffFDx2GGHHZaFAirzk5/8JJvw/bLLLssCB9tuu22st9560aNHj1i4cGFWHWHy5MmxYMGCbP8vnu/OO++Mq6++Opo1axZdunSJtddeO9Zcc82YNm1ajBo1KpYuXZrtd80112TbljVw4MC47bbbYtKkSdn5tt5662jTpk22rX///nH66adX05WiSYUNXn755SxgMGTIENUMAAAAAAAAAAAAAKAJW7NNi7j1+J3isD+/GNNLFq52O52LW8bgE3bK2msIUsWBYcOGVbotDf7ffvvt44c//GEcd9xxK2zn0ksvjX79+sWVV14ZTz31VIwfPz67lUtVCfbcc8/Yd999s0DAslLQ4JFHHskmjp86dWp2K5cqKXzjG9+ICy64IPbee+/lzpuCCzfccEP88pe/zEINL774YsW2zTbb7EtdC+pes7KysrK6Onkqo3H77bfH3/72t3j//fdz21KCJZX5uP7662Ottdaqqy7ShKXSLx07dszWZ86cGR06dKjrLgEAALAafL8DAABoPHzHAwAAaHo+nl4aJwx+bbUqHKSKBilo0KNTUdR3b731VlY5oDKFhYVZZYGNN944W35ZqYJBqoqQvle3bds2G5vdtWvXaNmy5QqPS8PMU59SVYU5c+ZEu3btYtNNN43i4uKVnjNVP/jwww+zCgqpmkJqK1VX6NWr15fuP00obJBKezz00ENZFYOUdikvo1GedPnmN78Zxx57bBx66KHZGxLqin+oBAAAaBx8vwMAAGg8fMcDAABomuZ8viiufWp03Dt8QpQsWLzS/YtbNY/Dd+geZ/Xt2WAqGkB91Ly2TvTyyy9nAYMhQ4bE7NmzK90nhQ++9a1v1VaXAAAAAAAAAAAAAIB6LgUGfnHAlvHjfXrFQ29OjL+/Mi5GTpq73H6br90ujum9fvTfdt0scAB8NTX6KZo4cWLcfvvt8be//S3ef//93LZUPuPggw+Oo48+Os4///x48803VTIAAAAAAAAAAAAAACqVAgTH9u6R3WaVLozpJQuySgfp8c7FraJDUUtXDupz2GD+/Pnx0EMPZVUMUqWCpUuXVmxr0aJFfPvb384CBgcddFC0adMme/zCCy+s7m4AAAAAAAAAAAAAAI1UChYIF0ADCxv06dMnXnzxxYr7zZo1i9133z2OOeaYOPzww6Njx47VfUoAAAAAAAAAAAAAAKA+hw0WLFhQsX7iiSfGxRdfHOutt151nwYAAAAAAAAAAAAAAKghBVGD/vrXv8YhhxwSv/vd72LSpEk1eSoAAAAAAAAAAAAAAKC+hg2uvvrqGDBgQLRq1Sq7//rrr8fZZ58d3bt3j759+8att94ac+bMqe7TAgAAAAAAAAAAAAAA9TVssNdee8WQIUNi8uTJceONN8bOO++cPb506dIYNmxYnHjiidGtW7c47LDD4sEHH4wFCxZUdxcAAAAAAAAAAAAAAID6FDYo1759+zjllFPilVdeiffeey/OPffcWGeddbJt8+fPj/vvvz8OOeSQLHgwatSomuoGAAAAAAAAAAAAAABQX8IGy9p8883jyiuvjHHjxsXQoUNjwIAB0apVq2zb7Nmzo6SkJFtPVQ9+85vfxKefflob3QIAAAAAAAAAAAAAAOoqbFCusLAw+vXrF0OGDInJkyfHjTfeGDvvvHPF9rfffjvOOeecWG+99aJv374xePDgrAoCAAAAAAAAAAAAAABQe5qVlZWVRR0bOXJkFiy44447lqtq8Nprr8WOO+5YZ32j6Zo1a1Z07NgxW585c2Z06NChrrsEAADAavD9DgAAoPHwHQ8AAACgkVY2qMrmm28eV155ZYwbNy6GDh0aAwYMiFatWtV1twAAAAAAAAAAAAAAoElqHvVIYWFh9OvXL7vNnj077rrrrujUqVNddwsAAAAAAAAAAAAAAJqUehU2WFb79u3jlFNOqetuAAAAAAAAAAAAAABAk1NQ1x0AAAAAAAAAAAAAAADqF2EDAAAAAAAAAAAAAAAgR9gAAAAAAAAAAAAAAADIETYAAAAAAAAAAAAAABqU2fNnx4ezxsQ70/6bLdN96odtt902mjVrFt/97nejvmoIfawPmtd1BwAAAAAAAAAAAAAAVqZ0UWk8/uGjcf/oe+KDWaOX275ph55xaM8B0W/j/aOoRVGDuqD7779/PPbYY6u8f58+feKpp56q0T6BygYAAAAAAAAAAAAAQL01d8GcuObVK6PfPd+KK165tNKgQZIeT9vTfmn/dBw0ZJtssklWgeH000+vk/OrbAAAAAAAAAAAAAAA1Evj546LM546JcZ/Nm6Vj5m3eF7cNfKOeGHic3F9nz9G93brRUNRVFQUJSUl0ZC9+eabdd0FqonKBgAAAAAAAAAAAABAvQwanPT4wC8VNFjWuLmfxImPH5u1A3x5wgYAAAAAAAAAAAAAQL0yd8GcrKLBzPkzv1I76fgzh52atQd8OcIGAAAAAAAAAAAAAEC9ctNbf1rtigaVVThI7TUV999/f/Tt2zc6duwYxcXF8bWvfS1+85vfxIIFC2Ly5MnRrFmz7Hbffffljps9e3bFtjvuuKPK9j/++OOK/R599NHltm+77bbZtu9+97u5x2+99daK40aMGLHC57B48eLo2rVrtu/xxx+f2zZnzpy49957s8e32267WGuttaJly5bZ/nvvvXf8+c9/joULF0Z1mDFjRlxyySXRu3fv6NSpU3aeddZZJ/r37x+PPPLICo/t1q1b1v/zzjsvu//f//43jj766Fh33XWjdevWsfHGG8dZZ50V06ZNW+7YY489Njv2ww8/zO7fcMMNFdeu/Hb66adHTRM2AAAAAAAAAAAAAADqjdJFpfHwBw9Ua5uPjHkwa7cxW7p0aZx44olx2GGHxbBhw2LWrFlRWlqaDXI/55xzsoH46X5dSf1q27Zttn7bbbetcN+hQ4dWDMIfNGhQbtsPfvCDGDBgQPztb3+LN998M6ZOnRqLFi3K9n/qqafi5JNPjt133z2mT5/+lfr7j3/8IzbaaKO4+OKL49VXX42ZM2dm55k0aVI8/PDDcdBBB2X9SCGOlUn7p8DCXXfdFZ9++ml2zEcffRTXXXdd9nhqsz4SNgAAAAAAAAAAAAAA6o3HP3w05i2eV61tpqDB4x89Fo3ZpZdemlUPSFJlg5dffjk+//zzmDJlSjYz/ltvvVUxy35dWGONNeLggw/O1tOg+1S9oCrlYYT1118/9tprr9y2VLHhuOOOiwcffDDeeeedLAQwd+7crFrCqaeeGs2bN4/XXnstTjrppNXuawot9O/fP2t3xx13zM6VwgupYsLo0aOz8EZBQUFWYeGMM85YYVtp/2OOOSYOPfTQeOONN2L+/PlZuCCFGJKxY8fG2WefnTsmVZYoKyvLqh8kp512WnZ/2dsf/vCHqGnCBgAAAAAAAAAAAABAvXH/6HtqpN0HRtVMu9UpVR5o1qzZSm/33Xdf7rgUKPj1r3+drffp0ycef/zxbMb81q1bR9euXbNB+KlawAMPVG/FiC8rhQSSVI3gX//6V6X7zJ49Ox599NFs/dhjj82e77JuvPHGGDx4cBYG2HLLLaNDhw5ZkGG77bbLQhXlgYtHHnkk3n777S/dxxQoOP7447NKEakaxIsvvpidq1OnTtGiRYvYdNNN46qrrorrr78+2/+mm26Kd999t8r2UlAhVZxIAYJtt902WrVqFd26dYtf/OIXWZWGJL2eM2bMiPpG2AAAAAAAAAAAAAAAqBdmz58dH8waXSNtj541Kmu/Mfr73/+eDZJPfve732Wz+3/RbrvtFkcddVTUpRSE6N69e656wRfdfffdsWDBgmx90KBBX/ocKaCw0UYbZespYPFlDRkyJCZOnJiFHP70pz9lAYPKnHLKKdGjR4+sykDqc1XWXHPNuPzyyyvdVl59IVV5ePXVV6O+ETYAAAAAAAAAAAAAAOqFGZ9Pr9H2Z86vf7PHL6uoqCgbvL6y22GHHZY77rnnnsuWm2yySWy99dZVtn/ooYdGXSooKIhjjjmmovLAnDlzltunPISQKjP06tVrtc6z2WabZct33nnnSx/7xBNPZMutttqqIrRQ1XPZZZddsvXhw4dXud9ee+2Vva6VWfa1Gj9+fNQ3wgYAAAAAAAAAAAAAQL3w+eJ5Ndr+vEWl0RiNHTs2W26++eYr3G9l22vDcccdly3nz58f9957b27bmDFj4qWXXlppVYP3338/zjnnnCyQ0Llz52jZsmVWiaD8Vl7RYNasWV+6f6nt8qBC8+bNs1thYWHFLYUM0i2dJ1VBSKZPrzoks8EGG1S5rXXr1lnfk5KSkqhvhA0AAAAAAAAAAAAAgHqhTfO2Ndp+2xaVzzDf0JUPVK9qBv1yxcXFUddS4GGnnXbKVTEoV34/DcA/8sgjKz3+uuuuy6oO/OY3v4lXX301ZsyYEYsWLap03xRo+LJmz56dLcvKymLJkiXZbenSpRW38uoSy1q4cGGV7bVq1WqF50uhhSS1Xd8IGwAAAAAAAAAAAAAA9UKnNp1rtP2OrTtFY1QeIigtXXHlhhXNnp9m6y/3xcH0X3UA/xeVVy14/vnnK6oypHPecccd2fr+++8fHTt2XO64l19+OX70ox9lAYAddtgh23/UqFExd+7cWLx4cUUQIB2/utZYY41sue+++1a0t7Lbm2++GY2RsAEAAAAAAAAAAAAAUC+0b90+Nu3Qs0ba7tmhV9Z+Y7Thhhtmy5EjR65wvxVtX7YqQhq8X5WPP/44vqqjjjoqq16wbMDgueeeqwgeHHfccZUelyofpGO6desW//73v+OYY46Jnj17ZgGBwsLCiv0+/fTT1e7bxhtvnC3ffPPNFYYumgJhAwAAAAAAAAAAAACg3ji054AaafeQXjXTbn2wxx57ZMsxY8bEO++8U+V+Dz74YJXb0mD9ddZZJ1t/9913q9zvH//4R3xVnTp1iv322y9bv/322yuCBEnnzp2jX79+lR73ySefZMttttkmF45Y1vjx4+Ott95a7b6ligbJlClTYujQoVGXWrRokS1TJYe6IGwAAAAAAAAAAAAAANQb/TbeP9o2b1utbRa1KIp+G/1vcHtjlGb4T5UCkrPPPrvSwekvvfRS3HnnnSts5+tf/3q2vO+++yqtbjBixIi4+eabq6XPgwYNypYffPBBPPPMM9k5y6selA+y/6L27f9XmeLtt9+Ozz//fLntixcvjlNOOeUrDc5P13LttdfO1k899dSYMGFC1JUUvEgmTpxYJ+cXNgAAAAAAAAAAAAAA6o0UDDho00Oqtc0DNzk4a7exWmutteKCCy7I1p988smsasCrr74aCxYsiGnTpsWf/vSn+M53vhMHH3zwCtv5/ve/ny3TMfvvv3+88cYbsWjRopg8eXLceOON0adPnzjiiCOqpc+pj+WD6U888cSYM2dOtn7cccdVecwBBxyQLSdNmpStv/zyy1FaWhqfffZZPPHEE/HNb34z3nzzzdhzzz1Xu19t2rTJqi00b948xo0bF9tvv31cc801MXr06Ox6pnOlChL//ve/45JLLolddtklnnvuuagJO+64Y7Z86qmn4p///GelAYuaJGwAAAAAAAAAAAAAANQr3/vaybF+ux7V0lZqJ7XXEKSB882aNVvprXXr1ssde+GFF8bxxx+frf/rX/+K3r17Z/t17do1m+1/yy23jMsvv3yF5997773j5JP/d63SAPo00D5VTEgz/Z922mnRt2/f+MUvflEtzzVVL0hVDJKPP/44W26xxRaxww47VHnMgAEDKgITw4YNi1133TWKi4ujXbt2se+++8aoUaPi3nvvjQ4dOnylvqVQxdChQ6NLly5Z8OInP/lJ9OrVK7ue6VybbrppFmy4+OKL45VXXvlKlRRWJL1uKfyQQgb9+vWLtm3bVrwHTj/99KhpwgYAAAAAAAAAAAAAQL3SrtWacV2fG6Nj645fqZ10/PV9/pi119gVFBTErbfemg22/9a3vhXt27fPBqdvtdVWccUVV2Sz46eB+SuTKhikdsoH8qdbmmH/L3/5S9xzzz1RWFhYbX3+YhWDQYMGrfQ53nffffHHP/4xC1MUFRVlg/HT4P8zzzwzRowYkfW7Ouy9997x0UcfxXXXXZetp+oRKXiRrmsKHqRAwi9/+cssbPBVKimsSM+ePePFF1/MQhnrr79+dv7a1KysrKysVs8IDcSsWbOiY8f//Qdq5syZXznhBAAAQN3w/Q4AAKDx8B0PAACg6Rk/d1ycOezUGDf3k9WqaJCCBt3brVcjfWuIJk+enFUpSFIo4bDDDqvrLlGPqWwAAAAAAAAAAAAAANRL67VbPwZ/5+9x1ObHRlGLolU6Ju2X9k/HCRrA6mv+FY4FAAAAAAAAAAAAAKhR7VqtGT/e+adx8nanx+MfPRYPjLonRs8atdx+PTv0ikN6DYh+G+23ysEEoGrCBgAAAAAAAAAAAABAvZcCBIf1GpDdZs+fHTPnz4h5i0qjbYui6Ni6U7Rv3b6uuwiNirABAAAAAAAAAAAAANCgpGCBcAHUrIIabh8AAAAAAAAAAAAAAGhgVDYAAAAAAAAAAAAAAGgCunXrFmVlZXXdDRoIlQ0AAAAAAAAAAAAAAIAcYQMAAAAAAAAAAAAAACBH2AAAAAAAAAAAAAAAAMgRNgAAAAAAAAAAAAAAAHKEDQAAAAAAAAAAAAAAgBxhAwAAAAAAAAAAAAAAIEfYAAAAAAAAAAAAAAAAyBE2AAAAAAAAAAAAAAAAcoQNAAAAAAAAAAAAAACAHGEDAAAAAAAAAAAAAAAgR9gAAAAAAAAAAAAAAADIETYAAAAAAAAAAAAAAAByhA0AAAAAAAAAAAAAAIAcYQMAAAAAAAAAAAAAACBH2AAAAAAAAAAAAAAAAMgRNgAAAAAAAAAAAAAAAHKEDQAAAAAAAAAAAAAAgBxhAwAAAAAAAAAAAAAAIEfYAAAAAAAAAAAAAAAAEDYAAAAAAAAAAAAAAACqprIBAAAAAAAAAAAAAACQI2wAAAAAAAAAAAAAAADkCBsAAAAAAAAAAAAAAAA5wgYAAAAAAAAAAAAAAECOsAEAAAAAAAAAAAAAAJAjbAAAAAAAAAAAAAAAAOQIGwAAAAAAAAAAAAAAADnCBgAAAAAAAAAAAAAAQI6wAQAAAAAAAAAAAAAAkCNsAAAAAAAAAAAAAAAA5AgbAAAAAAAAAAAAAAAAOcIGAAAAAAAAAAAAAABAjrABAAAAAAAAAAAAAACQI2wAAAAAAAAAAAAAAADkCBsAAAAAAAAAAAAAAAA5wgYAAAAAAAAAAAAAAECOsAEAAAAAAAAAAAAAAJAjbAAAAAAAAAAAAAAAAOQIGwAAAAAAAAAAAAAAADnCBgAAAAAAAAAAAAAAQI6wAQAAAAAAAAAAAAAAkCNsAAAAAAAAAAAAAAAA5AgbAAAAAAAAAAAAAAAAOcIGAAAAAAAAAAAAAABAjrABAAAAAAAAAAAAAACQI2wAAAAAAAAAAAAAAADkCBsAAAAAAAAAAAAAAAA5wgYAAAAAAAAAAAAAAECOsAEAAAAAAAAAAAAAAJAjbAAAAAAAAAAAAAAAAOQIGwAAAAAAAAAAAAAAADnCBgAAAAAAAAAAAAAAQI6wAQAAAAAAAAAAAAAAkCNsAAAAAAAAAAAAAAAA5AgbAAAAAAAAAAAAAAAAOcIGAAAAAAAAAAAAAACAsAEAAAAAAAAAAAAAAFA1lQ0AAAAAAAAAAAAAAIAcYQMAAAAAAAAAAAAAACBH2AAAAAAAAAAAAAAAAMgRNgAAAAAAAAAAAAAAAHKEDQAAAAAAAAAAAAAAgBxhAwAAAAAAAAAAAAAAIEfYAAAAAAAAAAAAAAAAyBE2AAAAAAAAAAAAAAAAcoQNAAAAAAAAAAAAAACAHGEDAAAAAAAAAAAAAAAgR9gAAAAAAAAAAAAAAADIETYAAAAAAAAAAAAAAAByhA0AAAAAAAAAAAAAAIAcYQMAAAAAAAAAAAAAACBH2AAAAAAAAAAAAAAAAMgRNgAAAAAAAAAAAAAAAHKEDQAAAAAAAAAAAAAAgBxhAwAAAAAAAAAAAAAAIEfYAAAAAAAAAAAAAAAAyBE2AAAAAAAAAAAAAAAAcoQNAAAAAAAAAAAAAACAHGEDAAAAAAAAAAAAAAAgR9gAAAAAAAAAAAAAAADIETYAAAAAAAAAAAAAAAByhA0AAAAAAAAAAAAAAIAcYQMAAAAAAAAAAAAAACBH2AAAAAAAAAAAAAAAAMgRNgAAAAAAAAAAAAAAAHKEDQAAAAAAAAAAAAAAgBxhAwAAAAAAAAAAAAAAIEfYAAAAAAAAAAAAAAAAyBE2AAAAAAAAAAAAAAAAcoQNAAAAAAAAAAAAAACAHGEDAAAAAAAAAAAAAAAgR9gAAAAAAAAAAAAAAADIETYAAAAAAAAAAAAAAACEDQAAAAAAAAAAAAAAgKqpbAAAAAAAAAAAAAAAAOQIGwAAAAAAAAAAAAAAADnCBgAAAAAAAAAAAAAAQI6wAQAAAAAAAAAAAAAAkCNsAAAAAAAAAAAAAAAA5AgbAAAAAAAAAAAAAAAAOcIGAAAAAAAAAAAAAABAjrABAAAAAAAAAAAAAACQI2wAAAAAAAAAAAAAAADkCBsAAAAAAAAAAAAAAAA5wgYAAAAAAAAAAAAAAECOsAEAAAAAAAAAAAAAAJAjbAAAAAAAAAAAAAAAAOQIGwAAAAAAAAAAAAAAADnCBgAAAAAAAAAAAAAAQI6wAQAAAAAAAAAAAAAAkCNsAAAAAAAAAAAAAAAA5AgbAAAAAAAAAAAAAAAAOcIGAAAAAAAAAAAAAABAjrABAAAAAAAAAAAAAACQI2wAAAAAAAAAAAAAAADkCBsAAAAAAAAAAAAAAAA5wgYAAAAAAAAAAAAAAECOsAEAAAAAAAAAAAAAAJAjbAAAAAAAAAAAAAAAAOQIGwAAAAAAAAAAAAAAADnCBgAAAAAAAAAAAAAAQI6wAQAAAAAAAAAAAAAAkCNsAAAAAAAAAAAAAAAA5AgbAAAAAAAAAAAAAAAAOcIGAAAAAAAAAAAAAABAjrABAAAAAAAAAAAAAACQI2wAAAAAAAAAAAAAAADkCBsAAAAAAAAAAAAAAAA5wgYAAAAAAAAAAAAAAECOsAEAAAAAAAAAAAAAAJAjbAAAAAAAAAAAAAAAAOQ0z98FGquyJUti6bRpVW4v6NIlmhUW1mqfgNrnbwEAAAAANHxLlpbF9JIFVW7vXNwqCgua1WqfmjqvCQB1ze+ANEbe1wAAdU/YAJqIFDSYtMNOVW5fe/hrUditW632Cah9/hYAAAAAQMOXgga9Lx9W5fZXzu8Ta7VrXat9auq8JgDUNb8D0hh5XwMA1L2Cuu4AAAAAAAAAAAAAAABQvwgbAAAAAAAAAAAAAAAAOcIGAAAAAAAAAAAAAABAjrABAAAAAAAAAAAAAACQI2wAAAAAAAAAAAAAAADkCBsAAAAAAAAAAAAAAAA5wgYAAAAAAAAAAAAAAECOsAEAAAAAAAAAAAAAAJAjbAAAAAAAAAAAAAAAAOQIGwAAAAAAAAAAAAAAADnCBgAAAAAAAAAAAAAAQI6wAQAAAAAAAAAAAAAAkCNsAAAAAAAAAAAAAAAA5AgbAAAAAAAAAAAAAAAAOcIGAAAAAAAAAAAAAABAjrABAAAAAAAAAAAAAACQ0zx/F4DGbsnMWbF02tRYWjovCoraRkGXrlHYsUNddwsAAAAAgCZuVunCmFayIEoXLI6iVs2jS3Gr6FDUsq67BQBQJb+/AwDQ2AkbNBAzZsyIzz//PFq1ahVdunSp6+7UK5999lnMmTMnCgoKYp111qnr7kC9tLSkJObd/0CU3n5HLBo5crntLTbfPIoGHhttDz0kCoqL66SPAAAAAAA0PSULFseDb0yMv7/ySbw/+bPltm/WbY04pnePOHi7daO4lZ82AYC65/d3AACakoK67gCr5qSTTor11lsvDj/8cJfsC2644Ybs2vTs2dO1gS9YOnt2zP75xTFp+x1j9s8uqDRokKTH0/Zsv59fnB0HAAAAAAA1Zc7ni+KSf7wbvS97Ki56+J1KgwZJejxtT/ul/dNxAAB1we/vAAA0RcIGAI3U4rFjY+p+B0TJLbdEWWnpKh2T9kv7T93/wFj88cc13kcAAAAAAJqej6eXxkE3PB+3vvhxlC5cskrHpP3S/v1veCE+mbFq/+YNAFBd/P4OAEBTJWwA0Fj/oaP/IasdGMiOP+jgbAkAAAAAANUZNDjszy/GxzPmrdbxY2eUxqF/ejFrBwCgNvj9HQCApkzYAKARlm6cfuygWDp9+ldrZ/r0mD7wuKw9AAAAAAD4quZ8viiOH/xqTC9Z+JXaScefMPi1rD0AgJrk93cAAJo6YQOARmbub69d7YoGlc3QkNoDAAAAAICv6tqnRq92RYPKKhyk9gAAapLf3wEAaOqEDRq4pUuXxvTp02PJkiUr3XfGjBkxYcKEmDZt2nLbUhuffvpplccuXLgwpk6dGgsWLFjtvs6ZMydmzpyZ9Xl1lJWVZcd/lT5AY7e0pCRK7767WtssHTIkaxcAAAAAAFZXyYLFcc/r46v1At47fELWLgBATfD7OwAARDR3ERqmV199NX7+85/H008/HYsWLYrmzZvHt771rbj44otj1113rfSYk046KR5++OH4xje+Ec8++2y89dZb8atf/SqGDh0an3/+eRQVFUXJMgOK0/rvfve7uPvuu+O9996reLxnz54xYMCA+PGPfxzt27evso/Dhg3L2n7iiSdi7NixUVpamj3eunXrrI+nnXZaHHrooSt9rhMnToyLLroo7r///pg7d240a9YsttpqqzjnnHNi4MCBX/LKNV1lS1Yc8lgyZUqt9YWaU3rvfVH2f5+16lJWUhIlg/8WRYet/PNK/beyz/rK/lYAAAAAAHVvydKyFW6fMnd+1Df3DZ8QpQtXPnnWl5GCBre99HEcun33qGsru+Yre80A4KsyJqD6+f297vl9GwCg7gkbNEBpAP8hhxySzfDfoUOHrOpAGsifBvU/9dRTcfPNN8cJJ5ywwjb+9a9/ZW3Mmzcv1lxzzejYsWMWNig3ZsyY2HfffeOjjz7K7hcWFmb7zJo1K0aPHh2XXnppDB48OP75z3/GlltuuVz78+fPj759+1bcTwGBTp06ZWGBtO2ZZ57JbikAkfpblTfeeCNrJ1U0SFq0aJH19913341BgwbFO++8k10DVm7p9OUrWixr6nf2dxmp0tzLr8huNJG/FeuuU9fdAAAAAABWYHrJiqtAH3jDC03m+l31r1HZrSG8Zuu0b1PX3QCgETMmoOHw+3v18fs2AEDNK6iFc1CNZsyYEccff3z06dMnG/SfBuF/9tlnWYWDTTfdNJYuXRrf+9734vXXX19hG2mgfmrj/fffj9mzZ8eECRNi1Kj//UNsCi7st99+WdCgZcuWcc0112Qhg6lTp2b7/v73v49WrVplx6T90mNflMIFKazwl7/8JatqkAIG06dPzyoopIoK/fv3z/a75ZZb4q9//Wul/UzBhIMOOih7jsXFxVkoIT02bdq07Pazn/0srr766njyySdX+3qm51XVrbLnBQAAQP3k+x0AAEDj4TseAAAAQP2gskEDk2by33333ePhhx+O5s2bVwzs32uvvbLAwdZbb50Nkj/33HOz+1W1kYIGDz30UBQULJ83uf7667MgQ5LCAscdd1zFtlT94PTTT8+qHBxzzDHxySefZAP+f/3rX+faSGGEVPXgi1KFhG222SYefPDBOPLII2PIkCFx1VVXxYknnrjcvtddd12MHz8+W7/rrrti//3//8z76fzpnKn/qcrC6krtAAAA0PD5fgcAANB4+I4HAAAAUD+obNAAXXbZZRVBg2V17949zjzzzGz9mWeeiXHjxlXZRhqgX1nQIBk8eHC2TKGAZYMGyzr66KNjp512ytarqkywMmeffXa2TBUVUpWEL7rtttuy5Z577pkLGizrggsuiPbt26/W+QEAAAAAAAAAAAAAqJywQQOz5pprZpUNqnLAAQdUrL/00kuV7pMG5++yyy6Vbps2bVpFVYMDDzxwhX3p379/tpw8eXJ8+OGHK9y3rKws5syZE59++mkWLEi31q1bV2wfOXLkcv0YM2ZMtl5V0CBJbfTt2zdW18yZM6u8ffTRR6vdLgAAALXL9zsAAIDGw3c8AAAAgPph+enxqdc22WSTaNasWZXbe/bsWbE+fvz4SvfZeOONqzx+2QoDy7ZVmV69euXO9cV2FyxYEH/5y1/innvuiTfffDNKSkqqbGvWrFm5+8v2fdNNN11hP1bWzxXp0KHDah8LAABA/eH7HQAAQOPhOx4AAABA/SBs0MC0adNmhdvbtm1bsV5aWlrpPkVFRVUeP2/evErbWlk7XzzX1KlTo0+fPvHOO+9UPFZYWJj9w2DLli2zwESqdpAqHSQLFy6ssh9f5jkDAAAAAAAAAAAAAPDVCRs0MHPnzl3h9tmzZ1esr7nmmpXus6LKCO3atau0rS97rh/96EdZ0KBFixZx0UUXxRFHHJFVZSgoKKjYZ/r06dGlS5eV9uPLPGeqVtC58mtdruvQR6NwrbVcwgau9N77Yu4VV1Z7u+3OPy+KDju02tul9i2ZMiWmfmf/1f5bAQAAAADUvc7FrVa4/ZHTdou12rWO+uS+4RPi6idGVXu75+7bKw7dvnvUtSlz58eBN7yw2q8ZAHxVxgRUP7+/1z2/bwMA1D1hgwZm1KhRWRWAVB2gMm+//XbFehrc/2VtuOGGWQWCJUuW5NqqzFtvvVXpuRYvXhwPPPBAtn7OOedkYYPKfPLJJ1W2vdFGG2XBhKVLl2b9OPzww6vcd2X95H+aFf7/oEdlUtCgsFs3l6uBKz7h+Pjs93+Isioqm6yOZsXFUXz8cVFQXFxtbdJw/1YAAAAAAHWvsKDqiaWSFDSob2GD476+Qdz47JgoXbik2tosbtU8Bu26QbZs6K8ZAHxVxgRUP7+/139+3wYAqHlGFDYwCxYsiEceeaTK7UOGDMmWqaLA17/+9S/dfnFxcey0007Z+n333ZcFGyqTAgXl59p8882j2zKD1GfOnBnz58/P1rfccssqz3X//fevsB877LBDRT/Kysoq3W/q1KnxzDPPrNJzg6YgBQKKjjyyWtssOuIIQQMAAAAAAL6SFAgYsON61XoVD9+he4MIGgAADZPf3wEAQNigQTrvvPOyAf1f9PLLL8ctt9ySrQ8YMCA6duy4Wu2feuqp2XLixIlx4YUXVrrPL3/5yxg7dmy2ftppp+W2tW/fvqLywlNPPVXp8S+++GJce+21K+zHD37wg2w5cuTI+O1vf7vc9hRAOP3002PRokWr9LygqWh39lnRfMMNq6Wt1E5qDwAAAAAAvqqz+vaMDTsVVcuFTO2k9gAAapLf3wEAaOpUNmhgdt1112jdunX07t077rjjjvjggw/i7bffjiuvvDL22WefbOB9hw4dsvur69hjj83aSq6++uo48sgj49lnn42PPvoonnvuuRg0aFD86le/yrbvtttucfLJJ+eOT0GDAw88MFu/9dZb43vf+148//zz2fEpEJHCEn369Invfve7K+zH8ccfH7vssku2fs4552Thg5deeilr54knnohvf/vbWZWHgQMHrvZzhcaooH376Hz736Kgc+ev1k7nztH5jtuy9gAAAAAA4Ktas02LuPX4naJz8f8mrVpd6fjBJ+yUtQcAUJP8/g4AQFOnrmgDkwby33PPPVkYoLJB9p07d45HH3001l133dU+R7NmzeL++++Po48+Ov7xj3/EkCFDstsX9e3bN+69994oLCxcbtt1110Xb775ZowZMyZuvvnm7Las1Pef//zn8fvf/77KfqR2U5igX79+MXz48PjLX/6S3cq1aNEiBg8eHOPGjVvt5wqNVapI0PWhB2L6wONi8f9VIfmyx6egQfMNNqiR/gEAAAAA0DRt0Lko7vvB1+OEwa/F2Bmlq1XRIAUNelRThQQAgJXx+zsAAE2ZsEEDkUIEKUDQpUuX2GKLLWLEiBHZQP1hw4bFlClTomvXrrH33nvHGWecke27sjZWpri4OBvo/+STT8Zdd92VBQdmz54d7dq1i2222SYGDBgQ+++/f5XHr7POOlkfb7jhhhg6dGhMmDAh1lhjjejVq1dWGSEdO3fu3IpQRFFR5f8gnPqaqiHccsstWQBi7NixWTvbb7999lxTX2688casnaragCb9Dx6PPhJzf3ttlA4ZEmUlJSs9pllxcRQdcURWClJFAwAAAAAAaipw8NBpu8W1T42Oe4dPiJIFi1d6THGr5nH4Dt3jrL49VTQAAGqd398BAGiqmpWVlZXVdSegPpo1a1Z07NgxW585c2Z06NAhGrIlkyfHpB12qnL72sNfi8Ju3Wq1T9SepSUlMe+BB6P09jti0XvvLbe9xRZbRNHAY6PtIQdHQXGxl6YR87cAAGiKGtv3OwAAmDJ3fvS+fFiVF+KV8/vEWu1aN4gLlYIGD705Mf7+yrgYOWnucts3X7tdHNN7/ei/7bpZ4KC+akyvSX3nOx5A5fwOWHv8/l57vK8BAOpe/f0XOQCqTQoQFA8amN2WzJwVS6dPi6UlpVFQXBQFnbtEYUeDrQAAAAAAqH0pQHBs7x7ZbVbpwphesiALIKTHOxe3ig5FLb0sAEC94vd3AACaEmEDgCYmBQuECwAAAAAAqG9SsEC4AABoSPz+DgBAY1dQ1x0AAAAAAAAAAAAAAADqF2EDAAAAAAAAAAAAAAAgR9gAAAAAAAAAAAAAAADIETYAAAAAAAAAAAAAAAByhA0AAAAAAAAAAAAAAIAcYQMAAAAAAAAAAAAAACBH2AAAAAAAAAAAAAAAAMgRNgAAAAAAAAAAAAAAAHKEDQAAAAAAAAAAAAAAgBxhAwAAAAAAAAAAAAAAIEfYAAAAAAAAAAAAAAAAyBE2AAAAAAAAAAAAAAAAcoQNAAAAAAAAAAAAAACAHGEDAAAAAAAAAAAAAAAgR9gAAAAAAAAAAAAAAADIETYAAAAAAAAAAAAAAABympWVlZXlHwKSWbNmRceOHbP1mTNnRocOHRr0hSlbsiSWTptW5faCLl2iWWFhrfYJqH3+FgAATVFj+34HAABLlpbF9JIFVV6IzsWtorCgmQtVi7wmtcd3PIDK+R2Qxsj7GgCg7jWv6w4AtSMFCQq7dXO5oYnztwAAAAAAGr4UJFirXeu67gbL8JoAUNf8Dkhj5H0NAFD3Cuq6AwAAAAAAAAAAAAAAQP0ibAAAAAAAAAAAAAAAAOQIGwAAAAAAAAAAAAAAADnCBgAAAAAAAAAAAAAAQI6wAQAAAAAAAAAAAAAAkCNsAAAAAAAAAAAAAAAA5AgbAAAAAAAAAAAAAAAAOcIGAAAAAAAAAAAAAABAjrABAAAAAAAAAAAAAACQI2wAAAAAAAAAAAAAAADkCBsAAAAAAAAAAAAAAAA5wgYAAAAAAAAAAAAAAECOsAEAAAAAAAAAAAAAAJAjbAAAAAAAAAAAAAAAAOQIGwAAAAAAAAAAAAAAADnCBgAAAAAAAAAAAAAAQI6wAQAAAAAAAAAAAAAAkCNsAAAAAAAAAAAAAAAA5AgbAAAAAAAAAAAAAAAAOcIGAAAAAAAAAAAAAABAjrABAAAAAAAAAAAAAACQI2wAAAAAAAAAAAAAAADkCBsAAAAAAAAAAAAAAAA5wgYAAAAAAAAAAAAAAECOsAEAAAAAAAAAAAAAAJAjbAAAAAAAAAAAAAAAAOQIGwAAAAAAAAAAAAAAADnCBgAAAAAAAAAAAAAAQI6wAQAAAAAAAAAAAAAAkCNsAAAAAAAAAAAAAAAA5AgbAAAAAAAAAAAAAAAAOcIGAAAAAAAAAAAAAABAjrABAAAAAAAAAAAAAACQI2wAAAAAAAAAAAAAAADkCBsAAAAAAAAAAAAAAAA5wgYAAAAAAAAAAAAAAECOsAEAAAAAAAAAAAAAAJAjbAAAAAAAAAAAAAAAAOQIGwAAAAAAAAAAAAAAADnCBgAAAAAAAAAAAAAAQI6wAQAAAAAAAAAAAAAAkCNsAAAAAAAAAAAAAAAA5AgbAAAAAAAAAAAAAAAAOcIGAAAAAAAAAAAAAABAjrABAAAAAAAAAAAAAACQI2wAAAAAAAAAAAAAAADkCBsAAAAAAAAAAAAAAAA5wgYAAAAAAAAAAAAAAECOsAEAAAAAAAAAAAAAAJAjbAAAAAAAAAAAAAAAAOQIGwAAAAAAAAAAAAAAADnCBgAAAAAAAAAAAAAAQI6wAQAAAAAAAAAAAAAAkCNsAAAAAAAAAAAAAAAA5AgbAAAAAAAAAAAAAAAAOcIGAAAAAAAAAAAAAABAjrABAAAAAAAAAAAAAACQI2wAAAAAAAAAAAAAAADkCBsAAAAAAAAAAAAAAAA5wgYAAAAAAAAAAAAAAECOsAEAAAAAAAAAAAAAAJAjbAAAAAAAAAAAAAAAAOQIGwAAAAAAAAAAAAAAADnCBgAAAAAAAAAAAAAAQI6wAQAAAAAAAAAAAAAAkCNsAAAAAAAAAAAAAAAA5AgbAAAAAAAAAAAAAAAAOcIGAAAAAAAAAAAAAABAjrABAAAAAAAAAAAAAACQI2wAAAAAAAAAAAAAAADkCBsAAAAAAAAAAAAAAAA5wgYAAAAAAAAAAAAAAECOsAEAAAAAAAAAAAAAAJAjbAAAAAAAAAAAAAAAAOQIGwAAAAAAAAAAAAAAADnCBgAAAAAAAAAAAAAAQI6wAQAAAAAAAAAAAAAAkCNsAAAAAAAAAAAAAAAA5AgbAAAAAAAAAAAAAAAAOcIGAAAAAAAAAAAAAABAjrABAAAAAAAAAAAAAACQI2wAAAAAAAAAAAAAAADkCBsAAAAAAAAAAAAAAAA5wgYAAAAAAAAAAAAAAECOsAEAAAAAAAAAAAAAAJAjbAAAAAAAAAAAAAAAAOQIGwAAAAAAAAAAAAAAADnCBgAAAAAAAAAAAAAAQI6wAQAAAAAAAAAAAAAAkCNsAAAAAAAAAAAAAAAA5AgbAAAAAAAAAAAAAAAAOcIGAAAAAAAAAAAAAABAjrABAAAAAAAAAAAAAACQI2wAAAAAAAAAAAAAAADkCBsAAP+vvTuBn6n6/zh+LCVk30JKe1FJZUllSYssJRRJ+6btV9r3fV9+aU97kTaKiGihVYSKSihLEiKkBSXzf7zP/3Hmd2e+987+ne37ej4e8zO/5s7M/d4z995zPud8zgEAAAAAAAAAAAAAAAAAAIhAsgEAAAAAAAAAAAAAAAAAAAAAAIhQMfL/AnA2b94cfr527VoODAAAAAAkqUaNGqZ8+dzPc0D7DgAAAACKo30ntPEAAAAAoHjaeADyH8kGQIB169aFn++4444cJwAAAABI0urVq02tWrVyftxo3wEAAABAcbTvhDYeAAAAABRPGw9A/iM1CQAAAAAAAAAAAAAAAAAAAAAARCgXCoVCkf8JgGzatMksWbLEPq9evXpeLRu0du3a8GoLCxYsMDVr1sz1LiFBlF1hotwKE+VWuCi7wkS5FS7KrjAVSrnlyxKs+dy+K6TyRCTKrXBRdoWJcitMlFvhouwKE+VWmAql3PKlfZfvbbxCKU+URNkVJsqtMFFuhYuyK0yUW+Gi7ApToZRbPrXxAOS/irneASBfVaxY0eywww4m36lCwpJGhYmyK0yUW2Gi3AoXZVeYKLfCRdkVJsqteNp3QnkWJsqtcFF2hYlyK0yUW+Gi7AoT5VaYKLfiauNRnoWLsitMlFthotwKF2VXmCi3wkXZFSbKDUCxIDUJAAAAAAAAAAAAAAAAAAAAAABEINkAAAAAAAAAAAAAAAAAAAAAAABEINkAAAAAAAAAAAAAAAAAAAAAAABEINkAAAAAAAAAAAAAAAAAAAAAAABEINkAAAAAAAAAAAAAAAAAAAAAAABEINkAAAAAAAAAAAAAAAAAAAAAAABEKBcKhUKR/wkAAAAAAAAAAAAAAAAAAAAAAJRlrGwAAAAAAAAAAAAAAAAAAAAAAAAikGwAAAAAAAAAAAAAAAAAAAAAAAAikGwAAAAAAAAAAAAAAAAAAAAAAAAikGwAAAAAAAAAAAAAAAAAAAAAAAAikGwAAAAAAAAAAAAAAAAAAAAAAAAikGwAAAAAAAAAAAAAAAAAAAAAAAAikGwAAAAAAAAAAAAAAAAAAAAAAAAikGwAAAAAAAAAAAAAAAAAAAAAAAAikGwAAAAAAAAAAAAAAAAAAAAAAAAiVIz8vwAyacaMGebNN980ixcvNhUrVjQ77bST6dWrl9ltt90yfqC///57M2bMGPvvunXrTOPGjU2zZs3MUUcdZWrWrOn7nhtuuMF88803cT+7ZcuW5pprrjFlxS+//GJee+01e2x0LBs2bGgOPfRQ+6hQoULKn/v777+bU089Nan3HHnkkeb000/P+r4Wok2bNpkJEyaYSZMmmeXLl5saNWqYvffe2/Tp08fUqVMnrc++8847zfTp0xPevnLlymbo0KER/23z5s3muOOOS+j9J598sunRo4cpK+bMmWNef/11s2DBAnuctt9+e9OzZ0+zzz77ZOw7dP6NHTvWlqPOm1AoZOrVq2e/Q9fJWrVq5c2+ForffvvNHouZM2eaNWvW2ON50EEHme7du5tKlSpl5DtUTp988ok9rxctWmT++usvU61aNbPrrruaI444wuy1116B7509e7a56aabEvqeu+++2+y4446mLNDv9oMPPrDXy6VLl5qqVauaPfbYw14rVXfIlJ9++snWgWbNmmXPv7p165pWrVqZo48+2pZhPu1rodA5MGLECDNv3jyzceNGs+2225quXbuaAw88MGPf8ffff5u33nrLnne6l1apUiVcf91ll11ivvfFF180b7zxRtzvUDk+//zzpixQOX3xxRdm6tSp9lr5559/2v9+7bXXZvy+oeujzrnPPvvMrFy50tZ9Wrdube9RW2+9ddY+o9jpeqbfueoTv/76q7336RxUvW2rrbbK+O/n3XffNR999JFZtmyZ/fymTZuaQw45xLRp08b3Pd999539fSXi1ltvNbvvvrspC1Sf+Pjjj8348ePt/UnHUm3yY4891my33XZpffYLL7xgz5tkPPHEE6Z27dpZ39dC9OOPP9p739y5c8369evtvU9tZNU5y5Url9Y99dJLL03qPQMGDLDXQ69XX33VPuLZcsstzfDhw01ZsWHDBhuf+vTTT23bS/eT/fbbz9YnEq0HJuLLL780EydONPPnzzd//PGHrbeoTt+pUyfTrl27vNrXQpGNOKbun/oOld+qVats7Kp+/fq2raC2pOqKQYhj+lO9TddKtYFdbFD1hcMOO8yWYybo/vTee+/ZtrnuTyo33ZdUB9I5k0/7WihKM47ppWukrnOqJ6o90qBBA3sfVVsyVv2VOKY//f7Vvps2bZqNDerc0LXyrrvuMpmWiRgkccz4dD8aPXq0rR+WL1/e1iV071P8KdMWLlxo74E6L9euXWtjW/oexaaD2ge33XabjSvE07x584TjoMVA9QndTxR3VIx6m222sXVAxYvTuZ/8888/5vjjj0/qPfre8847L+v7Woj+/fdfG+fQQ3EO1bf33HNP295VfTAdgwcPtm3pZKhcovXv39/GR+NRX1+i/X3FQNetkSNH2jEIqsO4eqDq8JmiuKT68D7//HOzYsUK+3tRn0KLFi3sdVLP82VfC0W24phqT6tOqzqLylFxZPXhqY4fq95CHNPkNDao67Brm+v+pHNs3333Ncccc4xtmySCOGYklZfG7ei3rTim6npdunQx7du3TyuO6aXrmn4b3j6DHXbYwZZbvPqrro0vvfRS3O9Qe/+VV14xZYH6YHQOqH2nmJjii3LFFVdk/L6RiRgkcUwAeSEEIOPWrFkT6tWrV0inWPSjXLlyoXPPPTe0cePGjHzXzz//HDr22GN9v0uPLbfcMvTwww/7vrdDhw6B7/M+jjjiiFBZoWNVuXJl3+PQsmXL0HfffZfyZ69cuTKh4+19XHXVVTnZ10Iza9asUPPmzX2PxdZbbx16+umn0/r8bt26JVVuDRs2LPEZ//zzT8Lvv+eee0Jlwfr160Nnnnlm4HHo27dv6Lfffkv7ex577LFQ9erVA79H59Fdd92VF/taKF577bVQ7dq1fY/FjjvuGJoyZUra3zF79uzQvvvuG/Nc6dq1a2j58uW+73/nnXcSPuc+//zzUFmwcOHCULt27QLrC3fccUfa37Fp06bQFVdcYT/P73vq1q0bGjFiRF7sa6H4999/bX2gQoUKvsfjsMMOCy1btizt79E506RJk8D668CBA+21MIjKPZHzrUaNGqGy0BbYb7/9QltssYXvMRg/fnxGv++9994LNW7c2Pe7GjRoEBo3blxWPqPYjR492l7D/I7R9ttvH/rwww8z9l0vvfSSrU8GnUe61/75558l3vfRRx8lfO/TtmXBTz/9FOrUqZPvMahYsWLohhtuCG3evDnlz7/kkksSPuZ6lC9fPrR69eqc7Gsh0d+pv1d/t9/x6Nixoz1eqfriiy+SKjc9HnnkkRKfo31M5L2VKlUKlRW6FuqaGFQPHDVqVNrfobJX/SfWMW/dunXcmEg29rVQZCOOqfP6lltuCW211VaB5VazZs2Y8RvimP7xjipVqvgezxYtWoS+/fbbUCba5nvvvXdgufXo0SP0yy+/5MW+ForSjmPKX3/9FTrjjDNs3cPve7bbbrvQ+++/H/h+4piRHnroocD6udp+mZSJGCRxzPh0DPv16xd4nFUGsWIgyVixYkWof//+gd+l2MF9993n+171zSVS39Q9sqzQNVLXSr/joGurrrGpUpkn20644IILcrKvhUZ1c/VbBvXPBPVjJ0rXxmTKrVq1ar6fo7ZbIu9XW7As+Pvvv0P/+c9/bJvA7zj07Nkz9Ouvv6b9Pc8991yoVq1agcdb5XLjjTfGjIlka18LRTbimHPmzLFt71jnitruS5cu9X0/cczcxAbV36TzKahtrnb50KFD434Occz/UZncfPPNgXHM9u3bh5YsWRJKl84Z9QsEnW+nnHJK6Pfffw98v2Iyidzj1BdZ7NS30qpVq8C+7DfeeCOj35eJGCRxTAD5omylzANZoBkPlGGvbFLp27evOfzww+2MGMpk1SxQjz76qM0QHjZsWNozoWgGDM04pllXNFuw/r8yjzUzirIvlbGu7WJRxuSVV14Z+Lpm2igLHn74YXPBBReEZ4I57bTT7LFUxv9TTz1lZ5Dp3Lmznb0olRmVq1evbn8D8Wimtm+//dY+D5oZo7T3tZBopgT9rZodTbMlnHXWWXamBM0K9uSTT9pZLLQ6hDLGk11ZwrnqqqvMKaecEnObyZMnm0ceecQ+jzejiT6rW7duga9rJrNip9kOTjzxxPDsMcrsV9a9suXHjRtnZ+5S1rxm21CGfqqz/Oh662YW0gyJ+g1oNnxdM3WePfPMM/Z6rAx1Za9fd911OdvXQqHZvnRv06xqmkXj7LPPtv9qhZXHH3/cnpO672nmjVR/y5r9oUOHDmb16tX2/+vzNNuTZjjSay+//LL56quv7PHXLIi638WaieWee+6xs0EH0Sx0xU6zhmrVmx9++MHOrqtzQTO+alUKzTKv+4audZoVI9FZsYOub65+o3PtpJNOMo0aNbJ1laefftp+v66ROmc0Y2Mu97VQDBo0yDz44IP2uY7DCSecYGfu1X1Hq+i88847dpZn1T1TnX1eM2rqvqQZo/QZZ555pp3Fxs0opdk2dH7r3qrZT3QNDaIZOHRtDaIyLXaaXUTXJa3yohnotTqAZhGNdVxSNWXKFFt2+k7NTjVw4EA7c5TOnyFDhtjZbdRGePvtt+31srQ+o9jpb9cMMzpHNLO67n26r2imUB0jXeN0Hmo1lmRm9/Vz88032/aAaPbSfv362RUIVL9Qu06zeGv1EbU7dS0Icvvtt8dckaQ0ZurMN6rjqQ6hOp+On1YPO/jgg+3Mbrp+asYizf6p375WMkuFPrNt27Yxt1F75Oqrr7bPNaub34pa2djXQqL4hFaeEl1HtaqA7k+616kuoHugjpdmgkp0tjUvzfiVSNv8/PPPtzMqqt6va0AQ1UOjV7bzKiurDurep7aS6g+anUv3E12/NFOw6hFaqUr1P9UrtF0qdD9V3EvnlWiWsd69e9u4h+opWqFJvw+dM5o5TjPIahbvXOxrochWHFMrpt5xxx32uWZvVpxGx1zfo1nknnvuORvLTCR+Qxzz/+m3es4554Tv62eccYatyyk2qHiY2swuNtikSZOUyk33Jc1+qlUItthiCxsb0bnlVqHTb8KdJ/r/Qe2RbOxrochGHFNtZc1Yq/NXDjjgAFunVOxYK+VplSWtHqT6q9qTqnPEQhzz/2feVbtI9xu17/R46KGHzM8//2wyKRMxSOKYiZ0jqtu5c0R1CZ0Pau/pGCtGovNRcSitYpXOTLRLliyxdRe1r/U5WsVHMS9dA3Vv1SqI6sPTtSEWxdiuv/76wNf1eWXBs88+G14JXHELxa9U11OsUNc2xad1jdWKjamsYquYVSLtBNVpVHax+oJKe18LierW+lv1r1YFVz1A9XjdCxUvVn1DbS9dv/RvqvHToFizo2N93333JdSHp/umrg1BmjVrZsoC/W7dCrWKCeq4qU6o+oP6aEaNGmXLUdfTVFe71oqRrv9Vvw8912oG+h7F3RRPVT/RjTfeaNtvQasJZWNfC0U24piqu6pdoGMqOsf1mbrO6VzXtVTtbh3/jh072mtfrFXsiGNmLzZ47rnn2t+BqE2uNod+J+p71b1L9V7VR9XmU/+eH+KYkdRPqd+w6P6m46dxQeonV6zjww8/tDFh9cPUrFkzpXLTZ6gOqRiK+gRUx9B3aWyDznnVYfVdarOoTy/WWAVdG2OtwBqr/6+YYmFaSUd1Px1Hte/URnDnRiZlIgZJHBNAXsl1tgNQbDQjuctC1Iw30S688MLw6+nMkqYZxdwMSMp2nDp1auB2mh041oxgmrW9rFu0aFF4xgrNkhg9a83HH38cnp22T58+pbYfmgnMfc8+++yT1/uaL9zsPpr9ZObMmRGvKXvbzapQtWrVwBnQM+Goo44Kn9tffvllzBnB7r///lBZpxl73fHQbNjR7r777vDrqc5qo+ufmw1F//7www8lttGMGm5mMp1Xa9euzcm+Fop169aF6tWrZ//WZs2alZgJZu7cuXbWC72uGQFSpZkz3TH973//6ztLhGZocNtohsRYKxto9tqy7vTTT7fHQrMaTpgwocSsP24FF81Y8c0336T0HSNHjgwfc82Mqute9EwRmsHDzY4SNJNQNva1UHhn9znxxBPtrDNew4cPD79+5ZVXpjzjpWaud3VKv1mANZuz+55nnnkm5soGderUCZV1GzZssCum6PfqaDagTK9soJVEdtttN/uZupf9+OOPJVZAc7Ol6F/tV2l8RrHTtatRo0b2GOyyyy4lZu5V/cLNFKZZf6PP02S8/PLL4d/JaaedFjiT5oIFCyJ+X37XjEysMlTovG3v119/vcRv360QqFnvSnOVo8svvzy8HyrjfN7XfKC/zx2L4447zv79QfWNiy66qNT2QzN5u+/p3r277zZuZQO1Ncs6XfvczOdqL+g6FT2j784772xf1zVV9Y9UqG3gyuW8886LO1ObVh/J1b4WimzEMXXvdDP8qT6hlT+jaVZ7zTCrberXr1/i3BfimP+jWRHdTJQHH3xwid+p6gFuhj7N4poqF1NTnHHSpEklXld7za3ApvtdLve1UGQjjvnAAw+Ez1vFV6KtWrUq3K+www47+K5cQhwzktrJaht5uXZUJlc2yEQMkjhmfLrfxVphOJH6eyJ0HrmZ3BWbVr+NH7Xtousj0deMzp07h8o6XRN1bdTxaNOmTeiPP/6IeH3GjBnhlcC7dOlSqqtiuO9RnTGf9zVf9O7dO1yf+OSTTyJeU73A1fHUP7N48eJS2w/vCiNB56Pre1WboqwbM2ZM+Hidf/75JV5/9NFHw6/feeedKX2H2mauf06rgPjF+tV2cLFJ1Tv9VvjNxr4WimzFMS+++OLwMb399tt9t9FKybH6xYljZj82qPab+w7df6Jj/fr/ru6h+1h0/Teb+1oo1KZzK6rofhcdy9AqI+51v+tTIlRXdNdBrRzutzKSVohxZfLggw/GjJeVpRVYYx1Tja/ztoVfe+21jK9skIkYJHFMAPmGZAMggxQ8dA20du3a+W6jCsu2225rt9l///1T/i5v52msJY9joZPuf9RJ7QY2zp8/3/d4DRo0KHzMtTRgaVBj232HOobyeV/zbSDK9ddf77vNV199lfZAzGSSRNSB4IdOukiuU3OnnXYqMSDZDSbfd999w42rVAJeauC7sr/00ksDt1MgzG2nAeq52NdCHIgSdO/xdmq//fbbKX2Pa3jrnhpEQS73PSeccEKJ10k2iFzO1A0A0eBVPwrSuwEeAwYMSKnc3PKuVapUCUwkUDBb96+g63a29rVQuMCukjOU7OOnR48e4cEqQdvE8vzzz4fPpccffzxwOyU4ugFifkv1kmwQW2kkG3gHkbzwwgu+23gH5T711FOl8hllaSDKuHHjfLcZMmRI2gMxvQl9GoiXypLYdNJFDqJz9woNWPezevXq8ACQ0hrcqHqh6+TVACO/hJ182dd8cfTRR4c7NfV3+3GdluocC6pzpEuD1N15reugH5IN/kedcO54PfHEE77H66233oo7QDIeJbS6zwj6fei800AVN7grV/taCLIVx3zzzTfDx3Pw4MEJJZ37xbKIY5Yc3KFBC37JwnLZZZeFj6cSqJKljvdEkrvcICIlFPidl9nY10KRrTimBpa5GJVfIoFokGWsayFxzPhKI9kgEzFI4piJ189Vdn7tLh37HXfc0W6z5557ZiSOmmocgGSDknEnPXSt9HPdddeFt5k+fXqoNDz55JPh77jtttvyel/zgRJK3d+pwcl+1M+Z7kDMZJJEdJ8MQrLB/6gt5e43QZOPKH6lbWrXru07KUY88+bNC/8+VKcMooGzsQaAZmNfC0W24pguQVYJ40ExTLUN3PdoEHY04pjZjw26viR9V1AigSbpc2Me/K7bxDH9E+rUL6pj4+f444+32+i4RicAJcLbP3PvvfcGbqfJUtwEDn5tCZINYiuNZINMxCCJYwLIN8W//g2QRZMmTTKrVq2yz7UMpB8txaSls0RLRWt5pGRpCadHHnnEPj/iiCPsMqxInRKvtLSYaCm/nXfe2Xc7b5m6pYwzTcubud/JCSeckNf7mg+8S9oGnXN77723Xf4sevtMevHFF+2ydZLqEudliZZg1DLBomUg/Zby07LSbplhLUn+6aefJv093mX+GjVqFLidlof0e08297VQuHNISzsH3Xu8xynVc86VQ6xy03KsWurRuz386b6hJXNjXSu32WYb061bN/v8zTfftEtIJkOf/8knn9jn+m3Url3bdzv9dvbZZx/7/JVXXsnJvhaKNWvW2GWdRcs+V6tWzXc7d5zWr19v3nrrrZSWX3ViLQ+upZdFyyxPnTo16e9B5rlrrH4bQcu/H3300aZevXoR22f6M4qd+5tVXwhaxlb19q222ipi+1Tqk27pcS27rPoFUue9PwTdT2rVqhW+tmm56T/++CPjh3zixIm2fijHH3+8qVSpUt7uaz7Q3zVhwoTwPUl/tx93nLRUuI5fpqkuonNS6tata7p3757x7yg27tqna6FfLEOOPPJI07hx44jtk+Xq/VWrVg38fWgb147waydka18LQbbimJlomyMyNjhy5Ej7/OCDDza77bZbqcQGk20nbNiwwYwePTon+1ooshHHXL58uZk/f7593qNHD3sO+znwwANN/fr1A9vmyL5MxCCJY8an2JWrn+tY+rW7dOxVBvL111/b45qszZs3m4ceesg+79ChQ2BbEolz94fWrVvba6Uf77W1tOpwrg9PdZWTTjopr/c1H3jv60H3PvVzqr9TVG9Q/SHTXn31VRs7Ffrw4luyZEk4/jtgwADfWIa3TFevXh2OY2e7nZCtfS0U2YpjunJo2LBhYAxTbfYqVapEbA9/2YoNujbeAQccYMvOj85Fve5+H9HXZOKY//PXX3+ZcePG2ec9e/Y0derU8T2mrkw1liS6zZxMuSXaNv/ll1/M5MmTk/4eZF4mYpDEMQHkG2p1QAZ5K3ouMOLH+9oHH3yQUmegOg4kqFKCxM2bN88sW7asRNlEa9asWbgTJpVyi+err76yDznqqKN8GyT5sq/5ds5p8GqTJk0Ct3PH6ocffjBLly7NepIIInl/k6V5rVQnthucG2tg7GeffRYuv+jgf7b2tRAoGK/BJfGORY0aNUzLli3TOhauY13XvLVr1/puM2PGjHCSz/7775/S95QV7lqpwK47tn5cua5bt8588cUXSX2HgvQuGLr99tvH3Na9Pnfu3HB9Jpv7Wig0aEAJpvHOufbt24cD+qmcc65eoWOuAZVBvOVKoDI/eDsHgjrSKlSoYA466CD7/KOPPirROZCJzyhmus9MmTKlxLkWTYNe3TUr1XvfSy+9ZP/dbrvtwscbqXO/bQ0U0mC6IO76qgGSpZFI5doJctppp+X1vuYD/V36++Ld+3SOuAF4pVH3Hj9+fLiOosEKQQM1UfJ3rAFVbjBBNF1DdS2Nruckw11r//zzTzv4z48St9T2D2onZGtfC0G24phqH7pzNpG2uQZR7LTTTkl/T1mxYMEC89NPP8Utt1133TU8gCSddkK8Nl6sdkK29rVQZCOOmWi5eV9XHd8l/SN3MhGDJI6ZP/c+JTX8+OOP9jn9BenTtdDV72KVm9rTO+ywQ6ndT77//vvwZCuHH354xADofNvXfDvn1F+5xx57BG7njpXuY+oTKK22uWJcQUkiyP61UueAi0cn0k5Q+bm+p2zvayHIZhzTvV/1fZfAHm327Nl2MLbQhxdbNmKDes9vv/2WVDtByTzunpbNfS0Un3/+eTiRLdb1p127duHYYrptc9UfgtCHl38yEYMkjgkg35ScGgNAytzMM8pMbNq0aeB2u+++e/j5t99+m/T3uEa1qBKvxuPYsWPDM5KpU26//fazGbRBMwt7aSaXm2++2TYI1bGgoI8aiZo1OGgW3WIsN4kV7HKDl5UNnEq5xfPss8+GnwfNrJEv+5ov3N8W71hEn3MuOzjTSSKa+TeRc27atGnmsssus+eeBvYpKK0Z3jp37lwmZndI9HeszmYdD80ElcrvWNfiW265xVx00UV2ljYd44EDB9qApGiw5AsvvGCGDBli///ll19eYqBttva1EMyZM8f+fYmecwqy6L6iQJKbJSVR1157rS0zDSTv37+/vT5qJQPvvpxyyin2+S677GLOOuusuDMoPfXUU+bXX3+19zW957DDDgvPsF/s3O9Yf7ffzHhB18o2bdok/B1ulQmJt9KA93Xtm1YqyOa+FopErz81a9a0x1ABx1SuP67sXPJOouUWa7v777/fbqPOBN0XW7RoYbp27ZrR+29Zpzqe68hJtB6k8tBsxK4zOxOfUew0K6w7NxI5RhqopQF1v//+e1LtKLXBXEKf66TRPVQz7ykxS3UWdSRoMEOiiQijRo2yM7Pr3rf11lvbQZuHHnqobSeWBe46pU6WoEC+3/1E9fFMUcKkm61qr732Cjz2+bCvhXbv03HSIM2FCxeWSt3bmySSyKyXOocfeOABO/hdg+B171OZa2aqWJ2AxUJ1djeYONH7ia6tusbG2z7aeeedZx577DF7L9KMw2ozeFd81H5o8JDKRLGxq666Kmf7WgiyFcfUzIhql997773mwQcftJ2s3hWVdIwHDx4cXqnkjjvuCLfb/RDHTDw2qLJLt50Qr40Xq52QrX0tFNmIY6bSNte/GkAbtPJEWY9jZksmYpDEMRM/zrrPKPaUrT48DRrSzLfvv/++bYsrlrPvvvvaPrxYEz84K1asMLfeeqs9V1XP0eqD6sNTrEUTvxS7ZO8naicofpyLdkK+7Gu+cMcj2Xtf0D0pE0kiidxXv/zyS3PFFVfY5BHdW/UencvqU4gVsy4Wif6O1d5V+1zxwlSulbqf3XnnnXbWb63Ye88995hBgwaFj7HiYZrRWbFmueCCC0okbGZrXwtBtuKYorb2sGHD7OrMWsnz+eefj1idQklDboU8tTXVlo+FOGbpxwa9165k+/C8cRfimMlffxRzUdnqHE23ba5zPGjSqET78NSOUGxGCUGKYyp+5uKY8RJRkLhMxCCJYwLIR8XfGgKyyM00pMZUULa4eAMZroKRDBd4UsVSS6RpsKRfxVQdeXfddZc555xzYn6eZgT2mxVYQcrrrrvOXHzxxTH/nkLnnSEqXpDJva7OFVXEM9Whoorj8OHD7XPN5HXEEUfk7b7mCwU/VMFO5likes6lmyQSNHNtNM1s9vjjj9uAZTFzv2Nl8cfqTFHgQ8lPmlU01XK78MILTeXKlc31119vzj//fHP77bfbBpvOBy2Brc91g1DUcZrLfc13qVx/dO3RYIFkB6Uq8KtOOS1nrpll9X4FOtSRpv2YNWtWeBUYJRHES2a47bbbfP+7Zpp4+umn7blXzFzZlea1UnUGdZRqYKUrnyAKYDmaGSXb+1qs55zOtVSOhRtYprqI6phBQS9vuUaXW/T9WXVHv+ukzun77rvPzp6E7F+TRb8Rd03OxGcUu3SOUTKDUhcvXhye6UuDh2644QZbZ4mexUZJlEo2ULsh1my4onagH71f9z59TzHLh/vJyy+/HJ6lP1Y7IR/2tVDPOQ3MyfSx0GpNY8aMsc81ACx65TM/KmfFX6JpEJsGxGsQdTFP5JCta6WoDqGZGjUYRe0EvV9lpDicBuGpvrJx40Z7rXvmmWfCM6XnYl8LQbbimHL33XfbtrcGEPXt29cm+2sQmeqgimmq/JRAq0QDl1gehDhm8r9jDWzVsfYOUojHm4CicytotYlY7YRs7WshyFYcU3VENxA9Vttc10rvzNEqu6CBnWU9jpktmYhBEsdM/DhrUpNYA4Z1jHUd0vUonT483V/VrlPisd85qTqkkgj86pJeSmr1W9VJdUzFtTUoutj6f9K9n2j25lQG0AbRoOehQ4fa56rTaOKpfN3XfOH6BnLd3k02mVxGjhwZ2G/x8MMPmx49ephilszvWG0JJXSkWm6KF+ved+WVV9o2gmLHzZo1s9dgTcChmJn6Hi655BI7SVUu9zXfZbO9q7a2ElK1iue7775r2wrqw9P9U+MSdM/TNUBJcYpDxusPII5Z+rFB1Xv0fm8fa5BE2njEMZM/5zSIPJ0+PFc2QavCJ9qHp/qtxk/4xTGVJKQJVapXr570fiLz12TimADyEckGQAYpGCTxGkyqqCnjVEF9JQskS1nios/QoHQFlhXUP+aYY2zFT5mqmqlbneTnnnuu/Z6gYKU6EZT1rAFDamSr00Mdt5opQAGuSy+91Dbmn3jiCVPs5ZZI2XlfV6ZvpoJ/mtVm5cqV9rlm4QuawS0f9jVfpHosUjnngqijwCWJ6PzRrCixKOB/wAEH2OXyFJTUjJcKtk6cONE+NIOtzml14qnzvaxfK73bpFNumlVDDWd1vCjIpYej66g6YxTQzId9zWfZPufUkFaSgILMClrq4aVEg5tuuskmIATRDCCaxVkDkDQbg5IStOSnVjpQB93kyZNtUEYzG3lnBCk2rgxKs9zUeaq6iOoPKivN0O23NK5WYnLLyEf/rrK1r8V8zqVyLHTvUvBQHn30UfPQQw+V2EaDoDU7kd++eWmAmD5Pg5h1n9O1VwFO3StVz1H9VDODaSa/WDP0IDvX5HyoS+W7bB0j174TrUagjk8NXtDKPeqoUxtNM+RPmDDBfPzxx3Ym2RkzZpg6deqU+CwlWR5yyCE2IV33Pv1/1THfeOMNe/7p/ZpRWrOX6bOLVaJ1uNL8bbvrpjrIBwwYkNf7WtbufbGoLeZmAktkIIo60tWGc/c+zTSrxEp9jmI1GvCuc0/LpGuVkWKU7fuJ6htanVM0++XMmTPtw1GbW4P2/GYr5t6Xmzimay+cffbZ9rnacRo0pIejAUSaJODYY4+N+TnEMdP7Hat+kSi1pVVuGlypFUUUd46m1zTYPKidkK19LQTZuv7oXNLKf4rv6xqp9rffKjuaPGX9+vW+++cQx8yuTMQgiWNm9jgrbqE+snT78LSCuAYNqZ3Wq1cvO1mHkhHU56ZYiWbxVvKqYqB+NJuwrslK8NFAJP0NmqRFK+Hp+dVXX20n1fHGbYpNOtfQTPWLKZblYppaiTdoVuF82Nd84T13ctXe9SaJqD9OfQqx6N7Xtm1bu4qBYiqKuygpVoOpleys34CbACmoT6kYuN+x4hnxEkAz0Tbv3bu3vQ6qr07HWw9H36+JbTSxol+CdLb3NZ9lu72r+5Pa3roPqY9Nq517aZZ0td29K1tHI44ZWXalXW7qu1E7QAn/ilN16NChxDbqN/WuuBPUxiOOmd0+PDepnvrwvBNhOoplKrEnqNwc9akrjqnYiotjqr9ccUyNWVGCniZ4UN9BsdVLso0+PADFimQDIINch3QiSygqS1+ddHoky3UEqDKqhxpy11xzTcQ2Wo5OwRB13Klx3qdPH7vEsZc6vf1mcx44cKDt+OvevbtNXHjyySdtpVON/WLkXVIsXtmp3ByVXaYq2d6ZNWLN4JYP+5ov0jkWmaJOu0SSRESvaZCzN/vc0Ywc77zzju1s0DmtmSA0iMy75GRZvlamU26apU0dOhq0pw7X//znP3YmKQWNNQBWDXJ15GhwrcqzRYsWOdvXfJfNc06JPLoXucCIZj/RQ8F9JYtoQPubb75pZ53VjCd+q1JoJlpt67eUuAax6H1KQFFinjqINGizGFfx0bHUDDLZKDeVg2Z90vdpkJCWvvWeUxrgqutb0O8qm/tarOdcKsdCQX+V01dffWUeeeQROzBPK8G4GfF+/fVXOyuzN0nEb5ldJbiqTuq3r5qNXTOiaLD01KlT7aztmtUWub0m50NdKt9l6xh5B3qpzqIZadVJ5129QJ2qunep3qI2nu5h0Qnhe+65p53txm9wnu59WnZeHbQaMKNkTJ33seqvhSzROlxp/baVsK8BQKK6aKzkyFzva1m89yXSNtfgIdURY9HgEsVi/AY06J6otr3qrRoIr3PWL6GvGGT7fqJ6ha5poriX2tGaVVF1FrXp3n77bbuCmeomWhbee53j3pebOKZo4IlmgNXAISXp6PxQ0ps6tpWorAGSrsw0kMsvdkIcM7u/Yw0eUjxZ1zHFrDQY9s477wwPrlT9RZPUaBBCUDuBcy43x0L1Rc24rfdqQOTrr78e0QegeIrKLqishDhm9mUiBkkcMzvHOZk2ngbPKtFAs3GrDuOl2Iv6ANQG1Arjxx13XIn+OiV7+a0sqAQ+DeDUOa7E1hdeeMEORDvhhBNMMcqH+0mis+Pnw77mi3w4FokmiTjqE/c751QPUp1H55xW9lW9VQlExbryZzbvJ4sWLbJxEw1+VoK+jq0miFI7W+WhPjzFkhW3Vn+QJtDI1b7mu2yec2rHXXDBBfY+JRpHonLU6kyaeEH9RGrX6aH7n9+qFMQxS5ZdaZeb4sLDhg2zk0Tpmqg+PO8s+Wq3R9clgtp4Zf0el804Zvv27e3EGkooV31EiQLqj3XxLsX6tQKod+U6vz48xWE0bswvjqnzVHFOrdSrPgOtNOPOb6SGPjwAxap411QEcsDN0JpIJdEFGxOZQSXoe0SDw5QxHk0znPz3v/8NV2S8gTDHL9HAUaeeGu0u8KJlC4uV93jGKzvvQKBUys7PqlWrbIe4aMb7WLNr53pf80k+HItkll/VIGa/znJHM4IrWOZmkPbODFdssnWtVMa4Zn1Sh41moVFygWbvVmKIZpe9++67bbCyefPmdmCettX5mIt9LQTZPOcUJHGJBjrPdI1UEl2/fv1sMEwBFQU6NDOR/vWbuUszFfklGrjzUZ3v7rzVLA2TJk0yxUgBLhc4Ku1yU1BSdQ8dX3USKOFD/02DHDTDtjpQlaClcnS8ZZTNfS3Wcy6VY6Hy0mx4mmFI55SWT9U1U4PBtPqVZjfROXjQQQeFE1f9zi1tFxRQVcLjK6+8YgcsudlX1OGO3F6T86Eule+ydYyiV/pQ28ubaOCoM0DXVtHMfNHnkWbIjDULsDrHlbQgqgNppYRilWgdLhvthOhEu3zb17J47wuiwQ0a9Cyqv6g+GYvO06CZE/W3aKUStTVEyUHFOntiNu8najO7RAMNylMyq9oHSqDSgD0NZNBKSq6+ceONN+ZsXwtBttq7am8r5qFEA7ULdK4pgU7tciW1KhFHndmKZWpmZg2W9KsrEseMLLds/I51Prnr2ODBg20ZKVm5S5cu9rnOM5WLG6AS3U7gnMvNsdBASDcpg84tDUZRcpbubVpFUv/qOzSw2YkuO+KYhXlNJo6ZneOc7Dmv/h5N7hVNcRi30qQm4FBSXbRYA5lVF1Ufnvsu+vAiyy3VsgvqZ1DilmgFXU1mFIR7X34di2Ta5vHOOcW2XZ+F+t2LNZk8m9dK1fnVTlD7QAnkSp5Sm08DYjXg+fbbb7ev6Zz75ZdfbDvBu3J5Nve1EGTznFPygBuIrDaDkv6VfKC2ueKPaqt72+6une5FHLNk2ZV2uSnBQ204TTSlc0kroun8UvtA/+r/67+rHJ2gNh4xlezGMbXygOsv0IQm6o/TxLG6hqrfbsSIEXa1edcH59eHp+1ixTHV36B6juh+pyQGpI4+PADFimQDIINcpU2zGsSigcQKHkr16tVT/h7REtZBMzErg9xlyWpgZrIUVFEHkmgWWm8Dpph4j2e8snOValXEtbRfJmgAgjLIExmwnut9zSfecyfRYxH9vkwliajDbtddd037MxU8c2WsZQqLlfsbNdjGXQvjlV0q5aZG8ZIlS8KdLX7LxmtGRQVWXJlGzxCcrX0tBKlcf1I5Hlpm3JWJAiUafOLnjjvuCAdN3PKRyVICg1MWzrlsXCs1UH3s2LE2GVKrFGjAnmZN1AAHJVxpVkzVXbznYK72tRjPuVSPhe5hKivNZqN6g2bdUzlq9i8lIKijQIP3tBKIX7klQgmsml3F1YWnTZuW0r4ic9fkbF3XC1m2jlF04pXuf0HcNVQdskqWSxb3vtL/bev+p1nCpEGDBuE2dRDufSWPRTbufX68y5DHa5snQvfUM888MzwY5dNPPzXFKFvXStVJNNhENFjWb9CenHXWWbaz1Q2OVr0j2/taKLIVx9SAIXc8NbGCVqzzi0FqQgCZP3++TYZNFnHMktxx12CSVAY1KIlRMWW18/R+rSCigURKWNTASw1W17XN/T6C2nfZ2Nd8l+04ps4n1Ue0cp3KR+WktrkSepo1a2ZXq9BgIieVNl5ZiWNmSyZikMQxEz/O8c5D9de4OkS6fXg9e/YMrx4ZTTNBu4FIqfThadCYEoxEg3SLdVBYrutwqpe430Np9OEVa31Tv203qDEXx8KbJKJYdcuWLdP+TLeqWrHf+9zvWPENHcfSapvr3NJkYa6/Z6eddvKtj7p+O33Xww8/nJN9LQTZuv6orqIV6USTuKkN7kfJ/y5x2bXlk0UcM/PXSvXRTJw40Q5MV5xFq3GqnaB/lVCuvnVNDODQh5cfcUxNEKaVJ5SMpb42JYVonMq7775r6606D997773w96TSvlO/hDuf9ZlaeRmpow8PQLEi2QDIINcI1vJwfktTOYsXLw4/dwMlk6FOAsdv8KyjiqYGN4hmD0uFZj5yjXTNGlCMvMELb9n4ca/7BTxS5WbkVuDNO6NUPu5rPtlqq61sozeZY5HqOedn+PDhCSeJJErL3bn9W7ZsmSlW7jep64oGtMYKWGngearlppkzvB03sWak0fKsEt1wzta+FoJUrj+6rjVq1Cip71GwxN1DY5WbOuk0k40bjKIZ81O9x5WVcy5b18quXbvaDk6tbqCgpWZZ0/9fsGCB6dOnj33uuBm6c7WvxXLOueXA0zkWuqcqAVLXMi0LPnr0aPPhhx/a+p86DxS8dB2r0eWWqLJyzmWDZpB1gxVSPV8y8RnFLpV7nzrSFfxPhrZ3SeLqCIiVKOxt/6XSxisr52Eu7yfq5HH1xhNPPDHuMtrc+0oei+iy8eNez1S5/fvvv/Y+6O6JbrB6usrCOafrkhtEVJrn3MKFC8OzWKodEDTxhrgkH7XTlPSa7X0tFNmKY7q2uWau9A5ujuZNzkq1U5s4pn/Zeet9ydIqZUrcUeLxZ599ZgeiKClZ1zStXqZVYObMmROzfefdl9Lc13yWizimkgHmzZtnH0oS0WAUzQ6sFa4OOeSQcNtc9VA3ECwZZSWOmS2ZiEESx0z8OOuaFmvVKZWBysLvOGeyD0/nkbs2pNuHpwGDuqcXo1TuJ0rEcCu3Z6oPT/VIXVvzeV/zjVuZKhd1b016k2iSSDLcxGPFfO9L9Hes5DjXRivNPjzVMd3A2aA+vNLe10KQrTimBqW7cytWuanN7l5X/4WbHC4ZZSGmkovYoFa0Vl+sykRJyOrDU7mqnJRoQB9ecuWWTNmlU24a96WJUlSP1bVQfXgffPCBrUNq9ZA///wz3FdOH17uZSIGSRwTQD4qvqgtkENuWSkFIb2dmdFUWXf22muvpL9HMzA4sToDva+nGqjyLvnlBsAUG28ZxJodVMdSHTLR70nH7Nmzw9/Zu3fvuNnMudzXfD7ndL4pmB7vnFPwXrN3ZXL51USSRFI554r1fPOWW7zf8YwZM8LPU/kduw4jlbtLJggKeLlzL7qTKVv7WigdA252wXgzKbtzTp3VsQYB+fGWgd8yj14arOL3vkSVhXuc93esAVqxZjhLt34STUFqDdTTDN2qu7jfggamuN+UOtPyYV/zUaLXnx9++CF8rDJxLHSeH3TQQXZmPG8ylis36dChQ0qfXVbOuWzQYHQXzE70mqyZ17wzCWfiM4qdrlGaQS2ZY7T77rvHHVweTdu7Omqi7btU23hl5Tx011B1tsTqjCyN+4lrJyQ6oCGX+1qo9z4NEHCTIWTqWGiWbnf8TzrpJNuGyISycM6p40zXvmSulRqc7AbWZbOdkK19LRTZimO6MogX8/KWayrtu7Jyzu25557htlWs37EmyPj6668zdq3U8VSySI8ePUynTp1M3bp17X/XIAetuOTXTsjVvuarXMUxNehZA700MYBWhhF9v5uRuW3btmn3HRTr+ZZNmYhBEsfM3HGmDy+/KMbs6uexys1bp8nU/USTp7gB0Ypx1qtXL2/3NZ/POSW6xYp3eM851R8y2TZPJEkkGWXh3pfotVK/YSXup9tOSKaNl2ofXrr7WgiyFcekDwucHK4AADDCSURBVC/zchUb1G9Gq1Po/qbVX6L78DS43Zvwkct9zUeJXn90rFyyUyaOhcamtGvXzvbhtW/fPnz91MoGDn14uZeJGCRxTAD5iGQDIIO8M3CNGzcucLvx48eHZzTSLELJ0sA9F8SYNWtWzIqrmw0l1dntXRBNs1ilstxWIVBDyWX3urLxo4aV6zxT50wmKPs4mYEoudzXfD7ntDSdlgP3o+CRsvJFgyf1W85kkohm6c7EZ4qWo9dy5sU8s4a7hrngVSLXylR/x+6apd9ArBnBlOnvBitFdxZka18LgWYWdLOQqEPazVwSTb9hzWifbrklkumvAemOG+iQ6sw5xXzOuWulOrE0m2G837HqDG6GpkxTvWXq1Kn2+emnn57X+5prrVu3Dg/qzvX1RwNRnnzySftcx1tJCKkoK+dctrjzRZ1lLljtV7eYNm1a4O8jE59R7Nwx0u933bp1gfejuXPnpnWMunXrZv9dtWpVYFlEt/9SaeOVlfMw2ba5EmnUqZYu/UZGjRoVvo4nMkAwV/uaj/R36e+Ldyy8r2XquuRNEtGS5JlS1s45zW7u2gJ+54drt3t/96XdTohu42VjXwtFtuKYruwUo3SxKj/e8og3kK8sxzHV9m3VqpV9rjZT0KB1zXDo2u2lWYd74oknwknLffv2zet9LatxzKDz2s0u69c2T0RZiWNmSyZikMQxM3/vU5mksuKVkrI0ECxeH56uB+5cTLcPTxMKJLvCbKHQtfDAAw+0z7WKqhswHE3XVjchRybbCe7+lUgfXi73NZ/POdUBJ02a5LuNjq+LA++33362HzSTSSJKlEyl78CPd+W0Yr73dezYMbzqZjb68OK18ZSYunTpUt92Qrb2tVBkI46ZqbZ5IspaTCUfYoPff/99+Hp92mmnlZhQLp/2NdeUOOAmVMuH649rm2uftCJoKsrKOZctmYhBEscEkHdCADJq//33V9Qp1LBhw9Bvv/1W4vUFCxaEttpqK7vN8ccfn/L39O3b135G7dq1Q7/++qvvNjfccIPdRo9XXnkl6e8YMWJE+P39+vULFbPBgweH/9Y33njDd5vOnTvb16tXrx5avXp12t/5zz//hOrXr28/c4cddght3rw5b/c1Xy1btixUuXJl+7ceffTRvtu88MIL4eP19NNPZ+R7Bw0aFP7MyZMnhzJl4MCB4c996qmnQsWsZ8+e9u+sWrVq6Keffirxuq5r9erVs9scfPDBKX3HM888Ez6eN954Y+B2Dz/8cHi7+++/Pyf7WihGjRoV81jJaaedZl+vUKFCaO7cuUl/x19//RW+T+62226hjRs3+m63fPny0NZbb223a9GiRdLfs379+lDLli3t+8uXLx+aN29eqFjpmLr7TevWrUP//vtviW3ef//9cNnedNNNpbIfGzZsCLVr185+R4MGDXzrL/myr/ni/PPPD/9Gv/rqK99juuuuu9ptdtppJ9/jlQkPPvhg+JgPHz48pc/Q9aBKlSrhek9ZM3To0PAxHD9+fEY+c/r06eHPvOSSS3y3uf7668PbfPDBB6XyGcXu7bffDv/9d9xxh+825557rn29XLlyodmzZ6f0Pd999529d+pzrr32Wt9tVK+vW7eu3WaXXXZJ+jt0T23Tpk3470l1XwuB2lpNmjSxf+eee+4Z+vvvv0tsM3Xq1PCxuOyyyzLyvUOGDAl/5uOPP57X+5qvLr300vDfOm3atBKv6/joOOl1HTcdv3Tp3KpUqZL9zIMOOiiUKYr/qE2uz23UqFGp3afzga4nugbqbz3vvPN8t7n99tvDZTthwoSUvmfHHXe0769Zs2Zo1apVgfV81TW0XY0aNUr8RrK1r4UiG3HMm2++OaFYx5VXXhne7rXXXkv6e8pSHNMbxwg6VkcccYR9Xe3moPMlXTo/3PmkOmM+72tZjmNGW7t2bbgduccee9h2ZSrKUhzTj2JW+tv322+/jH1mJmKQxDHjU31Px1DH0q/vZMmSJbYMtM0xxxwTStXJJ58c7qNZsWKF7zZqY7rz6Pnnn0/6O8aOHRt+v8q+mOk64/5WxVj86Nqq13Wt1TU3Xeqz23777e1nbrPNNgm3PXKxr/lK55hrEx166KG+27z++uvh4/XAAw9k5Huvu+668GfqPCmN9qr6aovZgAED7N+55ZZbhr7//vsSr//++++hbbfd1m6jfpZUvPrqq+HjqWMb5Lnnngtvd8stt+RkXwtFNuKYii+6vjm1vdUG96N6vdrurq8vle8hjpnd2KDuc26MSa1atXzvT8Qxg+MYU6ZM8T1e6sPW640bNw7s806Xd0zEE088kdJnLFq0yMbRXL1n06ZNobJE8Yp4Y7CSlYkYJHFMAPmGZAMgw959991wZaBr1642eO8oQOwGNqojO2hgowaX9O7d2z6COqPVWHadfe3btw/9/PPPJRreW2yxhX19r732KlEZVPLByy+/7NuRqEruQw89FO780PfMmTMnVMzUqeI6oxVkVoPN2wi4/PLLw+WqCp+fiRMnhstt0qRJcb9z9OjRKQ2WzMS+FpOrrroq/PeqA9v7W9eAOBfIUOeZX6NIg1VcuQV1jHrpGGuQrD5TAx0STRK55557Qu+9955vQPqXX34JnX322eG/Q/vqN8iomHz99dfha5SCRd6AhQLQLpihBtjHH3/s+xka7O7KTscw2h9//GEbw/qcihUr2sFf0ddUDZp11zr9VvwGP2diX4uJGyyuQcPeQL3OBe+A5LPOOsv3/V988UW43IIS4S644IKIjrKVK1dGvD5//nzbmeu2URDFS/deXQ++/PJL389XmbqORT3OOOOMULF75JFHwn/vOeecExHQ0iB2F2zX9W3dunW+n3HqqafactMA+CDqZPELUGugeceOHcMD53UPLM19LRa63lSrVs3+vRoM4u0s+fPPP+0gKnesgs4ndVa7cy6oPqcAloJn0fcefYfqKCozfUefPn18368g6mOPPeY7GELGjBljB1m6fVUdtKxJNtngxx9/DJebjm2QY4891n6mBqmr/u+l4+zuX2qXlOZnFLtOnTqF20XqBPfe+zSg3AWMTzrppMD7jivPYcOGxR2wpXpL9OAyJdm566hf4o/OVyVXzpw5MzCZwf0deqgjttjp+uf+3lNOOSWi81PXQzdoWZ1nQQMbdR9SuSVaVzjggAPCvxVvLCAb+1os9Pfp73TtLf12vUmJbtCWHhqQ6eell14Kn3OzZs2K+53eukeiAzs///xzO4BW1+ugDv7tttsu/LnR19didOKJJ4bremp7eena6RI6dC0Kqve4cgsaZKT/7o5p27Zt7UD46Gul7ldum6uvvrpU9rWYZCOOqZilSzrVoJToAeeK1SgO6ZLumjZtWqIDnjhmJB0fJRvreCkR8dNPPw2/priTfvveWFlQ2bty03M/qlfoHqX4ipe+48knnwyX67777hs4aCIT+1pMshXH1OCyH374wTfZ2J3Xqq989tlnvu8njpn5ZIN4ccxMxSCJY8b30UcfhdtwGvzsTTjQMdfkF3pNZaHj6UexEleeQYMsFy9eHL5Oqp0QHTNRm87VOfR7io7JjBw50m6zZs2aEp+tbdUWdUkRGmDrN0lFMdE9Q9dG1y7yToag66XKJF4d8MMPPwyXWyKxGfXnpDKwMxP7Wkxuu+228N97xRVXRPSR6T7kkqjU7xmUAHfcccfZclP/ZzyK1ag+6RJqEx0sqbi2YqR+dRr1G1144YXhv0P7qvZpMVM9wo1D0EBZJWI5GlvQvXv3mIMjRTFNd875tZ11rF1ZqW2mMoguL7XPXHxc11S/wc+Z2Ndiko04pq6J3nak2uJeaqurze62efTRRyNeJ46ZuzimYmB+8WOVWZcuXcJ1TcXWghDH/B/VI+vUqROOZXz77bfh11SGboI+v75sb7zDnXPqQ/ejsUeKpUTfJ/Udd911l+1P0HcceeSRvmNXVOaKu6h+GjTOySVYltVk8mSTDRKJY2YqBkkcE0A+IdkAKAW33npruCKiGRsOP/xwOzDEVRRUkYg1K+yBBx4Yfn+smTIUbHQdcfrsDh06hHr06BFubLiZ/vyy+JU56QKm2l6DR4866ii7n26WCdcJqAFiZYGCse5vVyNKQWU1kL2D43SMghJAFDRx2z377LNxv69Xr17h71KmcDb3tZgosH7YYYdF/Oa7detmOzrdf1MjzztIJboR5rbTORTPm2++mVInqOuA0jmlQLMaDCojlZ3rRNJj5513Di1cuDBUFqhR7YJaCnodcsghtoPHdZLoce+998Zd4UWPoGOmziPv5ym4rIa2fiPewT/6/lgdDOnuazFRoNYN9tZj7733tsfTJUHpod+1goV+dJzddlqBx4/e65Ia3DFXcoBmfGrVqlX43ueCbtGBEzXw3esazKAAs2ZK1H66jh730H9LdRa/QuNm+HED9XUuqLPTDSRX4o134Ec0FzDTQJF41zr9RjTLngL5Snp036vrXdDAwEzuazEZN25cOFCof3Vc9Xt2AzH1uOiiiwLfr9nq3Xa6JsaaSU8dNxp4onJTMqvrFNdD51/QACI3kF7XSd2HdZ7qM1QH1nXXfYbKrywkQrr2gAs06qFj4o6Drmfe1zRYNZqSdtz2p59+euD3aEBg8+bNw9sqKSX6Wqe6RXTSVqY/o9jpvuI6P/XQrOo6Rm7gnB777LOPnSktqDPA27EeRPVSnePezmudS6qjuk7ToEEOGoDirfvq/qxzUO9X+bp6jB6qOxd7p7jjTehVnUCdZmpvu7qEBuVoAEkQ18mie1E8GoTrvqt///5Z39dior9Tf6/+bv39um7qeLi6iB46XkGuueaa8HbvvPNO3O9zA8pUtw86j2N1QKneo9nhdb7pHq2ZytxrOvcSSWovBkoC1bXQe+/QtdJ7j9G1NGjmViUUu+1OOOEE320U43BJcu73ofJTPUXni4u76aE2W1A9P919LTbZiGMqhumNfej46pjr3HYTOuihWfQ0GDoaccyQb33RDUzXQ/VNxQa91yAd46ABdkoWcNvpuR91sLv2l+o/+nydW962iAZax0uES3dfi0m24pguXqX6pGKQOt6uve7ueUqMC0Ics+QgRm8bTg838FHnQ/RrfvePROKYmYpBEseMTwk17ngqXq/zUsfatbtUBrH6eFzihx6x6o/qW3MxHdVv1d5TH57qHu79ipv4TQ7h4jl6v7cPT+e095qq2I3us2WBro3eNoHuQbq+eWPVKsugiZy8E0FowF08GojrtvcOHszGvhYT1eH123V/t/oxdSxUH3DXO9VBYyXMuHZxIgle3lVxE0lOcNzkRjqndt99d1sfVjtDA6a97QzFCVJZ0bkQaQCsi8frGqZjoraCdxxBrFXFFdN02wXNoK9EfjeTth5a9VhtBLWvvX1OakvEutalu6/FJBtxTNVJVRd12+kcUbtQ54za6O7e51bIi+7DI46Zuzimu9apLaZ4m841/R7c9Vhll8hqrcQx/2fy5Mnh+4TKSmWmsnMrFOsRKwFEfeVuu6CxCqq3uHqrysv1GbhVRvTQNS8o5u/a9t44pq4LimN66yb6HSiuWhYoScPbhvMmSKk/2vuaEsdTiWNmKgZJHBNAPiHZACglWvrPGzB0Dw3gUoUzlkSTDWTatGm2IeAdPOIC0aq0Bi3PqsFmyoBUoz16H11FVZm2fjMgFTP9vQpyuYCEt0Gn2TdidXolk2ygTjg3eEKB6Wzva7FRQFYDOGrXrh1xLNQgVmAjaLbJVJINXJKIjntQ9rcf/SZUXt6Bm96HGnIKdEXPFlfsNPhHg+Gij4c6NeNljSfaSafGnma+ceec328kaJaqTO1rsdG9RYPooo+pOloHDRoUcwBjIskGokHNGvTiHajsfWgQbNAsEDqvdT5pFrjoa6T3fqzzMtHVSYqB/lYFRNyKH97gkTpU43WaJZJsoCCkmyXR+1CgTedaoh1z6e5rsdGAK28CjndgSrwZRhJJNtCsJgqYeQczezsjNFNNvDqJViTxq/u6ziAFz8rC6i+OgrR+x8LvoVm6U002cIFGzVoUXcdQeao+752lsTQ/o9ip/q6BBt4OZtdu0u8/Vh0u0WQDd/9TvdY7KMF77wtaxUT1YSXC6lrhTcrzPlSP0WDCsnTvc+00b6eJe2igT9AqSKkkG3hnZk5kgHum97XY6O/1Jt94203RM+Klk2ygOkWs63EQTRigmS2VoOV3vqmdoY7FePGfYqNroa6J3s5OVxfUNTTWgOREO+ncbIy77LKL77FX/ejuu++OG09LZ1+LUTbimKpzKi7id5/ScVe5B03GQRzTn2af1CCD6GOqeoTqBbHKI5FkA8W9tMKddwCYtzNc51qigyTT2ddik404ppK8NVAyutw0YF3J/bG+Q4hjlhwImWj7Tg/d01KNY2YqBkkcMz4dS28SjrfdFLTiS7LJBu7+p/M1ug9P9z5NohK9arl3FUnVT6NjY97zWa8HrTxUrHT90kq43oGseuiaet1118W8LyWTbKBydUk+ijFne1+Ljfor1W/pHXiph2L3qh/G64tOJtnAmyQStMqrnxdffNEmA0W3D9xD/RRq92um/LJE9XDvKtPuoSSoWDOfJ5psIGoDqC0QHXPTQ2Wv30jQSp6Z2tdik404purvd955p28cSw/FS5544gnfOCRxzNzFMVXP906M5O3D0bmWzEpJxDH/Ryur+tX3lGCnyaZixeMTSTbQOAa1J/zGmajdF3SueeskmrTMr43o2qJKVlDCXlmhtnei7Tsd+1TjmJmKQRLHBJAvyul/DIBSM2fOHLN48WJToUIFs9NOO5kdd9wx7nsmT55sVq1aZZ/37t3blCtXLu57li5daubNm2d+//13U69ePdOyZUuz1VZbxX2fLgFLliwxP//8s/nll1/sexo1amT22GMPu89llY6Fyk7Hs2HDhqZFixamYsWKMd+zYMECM3PmTPu8VatWZvvttw/cdtmyZeaTTz6xz/fcc0+z++67Z3Vfi9Xff/9tvvrqK7NixQpTvXp106xZM1O3bt2Y79m8ebN5/fXX7XOdOx06dIi5/ZgxY8zGjRvN1ltvbbp06ZLSPi5atMj+BtauXWuqVatmrwtNmzY1ZdkPP/xgHyoPHYtEzompU6fa65d07drVVKlSJeb2GzZsMLNmzbLnjOi3sffee8d9Xyb2tVjpN/z111+bNWvWmPr169vjWbly5Zjv0fn50Ucf2ec6R/WId5+aP3++PW/++usve27vtttupnHjxgnt47p168yPP/5ozzn9BmrVqmW/s3bt2qas0m9X54LqDvr96zes+0c8yVz/li9fbu+Lq1evtuda8+bN7fUuW/tarHTNU31P5dCkSRNbh4hXT5w9e7aZO3eufd6pUydTp06dwG11jul8++mnn+zx1v0pVn0m6BzX+/Ub0L7p3rrXXnslVC8tJh9//LE9BonQvWT//fcvce2aOHGifb7DDjuY/fbbL+7n/Pnnn/Z8UTtC1zhdk5M97zLxGcXut99+s/c+d31T3TteXWLlypXmgw8+sM91HdO5G8+mTZtsWaidtuWWW5qdd945obakqF3g7n06r3XvU/suXr24mOl+ouuh7ieVKlWydYltt9027vvGjx9vzwtdw7p3755QO17Xvl69eiXUjs/kvhYr3VN071u/fr09DrqnlC9fPuZ7vvnmG9tGlvbt29t6aiba8bHOcd2j3XVf55r2M169uJjp2qNrmI6N7ie67tWoUSPme3Su6ZwTlYPKIx7F277//nt73atataq9Tir2Vtr7WsyyEcf8448/7HVO79H53KBBA3vO6JoXD3FMf/r9fvvtt/Zc2GabbWz9ZIsttoh5LNXGnj59un2uumisuJRiWTrXVL/Qb0NtkVRjIansa7HKRhxT96eFCxfa461zTW3zZO5PxDH/n+Je7733XsLH7cgjj7T3pXTimJmKQRLHjO+7776z9z7dv3TfU9srHsU2de7KMccck1Bfmtpnis+ova9zXX14iZyPuvepTuz68NQ+VGxM53NZ7sNTPUL3Ex1PXd90P9GxiUX3sWnTptnnOv6x6o2ptOMzua/FSrEO3ft0PijGrHtfrPaao3ufroWqrx9yyCEJteN1fnXr1i3pffznn3/sNUHnnK7/2k/F5hKNyRQr1SdUH1QZbrfddvYaFM+MGTPs++Twww+39Z1YFPNWO0HXV5W3a1urDEp7X4tVtuKYOt467mpfK5ase6mOfSKIY+YmjqnzTDEx3aP029D1OJVYCHHMSCoz1feSiWOqjqCHHHzwwbauEESfq/NN7QqVs9oIyd6fdI6rbql7seqZalfqPE92vEShmzJlii2vRCgG0qZNm7TjmJmIQRLHBJBrJBsAAAAAAAAAAAAAAAAAAAAAAIAIsVPoAAAAAAAAAAAAAAAAAAAAAABAmUOyAQAAAAAAAAAAAAAAAAAAAAAAiECyAQAAAAAAAAAAAAAAAAAAAAAAiECyAQAAAAAAAAAAAAAAAAAAAAAAiECyAQAAAAAAAAAAAAAAAAAAAAAAiECyAQAAAAAAAAAAAAAAAAAAAAAAiECyAQAAAAAAAAAAAAAAAAAAAAAAiECyAQAAAAAAAAAAAAAAAAAAAAAAiECyAQAAAAAAAAAAAAAAAAAAAAAAiECyAQAAAAAAAAAAAAAAAAAAAAAAiECyAQAAAAAAAAAAAAAAAAAAAAAAiECyAQAAAAAAAAAAAAAAAAAAAAAAiECyAQAAAAAAAAAAAAAAAAAAAAAAiECyAQAAAAAAAAAAAAAAAAAAAAAAiECyAQAAAAAAAAAAAAAAAAAAAAAAiECyAQAAQIEZPHiwOeOMM8xDDz2U610BAAAAAKRh8eLFtn2nx4IFCziWAAAAAFDAHnnkEdu+++9//5vrXQEAAAAyplwoFApl7uMAAACK0zXXXGNWrFhhqlWrZu6///6k3nvTTTeZJUuWmCpVqpgHHnjAlCtXLq196dKli5kwYYLp1q2bGTt2bFqfBQAAAABlzeeff26GDBlin/fr188ceuihCb931qxZ5sEHH7TP+/TpY9tn6Zg+fbpp1aqVfT5lyhTTtm3btD4PAAAAAMqaG2+80fz000+mcuXKtr2WTD/c7bffbhO/K1WqZN9boUKFtPalZ8+eZvTo0aZz587m3XffTeuzAAAAgHxRMdc7AAAAUAjWr19vnn76afu8b9++CQ8A0SyVSjZQfmf//v3TTjQAAAAAAKRn5513NsOGDTMbN240ixYtSirZQLNUurbhJZdcQlEAAAAAQI79/fff4XZa7969TceOHRN63/Lly831119v/v33X9OrV6+0Ew0AAACAYlU+1zsAAABQCE499dTw8+effz7h9w0dOtQmGsgpp5xSKvsGAAAAAEhcrVq1zFFHHWWfT5o0ya5El4gNGzaYV1991T5v3bq12WOPPTjsAAAAAJBj3v63ZPrwlISuRIPozwAAAAAQiWQDAACABOy1116mZcuW9vkrr7xiZ8BMxAsvvGD/bdKkiV0yFQAAAACQe24gyebNm22SeCJGjx5t1q5dG/F+AAAAAEBu7brrruaAAw6wz0eMGGH++uuvhN7nEhMaNGhgjjzyyFLdRwAAAKCQkWwAAACQIDeYZM2aNWbMmDFxt//000/N/Pnz7fMTTzzRlC9P1QsAAAAA8sERRxxhGjZsGJEknuhAlEqVKpl+/fqV6v4BAAAAAJLvw/vjjz/M66+/Hnf7mTNnmq+//to+P+GEE0zFihU53AAAAEAAassAAAAJUrDxsssuM3///bcdZNKnT5+Y23uXaj355JPDz0OhkJk+fbqZMWOG+fnnn82qVatM9erVTfPmze2Al/r166dVJuecc475559/zHHHHWcOP/xw3202bdpkBg4cGA7AHnTQQYGft3z5cjNhwgTz3Xffmd9++83UqlXL7LfffnZfq1atmta+AgAAAEAuVKhQwQwYMMDcc889Zu7cuWbq1KmmTZs2MdtFEydOtM+PPvpo2y5yVq9ebd5//32zcOFC28bTaglKZDjwwANtW6tcuXIp76e+89VXXzVbbLGFeeyxxwK3GzVqlBk7dqypUaOGue+++wK3075NmTLFfPjhh/Zv0r5pJT61HbWiHwAAAAAUor59+5qLLrrIrF+/3vbPqb2XaB+ed+U69eEpEUH9eEuXLg334e2xxx62X2ybbbZJaz//85//2JUXjjnmGNOtW7fA7c4444xw32SnTp0Ct/vll19sH96cOXPsSnw1a9Y0++67r93XatWqpbWvAAAAgEOyAQAAQILq1KljA39vvPGGefvtt82KFSvs0qp+NmzYYAeESLt27ewSrvL000+bq6++2gb//Gy11VbmyiuvNNdff33KA1KeffZZs3HjRrP77rvHTDbQvkjbtm19kw0UkL388svNkCFDbPJCtHr16pnBgweb/v37p7SfAAAAAJBLGlCiZAM30CRWssGwYcPMv//+G36fqN3VuXNn89lnn4Vfi9aiRQvz4osv2uTyVMyaNcu23bSaQqxkAw2E0XZqowYlGyjB4LzzzgvP3hmte/fu5plnnrFtPQAAAAAoJEq87tmzp3nppZdsMvhPP/1ktt12W99t1eel7UQD813i9dChQ22/mBKz/ahddumll5qbb7455dXMtbKeJvZq2rRpzGQD14e3zz77+CYbqD161VVXmUcffdQ+9+vTvPfeeyMSKQAAAIBUkWwAAACQBAXllGygwfrDhw83gwYN8t1u9OjRdgYR9x5n9uzZZs2aNeawww6zs6A0atTIJhgsWLDAfu6SJUvMjTfeaFdPuO2223JWNppV5ZBDDrGze4oG0CiYWbt2bTuTixIp5s+fb2dU0bZuhhUAAAAAKBTNmjUzrVq1Mp9//rl5+eWXzf33328Hj8Sa9VIrFrikbg1Q+eSTT+zKAGo/aSCLZrn89ddfzZdffmnbhV999ZVp3769/TdooEs2jBw50hx//PF2n+vWrWtXwlOCulY6ULLEiBEj7MoISkTX8dDMnQAAAABQSNQfpyQCtXOUOKDB+H7GjRtnVq5cGX6P880339iVDNQnpvai+vAqV65sV7FT+27RokW2706TdcVaUa60KblA/YwfffSR/f8dO3a0+6wEg2XLlpnXXnvNrlZ+6qmnmj///NMmnQMAAADpINkAAAAgCV27djX169e3KxNosElQsoEbiKIgpJZudc4880xzww03mFq1apV4z5133mkuvPBC8+STT5q77rrLnHXWWWb77bfPSfno71KiQZUqVczrr79ul1v10t9w0kkn2QE5F1xwgZ19RYNuAAAAAKCQaGCJBtcrKXzMmDGmT58+JbaZOXNmeDWAE0880VSoUME+V+K4Buq3bt3ad2U6rTagNqQGsVx33XV2FbpcUHK7/k4lGmj1AiXOV6tWLfy62qFqAx566KFm3rx5dkDOI488kpN9BQAAAIBUqU2jJG+taqAVBIKSDVwf3pZbbhmxevfJJ59sVzbQxFvR1G+nVQ0efvhhm6g+cOBAs8suu+SksLSPSjRQm1STg/Xo0SPida2erknCXD+m2oG56m8EAABAcUhtXS8AAIAyqmLFinY2f9HMlLNmzSqxjZZXnThxon1+zDHHRMwI2bx5c99EA5eYoCBl48aNzb///htewjXbNEOLW55VS6xGJxrIFltsYZ555hmbeLFhwwbzxBNP5GBPAQAAACA9mu3frWagwSixBqJEz3qp9mGbNm18Ew1k//33N7fccot9/sorr9gV7HJBie1//PGHHXSj/fAmGjhKmLj11lvtc7X1NPslAAAAABSS8uXL2wRx0cz+06ZNK7GNVqJ766237HMNwtdqAI5WJPdLNBC1G5Vk0LRpUxMKhcyLL75ockGrjz/22GP2+e23314i0cC1VYcMGWLbgEo6f/zxx3OwpwAAACgmJBsAAAAkScuO+g06cYYNG2aTBaIHoiRCs6gcfPDB9rlm18wFrWSg/VfgVLO4BFFyxJFHHmmfT548OYt7CAAAAACZoWTwo446yj4fP368XcXOSwMzXCK4BuRr8EmyM2vK+vXrzTfffJP1YtMgmJEjR9rnGnSj1euC9OrVy/6rhHKt2AAAAAAAhcbbL+fXh6f2nUsET7YPT4P4O3bsmNM+vFGjRtl2qlbcO/300wO3Ux+fViUX+vAAAACQroppfwIAAEAZs9dee5mWLVuaL774ws5coqVTFWCMDl42adLEdO7c2fczFi1aZCZNmmTmz59vfvvtN7Nx48bwa19++aX9d9myZSYX3EwvCkRefPHF4QEqjnuuf3UMREvSAgAAAEAh0gCT1157zWzatMkMHz7cXHTRReHXxo0bZ1auXBnezo8GenzwwQe2ffTzzz/bVQE2b95sX/O29dTGU1sym77//nuzevVq+3zKlClm4MCBJdp17l9vu482HgAAAIBCtOuuu5oDDjjAtn9efvlluxqBJvqK7sNr0KBBeEKtaD/++KPtw5s3b55Zu3atTU5w7SWXZJAPfXiXX355+L/7tfFmzJhhn9O+AwAAQLpINgAAAEiBBploIMmKFSvMhAkTwrODzJw503z99dfhWSO1ZKuXgo9nnXWWGTt2bNzv+P3333NSNm4mz3Xr1tllVhPxxx9/lPJeAQAAAEDpOOKII0zDhg1te00DT7zJBm4gigZy9OvXr8R7X3jhBXPZZZeVWBEhX9p43v3SbJaJzmhJGw8AAABAIffhKdlAiddjxowxvXv3tv/922+/NdOnT7fPTzjhhIiJxFz76eyzz7arB+R7H95ff/1FHx4AAACyhmQDAACAFCgIqQElms1Eg0tcsoF3SdaTTz454j3r1683nTp1MnPnzrX/XzOr6NG4cWNTtWpVu+SpDB061Hz44YcRs0pm2r///hv4Wrly5ey/TZs2Nddcc01Cn1elSpWM7RsAAAAAZJPaYgMGDDD33HOPXWlu9uzZdkW7X3/91bz11lt2m6OPPtrUqlUr4n1qu7l2X+3atU2XLl3MbrvtZurUqWNnzlTbSoP2Bw0aZLfJRRvPte/k/PPPNy1atEjo89q1a5exfQMAAACAbOrbt69NIle/nPrwXLKBtw8veuU69fcdeuihtj0obdq0se0i14fnEhO0WsJ7772X8z68bbfd1txwww0JfZ6S5wEAAIB0kGwAAACQAg0eUYLBG2+8YUaPHm2XUVWw8aWXXrKvKwCppVq99JpLNBg5cqTp1auX72e///77aZWJgoYbN260jyCrVq0KfG2bbbYJz4pyxhlnpLUvAAAAAFAINNBEyQZuAMq9995r23AacOJej+YGdrRt29aueFe9evUS2yxYsCCcbJAKNyhE+6HBLN7kgUTaeK59J2qj0sYDAAAAUOxq1Khhevbsadt048ePNytXrrQJ4sOGDbOv77vvvjbB3GvEiBHhRIPhw4eb448/3vezP/3007T2zbXx0u3DU2L7aaedVmKFdQAAAKA0UOsEAABIkRtsooDgK6+8YsaNG2cDlt7XvD7//HP7r2a6DEo0kGnTpqVVJnXr1rX/LlmyJHCbWMHQAw88MLwUa7r7AgAAAACFoFmzZqZVq1b2+YsvvmhnknSzXjZs2NAcfvjhEdtr1YOFCxfa5+edd55vooFMnTo1I+07JRosXbo06TbejjvuaPdfxowZk9a+AAAAAEChcP10//zzj00eePfdd83PP/8c8ZpfH972228fmGiQyTZeun14mgTt448/TmtfAAAAgESRbAAAAJCirl27mvr169vnGoTiBqJUrlzZLtEabfPmzfbf33//PfAzlbTwww8/pFUmLVq0sP9OnDjRd6lV/bf7778/8P3HHXecXaVBrrjiipjLtQIAAABAsXADTpYvX27bTNOnT7f//8QTTzQVKlTwbd/FauNpUItWSMhE+040I6cfJb5/++23cf+ud955x67AAAAAAADF7tBDDzXbbrttiT68Lbfc0vTv37/E9q6NpxUDgmil81htr2TaeEp+2LRpU4nXlWh+3333Bb5fk5lp5Qa56qqrbLsTAAAAKG0kGwAAAKSoYsWK5oQTTrDPp0yZEp4l8phjjvGd1VLLsopmTrnzzjttwNDrtddeM2eccYbZYYcd0iqT3r172381y+aNN94Y8T0Kkp566ql2Fs4g9erVs++TyZMn26Vmg2ZY0eoHQ4cONV988UVa+wwAAAAAuabZKytVqmSfX3311eH/7jfrpdpNTZo0sc/vueces3jx4ojXV61aZY499lizZs2atFdc2H333e1ztdMWLFgQ8foHH3xgTjrpJLuCQZDLLrvMNG3a1D7XPmmQjV9SuQbXaJbORx99NK19BgAAAIBcK1++vE0cF/VhjRgxwj7v3r27qVOnTmAfnvrPbrrppogEc5dooLZXpvrwtHKd2p3ePry//vrLnHnmmWbZsmWB769Vq5a59dZbwysg9OjRwyxatMh3W7VLtXKfW7UBAAAASFW5UPQoNwAAACRs9uzZZu+99474b1pR4LDDDiuxrYKEe+21V3hwyM4772xatmxpZ8icMWOGmT9/vk020P8fMmSIad68ufn6669LfE6XLl3sbJTdunUzY8eOLfG6Bo20adPGfqYbnLLffvuZdevW2YEomuVEM6YccMAB9vUnn3zSfm+0QYMGmcGDB4cTK/bff387gEXVR830qWDn3Llz7f9/6aWXTL9+/fjlAAAAAChoWulNieBO69at7QB8P0899ZQdCOJmx2zfvr1p2LChWbFihfn4449t2+7NN980nTp1stv4tZu0ekKrVq3CSext27Yt8T1KbD/66KNt20sr6XXu3NnUrFnTfPfdd/b9WllP7cvbbrvNNGjQwLbXomn2Ta3O55IitJ3ajRqosnr1avserbKn5zvttJP5/vvv0zqOAAAAAJBr8+bNM7vttlvEf1MbTQP0o23cuNGuOqB+L1F/mBIQtthiCzNz5kz73wcMGGATFR544IHAdpMm8FJigtpt6ouLpiSGgw8+2CYKiJLL1f+mycI+/PBDs379ejsRmNpr8tBDD5nzzz+/xOdceeWV5q677rLP1fZUP6DahWo3qk3q+vD0fc8++6xvEj0AAACQqIoJbwkAAIASlDyghAE3s79mtlQA0U+VKlXM+++/bwN6ChQqCOkCkVoJQTOlXHfddeacc85J60grqDh+/Hhz8skn2381qMQt66oEBq1EsMcee8T9nPvvv98ccsghdoaUadOmmc8++8w+vLbZZhtz+OGHh2d8AQAAAIBCpvaaN9kg1oAMJW1rQMq1115r1q5dGzGQRAkEGtChQf3p0kAYteMuvPBCO8umSzrXKgwXX3yxufvuu80NN9wQ8zOUhK4BMkpIUJKEBp9okE10W7Jdu3Z29QMAAAAAKHS77rqrnXhLid2i9tmRRx7pu63aV2rTaXVw/auJw9zkYVtvvbW55pprzM0332zbYOmuuKCEcrU19a+SyPVwiQdaiU5J7/FoBfWOHTvafdLfp348Pbz092pytEQ+DwAAAIiFlQ0AAADSpODdrFmz7PNddtnFdOjQIe57tIqBEhT+/vtv06hRIztDSdWqVe1rn3zyiZkzZ46pXbu26dWrV4n3alWDJUuWmO22284O9I9FyQxffvmlXc1AM5q4GTO1+oEGvohmUIme2SWaZrnU/mpgi2bsVIBS+62/FwAAAACKhdpKzz33nJ0NUjTwvkaNGjHfo1XslJj9008/mWrVqtkBIi7BW8kIShQQJXNrdkyvVatWmVGjRtnnWr2gXr16gd+zYcMGO/vl0qVLbXtRA0bc9lrZTm02Jbn3798/5v5u2rTJbqtVDrTvdevWtW08tRnj/a0AAAAAUEhcW0nUHlO7LB6t+qZkbbXn1BemvjW19URtP61KrraTX6K2EhUWLVpkGjduHJjY4CxcuDD8PVopQW28cuXK2deUJC5KCFfyeCxKJtfnePvwtOqe+vDc5wEAAADpINkAAAAAAAAAAAAAAAAAAAAAAABEKB/5fwEAAAAAAAAAAAAAAAAAAAAAQFlHsgEAAAAAAAAAAAAAAAAAAAAAAIhAsgEAAAAAAAAAAAAAAAAAAAAAAIhAsgEAAAAAAAAAAAAAAAAAAAAAAIhAsgEAAAAAAAAAAAAAAAAAAAAAAIhAsgEAAAAAAAAAAAAAAAAAAAAAAIhAsgEAAAAAAAAAAAAAAAAAAAAAAIhAsgEAAAAAAAAAAAAAAAAAAAAAAIhAsgEAAAAAAAAAAAAAAAAAAAAAAIhAsgEAAAAAAAAAAAAAAAAAAAAAAIhAsgEAAAAAAAAAAAAAAAAAAAAAAIhAsgEAAAAAAAAAAAAAAAAAAAAAAIhAsgEAAAAAAAAAAAAAAAAAAAAAAIhAsgEAAAAAAAAAAAAAAAAAAAAAAIhAsgEAAAAAAAAAAAAAAAAAAAAAAIhAsgEAAAAAAAAAAAAAAAAAAAAAAIhAsgEAAAAAAAAAAAAAAAAAAAAAAIhAsgEAAAAAAAAAAAAAAAAAAAAAAIhAsgEAAAAAAAAAAAAAAAAAAAAAAIhAsgEAAAAAAAAAAAAAAAAAAAAAAIhAsgEAAAAAAAAAAAAAAAAAAAAAAIhAsgEAAAAAAAAAAAAAAAAAAAAAAIhAsgEAAAAAAAAAAAAAAAAAAAAAAIhAsgEAAAAAAAAAAAAAAAAAAAAAADBe/wdZEcMrtsBpowAAAABJRU5ErkJggg==", "text/plain": [ "
" ] @@ -532,7 +584,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 10, "id": "ec6b4fb5", "metadata": { "execution": { @@ -546,7 +598,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 9, @@ -555,7 +607,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -598,7 +650,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.13.14" + "version": "3.13.15" } }, "nbformat": 4, diff --git a/quarto/pages/sklearn_users.ipynb b/quarto/pages/sklearn_users.ipynb index 9a33175..1738129 100644 --- a/quarto/pages/sklearn_users.ipynb +++ b/quarto/pages/sklearn_users.ipynb @@ -3,58 +3,72 @@ { "cell_type": "markdown", "id": "5efdbe21", - "metadata": {}, + "metadata": { + "collapsed": false + }, "source": [ "---\n", "title: \"scikit-learn Users\"\n", - "subtitle: \"A quick guide to comparing classifiers' predictions with CompStats\"\n", + "subtitle: \"A quick guide to comparing the predictions of scikit-learn models with CompStats\"\n", "---" ] }, { "cell_type": "markdown", "id": "5f15b0ad", - "metadata": {}, + "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": null, + "execution_count": 1, "id": "fc19dcd7", "metadata": {}, "outputs": [], "source": [ - "# Colab does not have CompStats preinstalled\n", - "!pip install -q CompStats" + "#| 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": {}, + "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." + "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": {}, + "metadata": { + "collapsed": false + }, "source": [ "## Dataset and libraries\n", "\n", - "The first step is to load the digits dataset and split it into a training and a validation set." + "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": 1, + "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", @@ -64,51 +78,86 @@ "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)\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": {}, + "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`." + "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": 2, + "execution_count": 3, "id": "654559ee", "metadata": {}, "outputs": [], "source": [ - "m = LinearSVC().fit(X_train, y_train)\n", + "m = LinearSVC(random_state=0).fit(X_train, y_train)\n", "hy = m.predict(X_val)" ] }, { "cell_type": "markdown", "id": "3f06d338", - "metadata": {}, + "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 -- the function takes `(y_true, y_pred)` -- but the result, `score`, is a `Perf` instance rather than a bare float." + "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": 3, + "execution_count": 4, "id": "a1d9d078", "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 0%| | 0/1 [00:00" + "" ] }, "execution_count": 3, @@ -117,34 +166,78 @@ } ], "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": {}, + "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." + "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": 4, + "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.9832 (0.0058) <= Random Forest\n", - "0.9576 (0.0088) <= Linear SVM" + "0.9783 (0.0061) <= Random Forest\n", + "0.9440 (0.0098) <= Linear SVM" ] }, "execution_count": 4, @@ -153,30 +246,71 @@ } ], "source": [ - "ens = RandomForestClassifier().fit(X_train, y_train)\n", + "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": {}, + "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." + "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": 5, + "execution_count": 6, "id": "a65f6157", "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 0%| | 0/2 [00:00" + "" ] }, "execution_count": 5, @@ -185,15 +319,15 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": { "image/png": { "height": 470, - "width": 558 + "width": 550 } }, "output_type": "display_data" @@ -202,15 +336,336 @@ "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", + "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": "f131510f", + "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": "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", + "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." ] @@ -218,8 +673,24 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "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": { @@ -232,8 +703,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.13.14" - } + "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/requirements.txt b/requirements.txt index 408d95d..f94f3b0 100644 --- a/requirements.txt +++ b/requirements.txt @@ -6,4 +6,5 @@ pyyaml sphinx pytest statsmodels -sphinxcontrib-mermaid \ No newline at end of file +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())