diff --git a/.dockerignore b/.dockerignore index 727c28c..50849a4 100644 --- a/.dockerignore +++ b/.dockerignore @@ -1,6 +1,5 @@ .env .git -__pycache__ .cache .mypy_cache .pytest_cache @@ -11,6 +10,9 @@ Dockerfile .github .vscode docs -!docs/hello_world.py scripts tests +mkdocs.yaml +**/.mypy_cache +**/__pycache__ +**/tracing_database.json diff --git a/.forgejo/workflows/docker.yml b/.forgejo/workflows/docker.yml new file mode 100644 index 0000000..2ff9932 --- /dev/null +++ b/.forgejo/workflows/docker.yml @@ -0,0 +1,57 @@ +name: Publish on DockerHub + +on: + push: + tags: ['*'] + workflow_dispatch: + +jobs: + publish: + runs-on: docker + steps: + - name: Checkout + uses: actions/checkout@v4 + + # The `docker` runner image is node-based and may not ship the docker CLI + # that the docker/* actions below drive; install it idempotently, as the + # sibling repos do for their Docker jobs. + - name: Ensure Docker CLI + run: | + set -eux + if ! command -v docker >/dev/null 2>&1; then + ARCH=$(uname -m) + curl -fsSL --retry 3 --retry-connrefused \ + "https://download.docker.com/linux/static/stable/${ARCH}/docker-27.5.1.tgz" \ + | tar xz --strip-components=1 -C /usr/local/bin docker/docker + fi + docker --version + + # Marketplace actions must be referenced by full URL: this instance's + # DEFAULT_ACTIONS_URL points at code.forgejo.org, so only bare `actions/*` + # names resolve to GitHub automatically. + - name: Set up QEMU + uses: https://github.com/docker/setup-qemu-action@v3 + + - name: Set up Docker Buildx + uses: https://github.com/docker/setup-buildx-action@v3 + + - name: Log in to Docker Hub + uses: https://github.com/docker/login-action@v3 + with: + username: ${{ secrets.DOCKER_USERNAME }} + password: ${{ secrets.DOCKER_PASSWORD }} + + - name: Extract metadata for the Docker image + id: meta + uses: https://github.com/docker/metadata-action@v5 + with: + images: schmelczera/great-ai + + - name: Build and push + uses: https://github.com/docker/build-push-action@v6 + with: + context: . + push: true + tags: ${{ steps.meta.outputs.tags }} + labels: ${{ steps.meta.outputs.labels }} + platforms: linux/amd64,linux/arm64 diff --git a/.forgejo/workflows/docs.yml b/.forgejo/workflows/docs.yml new file mode 100644 index 0000000..973ab3a --- /dev/null +++ b/.forgejo/workflows/docs.yml @@ -0,0 +1,52 @@ +name: Publish documentation + +on: + push: + branches: [main] + paths: + - 'docs/**' + - 'great_ai/**' + - 'mkdocs.yaml' + - '.forgejo/workflows/docs.yml' + workflow_dispatch: + +concurrency: + group: pages + cancel-in-progress: false + +jobs: + publish: + runs-on: docker + steps: + - uses: actions/checkout@v4 + with: + # The mkdocs git-revision-date plugin reads each page's git history. + fetch-depth: 0 + + - name: Install uv + run: | + curl -LsSf https://astral.sh/uv/install.sh | sh + echo "$HOME/.local/bin" >> "$GITHUB_PATH" + + - name: Set up Python + run: uv python install 3.10 + + - name: Install dependencies + run: | + uv venv --python 3.10 + uv pip install '.[dev]' + + - name: Build documentation + run: | + . .venv/bin/activate + mkdocs build + + # The old workflow ran `mkdocs gh-deploy` (GitHub Pages); on this instance + # built sites are rsynced into the host /pages mount that nginx serves, + # via the shared ci-actions/deploy-pages action — same as photos/reconcile. + - name: Deploy to pages mount + if: github.ref == 'refs/heads/main' + uses: http://forgejo:3000/andras/ci-actions/deploy-pages@main + with: + source: site + target: great-ai diff --git a/.forgejo/workflows/publish.yml b/.forgejo/workflows/publish.yml new file mode 100644 index 0000000..8042684 --- /dev/null +++ b/.forgejo/workflows/publish.yml @@ -0,0 +1,28 @@ +name: Publish on PyPI + +on: + push: + tags: ['*'] + workflow_dispatch: + +jobs: + publish: + runs-on: docker + steps: + - uses: actions/checkout@v4 + + - name: Install uv + run: | + curl -LsSf https://astral.sh/uv/install.sh | sh + echo "$HOME/.local/bin" >> "$GITHUB_PATH" + + - name: Set up Python + run: uv python install 3.10 + + # Forgejo cannot use PyPI trusted publishing (OIDC), so authenticate with + # an API token, the same way the sibling repos publish their packages. + - name: Build and publish + env: + FLIT_USERNAME: __token__ + FLIT_PASSWORD: ${{ secrets.PYPI_TOKEN }} + run: uvx flit publish diff --git a/.forgejo/workflows/test.yml b/.forgejo/workflows/test.yml new file mode 100644 index 0000000..a76c206 --- /dev/null +++ b/.forgejo/workflows/test.yml @@ -0,0 +1,73 @@ +name: Check + +on: + push: + branches: [main, dev] + pull_request: + branches: [main, dev] + workflow_dispatch: + +concurrency: + group: ${{ gitea.workflow }}-${{ gitea.ref }} + cancel-in-progress: true + +jobs: + lint: + name: Lint, format & type checks + runs-on: docker + steps: + - uses: actions/checkout@v4 + + - name: Install uv + run: | + curl -LsSf https://astral.sh/uv/install.sh | sh + echo "$HOME/.local/bin" >> "$GITHUB_PATH" + + - name: Set up Python + run: uv python install 3.10 + + - name: Install dependencies + # --seed gives the venv its own pip, which scripts/check-python.sh shells + # out to for its linters; '.[dev]' provides the rest (mypy resolves the + # package's own imports against the installed tree). + run: | + uv venv --seed --python 3.10 + uv pip install '.[dev]' + + - name: Check code and formatting + run: | + . .venv/bin/activate + scripts/check-python.sh great_ai tests + + test: + name: Test on Python ${{ matrix.python-version }} + runs-on: docker + strategy: + fail-fast: false + matrix: + # pyproject declares >= 3.7, but uv's standalone CPython and the current + # dependency floors (scikit-learn/numpy now require >= 3.9) no longer + # build on the older interpreters, so we test the current supported set. + # The windows leg of the old GitHub matrix is dropped: this Forgejo + # instance only has a Linux `docker` runner. + python-version: ['3.10', '3.11', '3.12', '3.13'] + steps: + - uses: actions/checkout@v4 + + - name: Install uv + run: | + curl -LsSf https://astral.sh/uv/install.sh | sh + echo "$HOME/.local/bin" >> "$GITHUB_PATH" + + - name: Set up Python ${{ matrix.python-version }} + run: uv python install ${{ matrix.python-version }} + + - name: Install dependencies + run: | + uv venv --python ${{ matrix.python-version }} + uv pip install '.[dev]' + + - name: Run tests + run: | + . .venv/bin/activate + pytest --doctest-modules --asyncio-mode=strict diff --git a/.github/dependabot.yml b/.github/dependabot.yml deleted file mode 100644 index 1230149..0000000 --- a/.github/dependabot.yml +++ /dev/null @@ -1,6 +0,0 @@ -version: 2 -updates: - - package-ecosystem: "github-actions" - directory: "/" - schedule: - interval: "daily" diff --git a/.github/workflows/docker.yaml b/.github/workflows/docker.yaml deleted file mode 100644 index 8ac9d06..0000000 --- a/.github/workflows/docker.yaml +++ /dev/null @@ -1,39 +0,0 @@ -name: Publish on DockerHub - -on: - push: - tags: - - '*' - -jobs: - publish: - runs-on: ubuntu-latest - steps: - - name: Set up QEMU - uses: docker/setup-qemu-action@v2 - - - name: Set up Docker Buildx - uses: docker/setup-buildx-action@v2 - - - name: Log in to Docker Hub - uses: docker/login-action@v2 - with: - username: ${{ secrets.DOCKER_USERNAME }} - password: ${{ secrets.DOCKER_PASSWORD }} - - - name: Checkout - uses: actions/checkout@v3 - - - name: Extract metadata for the Docker image - id: meta - uses: docker/metadata-action@v4 - with: - images: schmelczera/great-ai - - - name: Build and push - uses: docker/build-push-action@v3 - with: - push: true - tags: ${{ steps.meta.outputs.tags }} - labels: ${{ steps.meta.outputs.labels }} - platforms: linux/amd64,linux/arm64 diff --git a/.github/workflows/publish.yaml b/.github/workflows/publish.yaml deleted file mode 100644 index 33aae57..0000000 --- a/.github/workflows/publish.yaml +++ /dev/null @@ -1,29 +0,0 @@ -name: Publish on PyPI - -on: - push: - tags: - - '*' - -jobs: - publish: - runs-on: ubuntu-latest - steps: - - uses: actions/checkout@v3 - - - name: Set up Python 3.9.2 - uses: actions/setup-python@v2 - with: - python-version: 3.9.2 - - - name: Install pypa/build - run: python -m pip install build --user - - - name: Build a binary wheel and a source tarball - run: python -m build --sdist --wheel --outdir dist/ - - - name: Publish distribution to PyPI - uses: pypa/gh-action-pypi-publish@master - with: - user: __token__ - password: ${{ secrets.PYPI_API_TOKEN }} diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml deleted file mode 100644 index 4279e47..0000000 --- a/.github/workflows/test.yml +++ /dev/null @@ -1,94 +0,0 @@ -name: Test - -on: - workflow_dispatch: - push: - branches: - - main - - dev - -jobs: - test: - name: Build and test on Python ${{ matrix.python-version }} - runs-on: ubuntu-latest - - strategy: - matrix: - python-version: ["3.8.12", "3.9.12", "3.10.4"] - - steps: - - name: Checkout - uses: actions/checkout@v3 - - - name: Setup Python ${{ matrix.python-version }} - uses: actions/setup-python@v2 - with: - python-version: ${{ matrix.python-version }} - - - name: Install dependencies - run: | - python3 -m pip install --upgrade pip setuptools pytest pytest-cov pytest-subtests pytest-asyncio - pip install . - - - name: Check code and formatting - run: scripts/check-python.sh . - - - name: Run tests - run: python3 -m pytest --cov=. --cov-report=xml --junit-xml pytest.xml --asyncio-mode=strict || true - - - name: Upload results - if: always() - uses: actions/upload-artifact@v2 - with: - name: Unit test coverage (Python ${{ matrix.python-version }}) - path: "*.xml" - - sonar: - name: Analyse Python project with SonarQube - needs: test - runs-on: ubuntu-latest - steps: - - name: Checkout - uses: actions/checkout@v3 - with: - fetch-depth: 0 - - - name: Install dependencies - run: | - python -m pip install --upgrade pip - pip install . - rm -rf build - - - name: Download test results - uses: actions/download-artifact@v2 - with: - path: artifacts - - - uses: sonarsource/sonarqube-scan-action@master - env: - SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }} - SONAR_HOST_URL: ${{ secrets.SONAR_HOST_URL }} - with: - args: > - -Dsonar.projectKey=great-ai - -Dsonar.login=${{ secrets.SONAR_TOKEN }} - -Dsonar.verbose=true - -Dsonar.python.coverage.reportPaths=artifacts/*/coverage.xml - -Dsonar.coverage.exclusions=**/external/**/* - -Dsonar.exclusions=**/external/**/*,artifacts/**/* - - publish-test-results: - name: Publish unit test results - needs: test - runs-on: ubuntu-latest - if: always() - steps: - - name: Download artifacts - uses: actions/download-artifact@v2 - with: - path: artifacts - - - name: Publish results - uses: EnricoMi/publish-unit-test-result-action@v1 - with: - files: artifacts/*/pytest.xml diff --git a/.gitignore b/.gitignore index 5603876..837ce85 100644 --- a/.gitignore +++ b/.gitignore @@ -8,3 +8,5 @@ __pycache__ .ipynb_checkpoints *.egg-info build +tracing_database.json +.tox diff --git a/.vscode/settings.json b/.vscode/settings.json index b9d0b65..9554956 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -1,28 +1,33 @@ { "cSpell.words": [ + "alru", "Analyse", + "András", "basereload", "boto", "botocore", "Convolutional", "datatable", + "deduplicated", "displaylogo", "downsample", "fastapi", "finalise", "finalised", "gridfs", + "httpx", "iloc", "initialisation", "initialised", "initialising", "inplace", "ipynb", - "joblib", + "langcodes", "lemmatize", "levelname", "levelno", "matplotlib", + "miniters", "Multinomial", "multiprocess", "nbconvert", @@ -31,11 +36,13 @@ "organisation's", "Parcoords", "plotly", + "pretrained", "proba", "pydantic", "pymongo", "pyplot", "redoc", + "scibert", "serialise", "sklearn", "starlette", @@ -47,6 +54,7 @@ "tickvals", "tinydb", "tqdm", + "unchunk", "uvicorn", "Vectorizer", "xmargin", @@ -59,8 +67,18 @@ "**/.mypy_cache": true, "**/.pytest_cache": true, "**/*.egg-info": true, - "**/*.cache": true + "**/*.cache": true, + "**/*.tox": true, + "**/tracing_database.json": true }, "notebook.output.textLineLimit": 400, - "python.defaultInterpreterPath": ".env/bin/python" + "python.defaultInterpreterPath": ".env/bin/python", + "python.testing.pytestArgs": ["tests"], + "editor.rulers": [88], + "python.linting.flake8Enabled": false, + "python.linting.pylintEnabled": false, + "python.linting.mypyEnabled": true, + "python.testing.unittestEnabled": false, + "python.testing.pytestEnabled": true, + "editor.wordWrap": "on" } diff --git a/.vscode/tasks.json b/.vscode/tasks.json index 3ad7159..e78ee00 100644 --- a/.vscode/tasks.json +++ b/.vscode/tasks.json @@ -4,30 +4,49 @@ { "label": "Format and lint", "type": "shell", - "command": "source .env/bin/activate && scripts/format-python.sh .", + "command": "source .env/bin/activate && scripts/format-python.sh great_ai docs tests", "windows": { - "command": ".env\\bin\\activate.bat; scripts\\format-python.sh ." + "command": ".env\\bin\\activate.bat; scripts\\format-python.sh great_ai docs tests" }, "group": "test", "presentation": { "reveal": "always", - "panel": "new" + "showReuseMessage": false, + "panel": "shared" }, "options": { "cwd": "${workspaceFolder}" } }, { - "label": "Test", + "label": "Test (quick)", "type": "shell", - "command": "source .env/bin/activate && python3 -m pytest .", + "command": "source .env/bin/activate && python3 -m pytest . --doctest-modules --asyncio-mode=strict", "windows": { - "command": ".env\\bin\\activate.bat; python3 -m pytest ." + "command": ".env\\bin\\activate.bat; python3 -m pytest . --doctest-modules --asyncio-mode=strict" }, "group": "test", "presentation": { "reveal": "always", - "panel": "new" + "showReuseMessage": false, + "panel": "shared" + }, + "options": { + "cwd": "${workspaceFolder}" + } + }, + { + "label": "Test (all Python versions)", + "type": "shell", + "command": "source .env/bin/activate && python3 -m tox", + "windows": { + "command": ".env\\bin\\activate.bat; python3 -m tox" + }, + "group": "test", + "presentation": { + "reveal": "always", + "showReuseMessage": false, + "panel": "shared" }, "options": { "cwd": "${workspaceFolder}" diff --git a/Dockerfile b/Dockerfile index e99b071..359dcd6 100644 --- a/Dockerfile +++ b/Dockerfile @@ -1,36 +1,46 @@ +# syntax=docker/dockerfile:1.4 FROM python:3.10.4-slim-bullseye -LABEL org.opencontainers.image.title="GreatAI package wrapper container" +LABEL org.opencontainers.image.title="GreatAI package wrapper image" LABEL org.opencontainers.image.vendor="ScoutinScience B.V." LABEL org.opencontainers.image.authors="andras@schmelczer.dev" -LABEL org.opencontainers.image.source="https://github.com/ScoutinScience/great-ai" +LABEL org.opencontainers.image.source="https://github.com/schmelczer/great-ai" + +SHELL ["/bin/bash", "-c"] ENV ENVIRONMENT=production -EXPOSE 6060 # curl is needed for the healthcheck # build-essentials are needed for building packages RUN DEBIAN_FRONTEND=noninteractive apt update &&\ - apt install curl build-essential -y &&\ - rm -rf /var/lib/apt/lists/* + apt install curl build-essential -y &&\ + rm -rf /var/lib/apt/lists/* WORKDIR /dependencies COPY . great_ai RUN python3 -m pip --no-cache-dir install --upgrade pip &&\ - pip install --no-cache-dir ./great_ai &&\ - rm -rf great_ai + pip install --no-cache-dir ./great_ai &&\ + rm -rf great_ai HEALTHCHECK \ - --interval=10s \ - --timeout=60s \ - --start-period=30s \ - --retries=5 \ - CMD [ "curl", "--fail", "http://localhost:6060/health" ] + --interval=30s \ + --timeout=180s \ + --start-period=60s \ + --retries=5 \ + CMD [ "curl", "--fail", "http://localhost:6060/health" ] WORKDIR /app -VOLUME /app +COPY < str: + """Learn more about GreatAI at https://great-ai.scoutinscience.com""" + return f"Hello {name}!" +EOF -COPY docs/hello_world.py . +EXPOSE 6060 +VOLUME /app ENTRYPOINT ["/usr/local/bin/python3", "-m", "great_ai"] CMD ["hello_world.py"] diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..f288702 --- /dev/null +++ b/LICENSE @@ -0,0 +1,674 @@ + GNU GENERAL PUBLIC LICENSE + Version 3, 29 June 2007 + + Copyright (C) 2007 Free Software Foundation, Inc. + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The GNU General Public License is a free, copyleft license for +software and other kinds of works. + + The licenses for most software and other practical works are designed +to take away your freedom to share and change the works. By contrast, +the GNU General Public License is intended to guarantee your freedom to +share and change all versions of a program--to make sure it remains free +software for all its users. We, the Free Software Foundation, use the +GNU General Public License for most of our software; it applies also to +any other work released this way by its authors. You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +them if you wish), that you receive source code or can get it if you +want it, that you can change the software or use pieces of it in new +free programs, and that you know you can do these things. + + To protect your rights, we need to prevent others from denying you +these rights or asking you to surrender the rights. Therefore, you have +certain responsibilities if you distribute copies of the software, or if +you modify it: responsibilities to respect the freedom of others. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must pass on to the recipients the same +freedoms that you received. You must make sure that they, too, receive +or can get the source code. And you must show them these terms so they +know their rights. + + Developers that use the GNU GPL protect your rights with two steps: +(1) assert copyright on the software, and (2) offer you this License +giving you legal permission to copy, distribute and/or modify it. + + For the developers' and authors' protection, the GPL clearly explains +that there is no warranty for this free software. For both users' and +authors' sake, the GPL requires that modified versions be marked as +changed, so that their problems will not be attributed erroneously to +authors of previous versions. + + Some devices are designed to deny users access to install or run +modified versions of the software inside them, although the manufacturer +can do so. This is fundamentally incompatible with the aim of +protecting users' freedom to change the software. The systematic +pattern of such abuse occurs in the area of products for individuals to +use, which is precisely where it is most unacceptable. Therefore, we +have designed this version of the GPL to prohibit the practice for those +products. If such problems arise substantially in other domains, we +stand ready to extend this provision to those domains in future versions +of the GPL, as needed to protect the freedom of users. + + Finally, every program is threatened constantly by software patents. +States should not allow patents to restrict development and use of +software on general-purpose computers, but in those that do, we wish to +avoid the special danger that patents applied to a free program could +make it effectively proprietary. To prevent this, the GPL assures that +patents cannot be used to render the program non-free. + + The precise terms and conditions for copying, distribution and +modification follow. + + TERMS AND CONDITIONS + + 0. Definitions. + + "This License" refers to version 3 of the GNU General Public License. + + "Copyright" also means copyright-like laws that apply to other kinds of +works, such as semiconductor masks. + + "The Program" refers to any copyrightable work licensed under this +License. Each licensee is addressed as "you". "Licensees" and +"recipients" may be individuals or organizations. + + To "modify" a work means to copy from or adapt all or part of the work +in a fashion requiring copyright permission, other than the making of an +exact copy. The resulting work is called a "modified version" of the +earlier work or a work "based on" the earlier work. + + A "covered work" means either the unmodified Program or a work based +on the Program. + + To "propagate" a work means to do anything with it that, without +permission, would make you directly or secondarily liable for +infringement under applicable copyright law, except executing it on a +computer or modifying a private copy. Propagation includes copying, +distribution (with or without modification), making available to the +public, and in some countries other activities as well. + + To "convey" a work means any kind of propagation that enables other +parties to make or receive copies. Mere interaction with a user through +a computer network, with no transfer of a copy, is not conveying. + + An interactive user interface displays "Appropriate Legal Notices" +to the extent that it includes a convenient and prominently visible +feature that (1) displays an appropriate copyright notice, and (2) +tells the user that there is no warranty for the work (except to the +extent that warranties are provided), that licensees may convey the +work under this License, and how to view a copy of this License. If +the interface presents a list of user commands or options, such as a +menu, a prominent item in the list meets this criterion. + + 1. Source Code. + + The "source code" for a work means the preferred form of the work +for making modifications to it. "Object code" means any non-source +form of a work. + + A "Standard Interface" means an interface that either is an official +standard defined by a recognized standards body, or, in the case of +interfaces specified for a particular programming language, one that +is widely used among developers working in that language. + + The "System Libraries" of an executable work include anything, other +than the work as a whole, that (a) is included in the normal form of +packaging a Major Component, but which is not part of that Major +Component, and (b) serves only to enable use of the work with that +Major Component, or to implement a Standard Interface for which an +implementation is available to the public in source code form. A +"Major Component", in this context, means a major essential component +(kernel, window system, and so on) of the specific operating system +(if any) on which the executable work runs, or a compiler used to +produce the work, or an object code interpreter used to run it. + + The "Corresponding Source" for a work in object code form means all +the source code needed to generate, install, and (for an executable +work) run the object code and to modify the work, including scripts to +control those activities. However, it does not include the work's +System Libraries, or general-purpose tools or generally available free +programs which are used unmodified in performing those activities but +which are not part of the work. For example, Corresponding Source +includes interface definition files associated with source files for +the work, and the source code for shared libraries and dynamically +linked subprograms that the work is specifically designed to require, +such as by intimate data communication or control flow between those +subprograms and other parts of the work. + + The Corresponding Source need not include anything that users +can regenerate automatically from other parts of the Corresponding +Source. + + The Corresponding Source for a work in source code form is that +same work. + + 2. Basic Permissions. + + All rights granted under this License are granted for the term of +copyright on the Program, and are irrevocable provided the stated +conditions are met. This License explicitly affirms your unlimited +permission to run the unmodified Program. The output from running a +covered work is covered by this License only if the output, given its +content, constitutes a covered work. This License acknowledges your +rights of fair use or other equivalent, as provided by copyright law. + + You may make, run and propagate covered works that you do not +convey, without conditions so long as your license otherwise remains +in force. You may convey covered works to others for the sole purpose +of having them make modifications exclusively for you, or provide you +with facilities for running those works, provided that you comply with +the terms of this License in conveying all material for which you do +not control copyright. Those thus making or running the covered works +for you must do so exclusively on your behalf, under your direction +and control, on terms that prohibit them from making any copies of +your copyrighted material outside their relationship with you. + + Conveying under any other circumstances is permitted solely under +the conditions stated below. Sublicensing is not allowed; section 10 +makes it unnecessary. + + 3. Protecting Users' Legal Rights From Anti-Circumvention Law. + + No covered work shall be deemed part of an effective technological +measure under any applicable law fulfilling obligations under article +11 of the WIPO copyright treaty adopted on 20 December 1996, or +similar laws prohibiting or restricting circumvention of such +measures. + + When you convey a covered work, you waive any legal power to forbid +circumvention of technological measures to the extent such circumvention +is effected by exercising rights under this License with respect to +the covered work, and you disclaim any intention to limit operation or +modification of the work as a means of enforcing, against the work's +users, your or third parties' legal rights to forbid circumvention of +technological measures. + + 4. Conveying Verbatim Copies. + + You may convey verbatim copies of the Program's source code as you +receive it, in any medium, provided that you conspicuously and +appropriately publish on each copy an appropriate copyright notice; +keep intact all notices stating that this License and any +non-permissive terms added in accord with section 7 apply to the code; +keep intact all notices of the absence of any warranty; and give all +recipients a copy of this License along with the Program. + + You may charge any price or no price for each copy that you convey, +and you may offer support or warranty protection for a fee. + + 5. Conveying Modified Source Versions. + + You may convey a work based on the Program, or the modifications to +produce it from the Program, in the form of source code under the +terms of section 4, provided that you also meet all of these conditions: + + a) The work must carry prominent notices stating that you modified + it, and giving a relevant date. + + b) The work must carry prominent notices stating that it is + released under this License and any conditions added under section + 7. This requirement modifies the requirement in section 4 to + "keep intact all notices". + + c) You must license the entire work, as a whole, under this + License to anyone who comes into possession of a copy. This + License will therefore apply, along with any applicable section 7 + additional terms, to the whole of the work, and all its parts, + regardless of how they are packaged. This License gives no + permission to license the work in any other way, but it does not + invalidate such permission if you have separately received it. + + d) If the work has interactive user interfaces, each must display + Appropriate Legal Notices; however, if the Program has interactive + interfaces that do not display Appropriate Legal Notices, your + work need not make them do so. + + A compilation of a covered work with other separate and independent +works, which are not by their nature extensions of the covered work, +and which are not combined with it such as to form a larger program, +in or on a volume of a storage or distribution medium, is called an +"aggregate" if the compilation and its resulting copyright are not +used to limit the access or legal rights of the compilation's users +beyond what the individual works permit. Inclusion of a covered work +in an aggregate does not cause this License to apply to the other +parts of the aggregate. + + 6. Conveying Non-Source Forms. + + You may convey a covered work in object code form under the terms +of sections 4 and 5, provided that you also convey the +machine-readable Corresponding Source under the terms of this License, +in one of these ways: + + a) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by the + Corresponding Source fixed on a durable physical medium + customarily used for software interchange. + + b) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by a + written offer, valid for at least three years and valid for as + long as you offer spare parts or customer support for that product + model, to give anyone who possesses the object code either (1) a + copy of the Corresponding Source for all the software in the + product that is covered by this License, on a durable physical + medium customarily used for software interchange, for a price no + more than your reasonable cost of physically performing this + conveying of source, or (2) access to copy the + Corresponding Source from a network server at no charge. + + c) Convey individual copies of the object code with a copy of the + written offer to provide the Corresponding Source. This + alternative is allowed only occasionally and noncommercially, and + only if you received the object code with such an offer, in accord + with subsection 6b. + + d) Convey the object code by offering access from a designated + place (gratis or for a charge), and offer equivalent access to the + Corresponding Source in the same way through the same place at no + further charge. You need not require recipients to copy the + Corresponding Source along with the object code. If the place to + copy the object code is a network server, the Corresponding Source + may be on a different server (operated by you or a third party) + that supports equivalent copying facilities, provided you maintain + clear directions next to the object code saying where to find the + Corresponding Source. Regardless of what server hosts the + Corresponding Source, you remain obligated to ensure that it is + available for as long as needed to satisfy these requirements. + + e) Convey the object code using peer-to-peer transmission, provided + you inform other peers where the object code and Corresponding + Source of the work are being offered to the general public at no + charge under subsection 6d. + + A separable portion of the object code, whose source code is excluded +from the Corresponding Source as a System Library, need not be +included in conveying the object code work. + + A "User Product" is either (1) a "consumer product", which means any +tangible personal property which is normally used for personal, family, +or household purposes, or (2) anything designed or sold for incorporation +into a dwelling. In determining whether a product is a consumer product, +doubtful cases shall be resolved in favor of coverage. For a particular +product received by a particular user, "normally used" refers to a +typical or common use of that class of product, regardless of the status +of the particular user or of the way in which the particular user +actually uses, or expects or is expected to use, the product. A product +is a consumer product regardless of whether the product has substantial +commercial, industrial or non-consumer uses, unless such uses represent +the only significant mode of use of the product. + + "Installation Information" for a User Product means any methods, +procedures, authorization keys, or other information required to install +and execute modified versions of a covered work in that User Product from +a modified version of its Corresponding Source. The information must +suffice to ensure that the continued functioning of the modified object +code is in no case prevented or interfered with solely because +modification has been made. + + If you convey an object code work under this section in, or with, or +specifically for use in, a User Product, and the conveying occurs as +part of a transaction in which the right of possession and use of the +User Product is transferred to the recipient in perpetuity or for a +fixed term (regardless of how the transaction is characterized), the +Corresponding Source conveyed under this section must be accompanied +by the Installation Information. But this requirement does not apply +if neither you nor any third party retains the ability to install +modified object code on the User Product (for example, the work has +been installed in ROM). + + The requirement to provide Installation Information does not include a +requirement to continue to provide support service, warranty, or updates +for a work that has been modified or installed by the recipient, or for +the User Product in which it has been modified or installed. Access to a +network may be denied when the modification itself materially and +adversely affects the operation of the network or violates the rules and +protocols for communication across the network. + + Corresponding Source conveyed, and Installation Information provided, +in accord with this section must be in a format that is publicly +documented (and with an implementation available to the public in +source code form), and must require no special password or key for +unpacking, reading or copying. + + 7. Additional Terms. + + "Additional permissions" are terms that supplement the terms of this +License by making exceptions from one or more of its conditions. +Additional permissions that are applicable to the entire Program shall +be treated as though they were included in this License, to the extent +that they are valid under applicable law. If additional permissions +apply only to part of the Program, that part may be used separately +under those permissions, but the entire Program remains governed by +this License without regard to the additional permissions. + + When you convey a copy of a covered work, you may at your option +remove any additional permissions from that copy, or from any part of +it. (Additional permissions may be written to require their own +removal in certain cases when you modify the work.) You may place +additional permissions on material, added by you to a covered work, +for which you have or can give appropriate copyright permission. + + Notwithstanding any other provision of this License, for material you +add to a covered work, you may (if authorized by the copyright holders of +that material) supplement the terms of this License with terms: + + a) Disclaiming warranty or limiting liability differently from the + terms of sections 15 and 16 of this License; or + + b) Requiring preservation of specified reasonable legal notices or + author attributions in that material or in the Appropriate Legal + Notices displayed by works containing it; or + + c) Prohibiting misrepresentation of the origin of that material, or + requiring that modified versions of such material be marked in + reasonable ways as different from the original version; or + + d) Limiting the use for publicity purposes of names of licensors or + authors of the material; or + + e) Declining to grant rights under trademark law for use of some + trade names, trademarks, or service marks; or + + f) Requiring indemnification of licensors and authors of that + material by anyone who conveys the material (or modified versions of + it) with contractual assumptions of liability to the recipient, for + any liability that these contractual assumptions directly impose on + those licensors and authors. + + All other non-permissive additional terms are considered "further +restrictions" within the meaning of section 10. If the Program as you +received it, or any part of it, contains a notice stating that it is +governed by this License along with a term that is a further +restriction, you may remove that term. If a license document contains +a further restriction but permits relicensing or conveying under this +License, you may add to a covered work material governed by the terms +of that license document, provided that the further restriction does +not survive such relicensing or conveying. + + If you add terms to a covered work in accord with this section, you +must place, in the relevant source files, a statement of the +additional terms that apply to those files, or a notice indicating +where to find the applicable terms. + + Additional terms, permissive or non-permissive, may be stated in the +form of a separately written license, or stated as exceptions; +the above requirements apply either way. + + 8. Termination. + + You may not propagate or modify a covered work except as expressly +provided under this License. Any attempt otherwise to propagate or +modify it is void, and will automatically terminate your rights under +this License (including any patent licenses granted under the third +paragraph of section 11). + + However, if you cease all violation of this License, then your +license from a particular copyright holder is reinstated (a) +provisionally, unless and until the copyright holder explicitly and +finally terminates your license, and (b) permanently, if the copyright +holder fails to notify you of the violation by some reasonable means +prior to 60 days after the cessation. + + Moreover, your license from a particular copyright holder is +reinstated permanently if the copyright holder notifies you of the +violation by some reasonable means, this is the first time you have +received notice of violation of this License (for any work) from that +copyright holder, and you cure the violation prior to 30 days after +your receipt of the notice. + + Termination of your rights under this section does not terminate the +licenses of parties who have received copies or rights from you under +this License. If your rights have been terminated and not permanently +reinstated, you do not qualify to receive new licenses for the same +material under section 10. + + 9. Acceptance Not Required for Having Copies. + + You are not required to accept this License in order to receive or +run a copy of the Program. Ancillary propagation of a covered work +occurring solely as a consequence of using peer-to-peer transmission +to receive a copy likewise does not require acceptance. However, +nothing other than this License grants you permission to propagate or +modify any covered work. These actions infringe copyright if you do +not accept this License. Therefore, by modifying or propagating a +covered work, you indicate your acceptance of this License to do so. + + 10. Automatic Licensing of Downstream Recipients. + + Each time you convey a covered work, the recipient automatically +receives a license from the original licensors, to run, modify and +propagate that work, subject to this License. You are not responsible +for enforcing compliance by third parties with this License. + + An "entity transaction" is a transaction transferring control of an +organization, or substantially all assets of one, or subdividing an +organization, or merging organizations. If propagation of a covered +work results from an entity transaction, each party to that +transaction who receives a copy of the work also receives whatever +licenses to the work the party's predecessor in interest had or could +give under the previous paragraph, plus a right to possession of the +Corresponding Source of the work from the predecessor in interest, if +the predecessor has it or can get it with reasonable efforts. + + You may not impose any further restrictions on the exercise of the +rights granted or affirmed under this License. For example, you may +not impose a license fee, royalty, or other charge for exercise of +rights granted under this License, and you may not initiate litigation +(including a cross-claim or counterclaim in a lawsuit) alleging that +any patent claim is infringed by making, using, selling, offering for +sale, or importing the Program or any portion of it. + + 11. Patents. + + A "contributor" is a copyright holder who authorizes use under this +License of the Program or a work on which the Program is based. The +work thus licensed is called the contributor's "contributor version". + + A contributor's "essential patent claims" are all patent claims +owned or controlled by the contributor, whether already acquired or +hereafter acquired, that would be infringed by some manner, permitted +by this License, of making, using, or selling its contributor version, +but do not include claims that would be infringed only as a +consequence of further modification of the contributor version. For +purposes of this definition, "control" includes the right to grant +patent sublicenses in a manner consistent with the requirements of +this License. + + Each contributor grants you a non-exclusive, worldwide, royalty-free +patent license under the contributor's essential patent claims, to +make, use, sell, offer for sale, import and otherwise run, modify and +propagate the contents of its contributor version. + + In the following three paragraphs, a "patent license" is any express +agreement or commitment, however denominated, not to enforce a patent +(such as an express permission to practice a patent or covenant not to +sue for patent infringement). To "grant" such a patent license to a +party means to make such an agreement or commitment not to enforce a +patent against the party. + + If you convey a covered work, knowingly relying on a patent license, +and the Corresponding Source of the work is not available for anyone +to copy, free of charge and under the terms of this License, through a +publicly available network server or other readily accessible means, +then you must either (1) cause the Corresponding Source to be so +available, or (2) arrange to deprive yourself of the benefit of the +patent license for this particular work, or (3) arrange, in a manner +consistent with the requirements of this License, to extend the patent +license to downstream recipients. "Knowingly relying" means you have +actual knowledge that, but for the patent license, your conveying the +covered work in a country, or your recipient's use of the covered work +in a country, would infringe one or more identifiable patents in that +country that you have reason to believe are valid. + + If, pursuant to or in connection with a single transaction or +arrangement, you convey, or propagate by procuring conveyance of, a +covered work, and grant a patent license to some of the parties +receiving the covered work authorizing them to use, propagate, modify +or convey a specific copy of the covered work, then the patent license +you grant is automatically extended to all recipients of the covered +work and works based on it. + + A patent license is "discriminatory" if it does not include within +the scope of its coverage, prohibits the exercise of, or is +conditioned on the non-exercise of one or more of the rights that are +specifically granted under this License. You may not convey a covered +work if you are a party to an arrangement with a third party that is +in the business of distributing software, under which you make payment +to the third party based on the extent of your activity of conveying +the work, and under which the third party grants, to any of the +parties who would receive the covered work from you, a discriminatory +patent license (a) in connection with copies of the covered work +conveyed by you (or copies made from those copies), or (b) primarily +for and in connection with specific products or compilations that +contain the covered work, unless you entered into that arrangement, +or that patent license was granted, prior to 28 March 2007. + + Nothing in this License shall be construed as excluding or limiting +any implied license or other defenses to infringement that may +otherwise be available to you under applicable patent law. + + 12. No Surrender of Others' Freedom. + + If conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot convey a +covered work so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you may +not convey it at all. For example, if you agree to terms that obligate you +to collect a royalty for further conveying from those to whom you convey +the Program, the only way you could satisfy both those terms and this +License would be to refrain entirely from conveying the Program. + + 13. Use with the GNU Affero General Public License. + + Notwithstanding any other provision of this License, you have +permission to link or combine any covered work with a work licensed +under version 3 of the GNU Affero General Public License into a single +combined work, and to convey the resulting work. The terms of this +License will continue to apply to the part which is the covered work, +but the special requirements of the GNU Affero General Public License, +section 13, concerning interaction through a network will apply to the +combination as such. + + 14. Revised Versions of this License. + + The Free Software Foundation may publish revised and/or new versions of +the GNU General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + + Each version is given a distinguishing version number. If the +Program specifies that a certain numbered version of the GNU General +Public License "or any later version" applies to it, you have the +option of following the terms and conditions either of that numbered +version or of any later version published by the Free Software +Foundation. If the Program does not specify a version number of the +GNU General Public License, you may choose any version ever published +by the Free Software Foundation. + + If the Program specifies that a proxy can decide which future +versions of the GNU General Public License can be used, that proxy's +public statement of acceptance of a version permanently authorizes you +to choose that version for the Program. + + Later license versions may give you additional or different +permissions. However, no additional obligations are imposed on any +author or copyright holder as a result of your choosing to follow a +later version. + + 15. Disclaimer of Warranty. + + THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY +APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT +HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY +OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, +THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM +IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF +ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. Limitation of Liability. + + IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS +THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY +GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE +USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF +DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD +PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), +EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF +SUCH DAMAGES. + + 17. Interpretation of Sections 15 and 16. + + If the disclaimer of warranty and limitation of liability provided +above cannot be given local legal effect according to their terms, +reviewing courts shall apply local law that most closely approximates +an absolute waiver of all civil liability in connection with the +Program, unless a warranty or assumption of liability accompanies a +copy of the Program in return for a fee. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +state the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . + +Also add information on how to contact you by electronic and paper mail. + + If the program does terminal interaction, make it output a short +notice like this when it starts in an interactive mode: + + Copyright (C) + This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, your program's commands +might be different; for a GUI interface, you would use an "about box". + + You should also get your employer (if you work as a programmer) or school, +if any, to sign a "copyright disclaimer" for the program, if necessary. +For more information on this, and how to apply and follow the GNU GPL, see +. + + The GNU General Public License does not permit incorporating your program +into proprietary programs. If your program is a subroutine library, you +may consider it more useful to permit linking proprietary applications with +the library. If this is what you want to do, use the GNU Lesser General +Public License instead of this License. But first, please read +. diff --git a/README.md b/README.md index 24d203f..eba2aaf 100644 --- a/README.md +++ b/README.md @@ -1,18 +1,61 @@ -# GreatAI +# logo of great-ai GreatAI -**work in progress, do not use!** +> Easily transform your prototype AI code into production-ready software. -[![Test](https://github.com/ScoutinScience/great_ai/actions/workflows/test.yml/badge.svg)](https://github.com/ScoutinScience/great_ai/actions/workflows/check.yml) [![Quality Gate Status](https://sonar.scoutinscience.com/api/project_badges/measure?project=great-ai&metric=alert_status)](https://sonar.scoutinscience.com/dashboard?id=great-ai) [![Publish on PyPI](https://github.com/ScoutinScience/great_ai/actions/workflows/publish.yaml/badge.svg)](https://github.com/ScoutinScience/great_ai/actions/workflows/publish.yaml) [![Publish on DockerHub](https://github.com/ScoutinScience/great_ai/actions/workflows/docker.yaml/badge.svg)](https://github.com/ScoutinScience/great_ai/actions/workflows/docker.yaml) +[![PyPI version](https://badge.fury.io/py/great-ai.svg)](https://badge.fury.io/py/great-ai) +[![Downloads](https://pepy.tech/badge/great-ai/month)](https://pepy.tech/project/great-ai) +[![Docker Pulls](https://img.shields.io/docker/pulls/schmelczera/great-ai)](https://hub.docker.com/repository/docker/schmelczera/great-ai) +[![Test](https://github.com/schmelczer/great-ai/actions/workflows/test.yml/badge.svg)](https://github.com/schmelczer/great-ai/actions/workflows/test.yml) +[![Sonar line coverage](https://sonar.scoutinscience.com/api/project_badges/measure?project=great-ai&metric=coverage)](https://sonar.scoutinscience.com/dashboard?id=great-ai) +[![Sonar LoC](https://sonar.scoutinscience.com/api/project_badges/measure?project=great-ai&metric=ncloc)](https://sonar.scoutinscience.com/dashboard?id=great-ai) +Applying AI is becoming increasingly more accessible, but many case studies have shown that these applications are often deployed poorly. This may lead to suboptimal performance and to introducing unintended biases. GreatAI helps fix this by allowing you to easily transform your prototype AI code into production-ready software. -## Find `great-ai` on [DockerHub](https://hub.docker.com/repository/docker/schmelczera/great-ai) +## Example ```sh -docker run -p6060:6060 schmelczera/great-ai +pip install great-ai ``` -Find the dashboard at [http://localhost:6060](http://localhost:6060/dashboard/). +Create a new file called `demo.py` +```python +from great_ai import GreatAI + +@GreatAI.create +def greeter(name: str) -> str: + return f"Hello {name}!" +``` + +Start it by executing `great-ai demo.py`, and find the dashboard at [http://localhost:6060](http://localhost:6060/dashboard). + +![demo screen capture](https://raw.githubusercontent.com/schmelczer/great-ai/main/docs/media/demo.gif) + +That's it. Your GreatAI service is _nearly_ ready for production use. Many of the [SE4ML best practices](https://se-ml.github.io) are configured and implemented automatically (of course, these can be customised as well). + +[Check out the full documentation here](https://great-ai.scoutinscience.com). + +## Why is this GREAT? + +![scope of GreatAI](https://raw.githubusercontent.com/schmelczer/great-ai/main/docs/media/scope-simple.drawio.svg) + +GreatAI fits between the prototype and deployment phases of your AI development lifecycle. This is highlighted in blue in the diagram. Here, several best practices can be automatically implemented, aiming to achieve the following attributes: + +- **G**eneral: use any Python library without restriction +- **R**obust: have error-handling and well-tested utilities out-of-the-box +- **E**nd-to-end: utilise end-to-end feedback as a built-in, first-class concept +- **A**utomated: focus only on what actually requires your attention +- **T**rustworthy: deploy models that you and society can confidently trust + +## Why GreatAI? + +There are other existing solutions aiming to facilitate this phase. [Amazon SageMaker](https://aws.amazon.com/sagemaker) and [Seldon Core](https://www.seldon.io/solutions/open-source-projects/core) provide the most comprehensive suite of features. If you have the opportunity to use them, do that because they're great. + +However, [research indicates](https://great-ai.scoutinscience.com) that professionals rarely use them. This may be due to their inherent setup and operational complexity. **GreatAI is designed to be as simple to use as possible.** Its straightforward, high-level API and sensible default configuration make it easy to start using. Despite its relative simplicity over Seldon Core, it still implements many of the [SE4ML best practices](https://se-ml.github.io), and thus, can meaningfully improve your deployment without requiring prohibitively great effort. + +## [Learn more](https://great-ai.scoutinscience.com) + +[Check out the full documentation here](https://great-ai.scoutinscience.com). ## Find `great-ai` on [PyPI](https://pypi.org/project/great-ai/) @@ -20,15 +63,41 @@ Find the dashboard at [http://localhost:6060](http://localhost:6060/dashboard/). pip install great-ai ``` -```python -from great_ai import GreatAI +## Find `great-ai` on [DockerHub](https://hub.docker.com/repository/docker/schmelczera/great-ai) -@GreatAI.create -def hello_world(name: str) -> str: - return f"Hello {name}!" +```sh +docker run -p6060:6060 schmelczera/great-ai ``` -> Create a new file called `main.py` -Deploy by executing `python3 -m great-ai main.py` +## Contribute -Find the dashboard at [http://localhost:6060](http://localhost:6060/dashboard/). +Contributions are welcome. + +### Install for development + +```sh +python3 -m venv --copies .env +source .env/bin/activate +pip install --upgrade flit pip +flit install --symlink +``` + +### Develop + +```sh +scripts/format-python.sh great_ai docs tests +``` + +> Format code. + +```sh +python3 -m pytest --doctest-modules --asyncio-mode=strict . +``` + +> Run tests. + +```sh +mkdocs serve +``` + +> Serve documentation. diff --git a/docs/CNAME b/docs/CNAME new file mode 100644 index 0000000..10425a6 --- /dev/null +++ b/docs/CNAME @@ -0,0 +1 @@ +great-ai.scoutinscience.com \ No newline at end of file diff --git a/docs/README.md b/docs/README.md deleted file mode 100644 index 2ef2e77..0000000 --- a/docs/README.md +++ /dev/null @@ -1,16 +0,0 @@ -# **S**coutinScience **U**tilitie**S** for text processing [![Lint and test ScoutinScience utilities](https://github.com/ScoutinScience/platform/actions/workflows/sus-general.yaml/badge.svg)](https://github.com/ScoutinScience/platform/actions/workflows/sus-general.yaml) - -## Exports - -- [clean](src/sus/clean.py) -- [language](src/sus/clean.py) -- [unique](src/sus/unique.py) -- [parallel_map](src/sus/parallel_map.py) -- [evaluate_ranking](src/sus/evaluate_ranking/evaluate_ranking.py) -- [get_sentences](src/sus/get_sentences.py) - -## Development - -- Optional booleans must have a default value of `False`. -- No imports in top-level `__init__.py`, in order to not load anything unnecessary automatically -- Should only be updated through a PR diff --git a/docs/examples/scibert/additional-files.md b/docs/examples/scibert/additional-files.md new file mode 100644 index 0000000..883c7d8 --- /dev/null +++ b/docs/examples/scibert/additional-files.md @@ -0,0 +1,75 @@ +# Additional files in the repository + +In order to give you a smooth experience while comprehending this example, all non-notebook files are presented on this page in one place. In reality, these files should be in your project's top-level directory. + +## config.ini + +```ini title="config.ini" +ENVIRONMENT = DEVELOPMENT +ENVIRONMENT = ENV:ENVIRONMENT + +MONGO_CONNECTION_STRING=ENV:MONGO_CONNECTION_STRING +MONGO_DATABASE=highlights + +AWS_REGION_NAME = eu-west-2 +AWS_ACCESS_KEY_ID = MY_DEFAULT_AWS_ACCESS_KEY_ID_FOR_DEVELOPMENT +AWS_SECRET_ACCESS_KEY = MY_DEFAULT_AWS_SECRET_ACCESS_KEY_FOR_DEVELOPMENT +LARGE_FILES_BUCKET_NAME = my-orgs-large-files + +AWS_REGION_NAME = ENV:AWS_REGION_NAME +AWS_ACCESS_KEY_ID = ENV:AWS_ACCESS_KEY_ID +AWS_SECRET_ACCESS_KEY = ENV:AWS_SECRET_ACCESS_KEY +LARGE_FILES_BUCKET_NAME = ENV:LARGE_FILES_BUCKET_NAME +``` + +> All necessary configuration which is read by [great_ai.utilities.ConfigFile][]. This will resolve values starting with `ENV:` from your environment variables. + +## requirements.txt + +```requirements.txt title="requirements.txt" +torch==1.12.0 +transformers==4.20.1 +numpy==1.23.0 +``` + +> Usually, it is recommended to pin (freeze) the library versions on which we depend. This file is referenced by the [Dockerfile](#dockerfile). + +## Dockerfile + +```Dockerfile title="Dockerfile" +FROM schmelczera/great-ai:v0.1.6 + +COPY requirements.txt ./ +RUN pip install --no-cache-dir --requirement requirements.txt + +COPY . ./ + +RUN large-file --backend s3 --secrets s3.ini --cache scibert-highlights + +CMD ["deploy.ipynb"] +``` + +> This is used by the CD pipeline to create the production deployment of the service. + +## .dockerignore + +```dockerignore title=".dockerignore" +.cache +.git +data +.gitignore +.env +.vscode +.dockerignore +Dockerfile +.mypy_cache +.gitignore +**/__pycache__ +**/.DS_Store +README.md +``` + +> It is useful not to send, for example, the `.cache` folder used by LargeFile to the docker daemon; this will speed up your local build times substantially. + +!!! Note ".gitignore" + A very similar looking `.gitignore` file should also be present. diff --git a/docs/examples/scibert/data.ipynb b/docs/examples/scibert/data.ipynb new file mode 100644 index 0000000..97a7fb8 --- /dev/null +++ b/docs/examples/scibert/data.ipynb @@ -0,0 +1,310 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Explore data and feasibility of approach\n", + "\n", + "![screenshot fo the annotator tool](/media/annotator.png)\n", + "\n", + "We had asked our clients and in-house experts to annotate sentences using a rigorous guideline. The aim is to decide on which sentences they would like to see in a summary for a paper.\n", + "\n", + "The results are in JSON format, each annotator has a separate file. Let's load them." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "data/evaluation-experiment-2-stage #1-sa6a0y.json\n", + "data/evaluation-experiment-2-stage #1-2m6dmb.json\n" + ] + } + ], + "source": [ + "from pathlib import Path\n", + "import json\n", + "\n", + "annotations = []\n", + "for p in Path(\"data\").glob(\"*.json\"):\n", + " with open(p, encoding=\"utf-8\") as f:\n", + " print(p)\n", + " annotations.append(json.load(f))\n", + "\n", + "evaluations = {\n", + " sentence: [\n", + " annotation[sentence] for annotation in annotations if sentence in annotation\n", + " ]\n", + " for sentence in {\n", + " sentence for annotation in annotations for sentence in annotation.keys()\n", + " }\n", + "}\n", + "\n", + "X = [s for s in evaluations.keys()]\n", + "y = [int(sum(e) > 0) for e in evaluations.values()]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Save the compiled and processed data for later use using LargeFileS3." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[38;5;39mCopying file for summary-train-dataset-small-0\u001b[0m\n", + "\u001b[38;5;39mCompressing summary-train-dataset-small-0\u001b[0m\n", + "\u001b[38;5;39mUploading summary-train-dataset-small-0 to S3 as summary-train-dataset-small/0\u001b[0m\n", + "\u001b[38;5;39mUploading summary-train-dataset-small-0.tar.gz 0.04/0.04 MB (100.0%)\u001b[0m\n" + ] + } + ], + "source": [ + "from great_ai.large_file import LargeFileS3\n", + "import json\n", + "\n", + "LargeFileS3.configure_credentials_from_file(\"config.ini\")\n", + "\n", + "with LargeFileS3(\"summary-train-dataset-small\", \"w\", encoding=\"utf-8\") as f:\n", + " json.dump((X, y), f)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Filter out sentences which don't have enough annotations." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "y1 = [e[0] for e in evaluations.values() if len(e) == 2]\n", + "y2 = [e[1] for e in evaluations.values() if len(e) == 2]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Calculate [Cohen's kappa](https://en.wikipedia.org/wiki/Cohen%27s_kappa).\n", + "\n", + "It's a bit low but the task itself is pretty subjective so it's not all that surprising." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.3546448712421808" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import sklearn.metrics\n", + "\n", + "sklearn.metrics.cohen_kappa_score(y1, y2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Can we train anything on this data?\n", + "\n", + "Let's try with a trivial SVM." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "X = [s for s in evaluations.keys()]\n", + "y = [int(sum(e) > 0) for e in evaluations.values()]" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0.79, 0.75, 0.77, 0.69, 0.77])" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from sklearn.model_selection import train_test_split\n", + "from sklearn.svm import LinearSVC\n", + "from sklearn.pipeline import Pipeline\n", + "from sklearn.feature_extraction.text import TfidfVectorizer\n", + "from sklearn.model_selection import cross_val_score\n", + "\n", + "\n", + "model = Pipeline(\n", + " steps=[\n", + " (\"vectorizer\", TfidfVectorizer(sublinear_tf=True, min_df=3, max_df=0.3)),\n", + " (\"classifier\", LinearSVC()),\n", + " ]\n", + ") # baseline model\n", + "\n", + "cross_val_score(model, X, y, cv=5)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The cross-validation shows promising accuracies. But accuracy isn't everything, therefore, we should investigate the accuracy metrics." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
Pipeline(steps=[('vectorizer',\n",
+       "                 TfidfVectorizer(max_df=0.3, min_df=3, sublinear_tf=True)),\n",
+       "                ('classifier', LinearSVC())])
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ], + "text/plain": [ + "Pipeline(steps=[('vectorizer',\n", + " TfidfVectorizer(max_df=0.3, min_df=3, sublinear_tf=True)),\n", + " ('classifier', LinearSVC())])" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)\n", + "model.fit(X_train, y_train)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " precision recall f1-score support\n", + "\n", + " False 0.78 0.78 0.78 51\n", + " True 0.78 0.78 0.78 49\n", + "\n", + " accuracy 0.78 100\n", + " macro avg 0.78 0.78 0.78 100\n", + "weighted avg 0.78 0.78 0.78 100\n", + "\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "y_predicted = model.predict(X_test)\n", + "print(\n", + " sklearn.metrics.classification_report(\n", + " [y > 0 for y in y_test], [y > 0 for y in y_predicted]\n", + " )\n", + ")\n", + "sklearn.metrics.ConfusionMatrixDisplay.from_predictions(\n", + " [y > 0 for y in y_test],\n", + " [y > 0 for y in y_predicted],\n", + " xticks_rotation=\"vertical\",\n", + " values_format=\".2f\",\n", + ")\n", + "None" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We get an F1-score of 0.78 without any hyperparameter-optimisation; this task may be feasible to solve with AI.\n", + "\n", + "Next: [Part 2](/examples/scibert/train)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.10.4 ('.env': venv)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.4" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "02dd6d3afbfa9fbbe1037d64ad9014965528a1ccad21929d6e72f466389a68ad" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/docs/examples/scibert/deploy.ipynb b/docs/examples/scibert/deploy.ipynb new file mode 100644 index 0000000..b35e6b2 --- /dev/null +++ b/docs/examples/scibert/deploy.ipynb @@ -0,0 +1,324 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Create an inference function\n", + "\n", + "Everything is ready to wrap the previously trained model and deploy it. \n", + "\n", + "First, we need to configure the LargeFileBackend, the TracingDatabase and GreatAI." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[38;5;226mThe value of `ENVIRONMENT` contains the \"ENV` prefix but `ENVIRONMENT` is not defined as an environment variable, using the default value defined above (`DEVELOPMENT`)\u001b[0m\n", + "\u001b[38;5;226mEnvironment variable ENVIRONMENT is not set, defaulting to development mode ‼️\u001b[0m\n", + "\u001b[38;5;39mMongoDbDriver has been already configured: skipping initialisation\u001b[0m\n", + "\u001b[38;5;39mLargeFileS3 has been already configured: skipping initialisation\u001b[0m\n", + "\u001b[38;5;39mGreatAI (v0.1.6): configured ✅\u001b[0m\n", + "\u001b[38;5;39m 🔩 tracing_database: MongoDbDriver\u001b[0m\n", + "\u001b[38;5;39m 🔩 large_file_implementation: LargeFileS3\u001b[0m\n", + "\u001b[38;5;39m 🔩 is_production: False\u001b[0m\n", + "\u001b[38;5;39m 🔩 should_log_exception_stack: True\u001b[0m\n", + "\u001b[38;5;39m 🔩 prediction_cache_size: 4096\u001b[0m\n", + "\u001b[38;5;39m 🔩 dashboard_table_size: 100\u001b[0m\n", + "\u001b[38;5;226mYou still need to check whether you follow all best practices before trusting your deployment.\u001b[0m\n", + "\u001b[38;5;226m> Find out more at https://se-ml.github.io/practices\u001b[0m\n" + ] + } + ], + "source": [ + "from great_ai.utilities import ConfigFile\n", + "from great_ai.large_file import LargeFileS3\n", + "from great_ai import configure, MongoDbDriver\n", + "\n", + "configuration = ConfigFile(\"config.ini\")\n", + "\n", + "LargeFileS3.configure_credentials_from_file(configuration)\n", + "MongoDbDriver.configure_credentials_from_file(configuration)\n", + "\n", + "configure(\n", + " dashboard_table_size=100, # traces are small, we can show many\n", + " prediction_cache_size=4096, # predictions are expensive, cache them\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For a pleasant developer experience, we create some typed models that will show up in the automatically generated OpenAPI schema specification and will also provide runtime type validation." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "from typing import List\n", + "from pydantic import BaseModel\n", + "\n", + "\n", + "class Attention(BaseModel):\n", + " weight: float\n", + " token: str\n", + "\n", + "\n", + "class EvaluatedSentence(BaseModel):\n", + " score: float\n", + " text: str\n", + " explanation: List[Attention]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Even though `@use_model` caches the remote files locally and it also handles deserialising objects, we only use it to store a directory. In this case, it gives back a path, the path to that directory. So, we need to load the files from that folder ourselves. In order to only load it once per process, we create a small model loader helper function.\n", + "\n", + "> This is usually not needed, however, when we can outsmart `dill` so for optimisation purposes, we do it." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[38;5;39mLatest version of scibert-highlights is 0 (from versions: 0)\u001b[0m\n", + "\u001b[38;5;39mFile scibert-highlights-0 found in cache\u001b[0m\n" + ] + } + ], + "source": [ + "from great_ai import use_model\n", + "from pathlib import Path\n", + "from typing import Tuple\n", + "from transformers import (\n", + " PreTrainedModel,\n", + " PreTrainedTokenizer,\n", + ")\n", + "from transformers import (\n", + " AutoConfig,\n", + " AutoModelForSequenceClassification,\n", + " AutoTokenizer,\n", + ")\n", + "\n", + "_tokenizer: PreTrainedTokenizer = None\n", + "_loaded_model: PreTrainedModel = None\n", + "\n", + "\n", + "@use_model(\"scibert-highlights\", version=\"latest\", model_kwarg_name=\"model_path\")\n", + "def get_tokenizer_and_model(\n", + " model_path: Path, original_model: str = \"allenai/scibert_scivocab_uncased\"\n", + ") -> Tuple[PreTrainedTokenizer, PreTrainedModel]:\n", + " global _tokenizer, _loaded_model\n", + "\n", + " if _tokenizer is None:\n", + " _tokenizer = AutoTokenizer.from_pretrained(original_model)\n", + "\n", + " if _loaded_model is None:\n", + " config = AutoConfig.from_pretrained(\n", + " model_path, output_hidden_states=True, output_attentions=True\n", + " )\n", + " _loaded_model = AutoModelForSequenceClassification.from_pretrained(\n", + " model_path, config=config\n", + " )\n", + "\n", + " return _tokenizer, _loaded_model" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Finally, implement the inference function." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "from great_ai import GreatAI\n", + "from great_ai.utilities import clean\n", + "\n", + "import re\n", + "import numpy as np\n", + "import torch\n", + "from transformers.modeling_outputs import SequenceClassifierOutput\n", + "\n", + "\n", + "@GreatAI.create\n", + "def find_highlights(sentence: str) -> EvaluatedSentence:\n", + " \"\"\"Get the interestingness prediction of the input sentence using SciBERT.\n", + "\n", + " Run the SciBERT model in inference mode and evaluate the sentence.\n", + " Additionally, provide explanation in the form of the last layer's sum attention\n", + " between `[CLS]` and the other tokens.\n", + " \"\"\"\n", + "\n", + " tokenizer, loaded_model = get_tokenizer_and_model()\n", + " sentence = clean(sentence, convert_to_ascii=True, remove_brackets=True)\n", + "\n", + " tensors = tokenizer(sentence, return_tensors=\"pt\", truncation=True, max_length=512)\n", + "\n", + " with torch.inference_mode():\n", + " result: SequenceClassifierOutput = loaded_model(**tensors)\n", + " positive_likelihood = torch.nn.Softmax(dim=1)(result.logits)[0][1]\n", + " tokens = tensors[\"input_ids\"][0]\n", + "\n", + " attentions = np.sum(result.attentions[-1].numpy()[0], axis=0)[0][1:-1]\n", + " # Tuple of `torch.FloatTensor` (one for each layer) of shape\n", + " # `(batch_size, num_heads, sequence_length, sequence_length)`.\n", + "\n", + " explanation = []\n", + "\n", + " token_attentions = list(zip(attentions, tokens[1:-1]))\n", + " for token in re.split(r\"([ .,])\", sentence):\n", + " token = token.strip()\n", + " if not token:\n", + " continue\n", + " bert_tokens = tokenizer(\n", + " token, return_tensors=\"pt\", truncation=True, max_length=512\n", + " )[\"input_ids\"][0][\n", + " 1:-1\n", + " ] # truncation=True needed to fix `RuntimeError: Already borrowed`\n", + " weight = 0\n", + " for t1 in bert_tokens:\n", + " if not token_attentions:\n", + " break\n", + " a, t2 = token_attentions.pop(0)\n", + " assert t1 == t2, sentence\n", + " weight += a\n", + " explanation.append(\n", + " Attention(\n", + " token=token if token in \".,\" else \" \" + token, weight=round(weight, 4)\n", + " )\n", + " )\n", + " if not token_attentions:\n", + " break\n", + "\n", + " return EvaluatedSentence(\n", + " score=positive_likelihood, text=sentence, explanation=explanation\n", + " )" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "A simple test to see everything works. Note that the models list is filled by the `@use_model` call even though it's not on the main inference function." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(Trace[EvaluatedSentence]({'created': '2022-07-16T18:47:29.581701',\n", + " 'exception': None,\n", + " 'feedback': None,\n", + " 'logged_values': { 'arg:sentence:length': 51,\n", + " 'arg:sentence:value': 'Our solution has outperformed the '\n", + " 'state-of-the-art.'},\n", + " 'models': [{'key': 'scibert-highlights', 'version': 0}],\n", + " 'original_execution_time_ms': 7127.2063,\n", + " 'output': { 'explanation': [ {'token': ' Our', 'weight': 0.3993},\n", + " {'token': ' solution', 'weight': 0.3481},\n", + " {'token': ' has', 'weight': 0.2945},\n", + " {'token': ' outperformed', 'weight': 0.4011},\n", + " {'token': ' the', 'weight': 0.1484},\n", + " {'token': ' state-of-the-art', 'weight': 0.5727},\n", + " {'token': '.', 'weight': 7.775}],\n", + " 'score': 0.9991180300712585,\n", + " 'text': 'Our solution has outperformed the state-of-the-art.'},\n", + " 'tags': ['find_highlights', 'online', 'development'],\n", + " 'trace_id': '56e20e94-79df-4793-ae61-d20820ebe2d3'}),\n", + " Trace[EvaluatedSentence]({'created': '2022-07-16T18:47:37.020275',\n", + " 'exception': None,\n", + " 'feedback': None,\n", + " 'logged_values': { 'arg:sentence:length': 36,\n", + " 'arg:sentence:value': 'Their solution did not perform '\n", + " 'well.'},\n", + " 'models': [{'key': 'scibert-highlights', 'version': 0}],\n", + " 'original_execution_time_ms': 170.7057,\n", + " 'output': { 'explanation': [ {'token': ' Their', 'weight': 1.1475},\n", + " {'token': ' solution', 'weight': 0.8205},\n", + " {'token': ' did', 'weight': 0.3254},\n", + " {'token': ' not', 'weight': 0.2921},\n", + " {'token': ' perform', 'weight': 0.4293},\n", + " {'token': ' well', 'weight': 0.2772},\n", + " {'token': '.', 'weight': 4.4723}],\n", + " 'score': 0.12305451184511185,\n", + " 'text': 'Their solution did not perform well.'},\n", + " 'tags': ['find_highlights', 'online', 'development'],\n", + " 'trace_id': '7fcf8271-1738-4025-8305-d5a1e5100aea'}))" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "if __name__ == \"__main__\":\n", + " find_highlights(\n", + " \"Our solution has outperformed the state-of-the-art.\"\n", + " ), find_highlights(\"Their solution did not perform well.\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In this case, the service is built as a docker image, pushed to our image registry and subsequent rolling update is performed in the production cluster.\n", + "To check out the Dockerimage, go to [the additional files page](/examples/scibert/additional-files)." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.10.4 ('.env': venv)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.4" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "02dd6d3afbfa9fbbe1037d64ad9014965528a1ccad21929d6e72f466389a68ad" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/docs/examples/scibert/index.md b/docs/examples/scibert/index.md new file mode 100644 index 0000000..9332607 --- /dev/null +++ b/docs/examples/scibert/index.md @@ -0,0 +1,50 @@ +# Summarising scientific publications from a tech-transfer perspective + +This is a simplified example illustrating how `great-ai` is used in practice at [ScoutinScience](https://www.scoutinscience.com/){ target=_blank }. The subpages show `great-ai` in action by going over the lifecycle of fine-tuning and deploying a BERT-based software service. + +??? note "Propriety data" + The purpose of this example is to show you different ways in which `great-ai` can assist you. The exact NLP task being solved is not central. Stemming from this and from the difficult nature of obtaining appropriate training data, the propriety dataset used for the experiments is not shared. + +## Objectives + +1. You will see how the [great_ai.utilities](/reference/utilities) can integrate into your Data Science workflow. +2. You will see how [great_ai.large_file](/reference/large-file) can be used to version and store your trained model. +3. You will see how [GreatAI][great_ai.GreatAI] should be used to prepare your model for a robust and responsible deployment. +4. You will see multiple ways of customising your deployment. + +## Overview + +One of the core features of the ScoutinScience platform is summarising research papers from a tech-transfer perspective. In short, extractive summarisation is preferred using a binary classifier trained on clients' judgement of sentence interestingness. Thus, documents are sentences, and the expected output is a binary label showing whether a sentence is "worthy" of being in the tech-transfer summary. Explaining each decision is imperative since ScoutinScience embraces applying only explainable AI (XAI) methods wherever feasible. + +!!! success + You are ready to start the tutorial. Feel free to return to the [summary](#summary) section once you're finished. + +
+[:material-database: Examine data](data.ipynb){ .md-button .md-button--primary } + +[:fontawesome-solid-chart-simple: Train model](train.ipynb){ .md-button .md-button--primary } + +[:material-cloud-tags: Deploy service](deploy.ipynb){ .md-button .md-button--primary } +
+ +## Summary + +### [Data notebook](data.ipynb) + +We load and analyse the data by calculating inter-rater reliability and checking the feasibility of using an AI-based approach by testing the accuracy of a trivial baseline method. + +### [Training notebook](train.ipynb) + +We simply fine-tune SciBERT. + +After training and evaluating a model, it is exported using [great_ai.save_model][]. For more info, check out [the configuration how-to page](/how-to-guides/configure-service). + +### [Deployment notebook](deploy.ipynb) + +We customise the GreatAI configuration, create custom caching for the model and implement an inference function that can be hardened by wrapping it in a [GreatAI][great_ai.GreatAI] instance. We also extract the attention weights as a quasi-explanation. + +Finally, we test the model's inference function through the GreatAI dashboard. [The only thing left is to deploy the hardened service properly.](/how-to-guides/use-service) + +#### [Additional files](additional-files.md) + +There are some other files required for deploying the notebook. For example, the config file for S3 and MongoDB or a Dockerfile for building a custom image. These are gathered and shown on a separate page. diff --git a/docs/examples/scibert/train.ipynb b/docs/examples/scibert/train.ipynb new file mode 100644 index 0000000..6e96889 --- /dev/null +++ b/docs/examples/scibert/train.ipynb @@ -0,0 +1,374 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Fine-tune SciBERT\n", + "\n", + "We are planning to do a simple classification task on scientific text. For that, [SciBERT](https://github.com/allenai/scibert) is an ideal model to fine-tune since it has been pretrained of academic publications.\n", + "\n", + "This notebook was updated so that it can run in [Google Colab](https://colab.research.google.com/).\n", + "\n", + "First, we need to install the dependencies." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "executionInfo": { + "elapsed": 2529, + "status": "ok", + "timestamp": 1656596749103, + "user_tz": -120 + }, + "id": "j7l0nD9hDQbB", + "outputId": "88a9931b-396a-4cf1-c659-8a7b098b3cdd" + }, + "outputs": [], + "source": [ + "!pip install transformers datasets great-ai > /dev/null" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Load the training data from S3. (We have uploaded this to S3 in the `data` notebook.)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[38;5;39mLatest version of summary-train-dataset-small is 0 (from versions: 0)\u001b[0m\n", + "\u001b[38;5;39mFile summary-train-dataset-small-0 found in cache\u001b[0m\n" + ] + } + ], + "source": [ + "from great_ai.large_file import LargeFileS3\n", + "import json\n", + "\n", + "LargeFileS3.configure_credentials_from_file(\"config.ini\")\n", + "\n", + "with LargeFileS3(\"summary-train-dataset-small\", encoding=\"utf-8\") as f:\n", + " # splitting training and test data is done later by `datasets`\n", + " X, y = json.load(f)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Finetune SciBERT, for more info about this step, check out [HuggingFace](https://huggingface.co/docs/transformers/training).\n", + "If you're only here for `great-ai`, feel free to skip the next cell." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "executionInfo": { + "elapsed": 118131, + "status": "ok", + "timestamp": 1656593941974, + "user_tz": -120 + }, + "id": "AL3etUQ3LtKN", + "outputId": "fe00589f-64dd-4b70-e612-3873b504c00a" + }, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "9c57de70e68a41ecbde5093bd671715a", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/1 [00:00\n", + " \n", + " \n", + " [130/650 01:43 < 07:01, 1.23 it/s, Epoch 10/50]\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
EpochTraining LossValidation LossF1
10.5868000.5121380.719101
20.4116000.4166750.849057
30.2456000.4170700.864000
40.1478000.5758780.852459
50.0568000.4742590.896552
60.0225000.7542360.843137
70.0010000.8576360.834783
80.0005000.9202320.869565
90.0003000.9707900.877193
100.0003000.9486890.862385

" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "...\n", + "Deleting older checkpoint [models/checkpoint-39] due to args.save_total_limit\n", + "***** Running Evaluation *****\n", + " Num examples = 100\n", + " Batch size = 32\n", + "Saving model checkpoint to models/checkpoint-117\n", + "Configuration saved in models/checkpoint-117/config.json\n", + "Model weights saved in models/checkpoint-117/pytorch_model.bin\n", + "Deleting older checkpoint [models/checkpoint-52] due to args.save_total_limit\n", + "***** Running Evaluation *****\n", + " Num examples = 100\n", + " Batch size = 32\n", + "Saving model checkpoint to models/checkpoint-130\n", + "Configuration saved in models/checkpoint-130/config.json\n", + "Model weights saved in models/checkpoint-130/pytorch_model.bin\n", + "Deleting older checkpoint [models/checkpoint-78] due to args.save_total_limit\n", + "\n", + "\n", + "Training completed. Do not forget to share your model on huggingface.co/models =)\n", + "\n", + "\n", + "Loading best model from models/checkpoint-65 (score: 0.896551724137931).\n" + ] + } + ], + "source": [ + "from transformers import (\n", + " AutoModelForSequenceClassification,\n", + " AutoTokenizer,\n", + " DataCollatorWithPadding,\n", + " Trainer,\n", + " TrainingArguments,\n", + " EarlyStoppingCallback,\n", + ")\n", + "from pathlib import Path\n", + "import numpy as np\n", + "from datasets import Dataset, load_metric\n", + "\n", + "MODEL = \"allenai/scibert_scivocab_uncased\"\n", + "BATCH_SIZE = 32\n", + "\n", + "tokenizer = AutoTokenizer.from_pretrained(MODEL)\n", + "model = AutoModelForSequenceClassification.from_pretrained(MODEL, num_labels=2)\n", + "data_collator = DataCollatorWithPadding(tokenizer=tokenizer)\n", + "\n", + "\n", + "def tokenize_function(v):\n", + " return tokenizer(v[\"text\"])\n", + "\n", + "\n", + "dataset = (\n", + " Dataset.from_dict({\"text\": X, \"label\": y})\n", + " .map(lambda v: tokenizer(v[\"text\"], truncation=True), batched=True)\n", + " .remove_columns(\"text\")\n", + " .train_test_split(test_size=0.2, shuffle=True) # test is actually validation\n", + ")\n", + "\n", + "f1_score = load_metric(\"f1\")\n", + "\n", + "\n", + "def compute_metrics(p):\n", + " pred, labels = p\n", + " pred = np.argmax(pred, axis=1)\n", + " return f1_score.compute(predictions=pred, references=labels)\n", + "\n", + "\n", + "training_args = TrainingArguments(\n", + " output_dir=Path(\"models\"),\n", + " per_device_train_batch_size=BATCH_SIZE,\n", + " per_device_eval_batch_size=BATCH_SIZE,\n", + " save_total_limit=5,\n", + " num_train_epochs=50,\n", + " save_strategy=\"epoch\",\n", + " evaluation_strategy=\"epoch\",\n", + " logging_strategy=\"epoch\",\n", + " weight_decay=0.01,\n", + " metric_for_best_model=\"f1\",\n", + " load_best_model_at_end=True,\n", + ")\n", + "\n", + "result = Trainer(\n", + " model=model,\n", + " args=training_args,\n", + " train_dataset=dataset[\"train\"],\n", + " eval_dataset=dataset[\"test\"],\n", + " data_collator=data_collator,\n", + " compute_metrics=compute_metrics,\n", + " callbacks=[EarlyStoppingCallback(early_stopping_patience=5)],\n", + ").train()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The best macro F1-score on the test set is **0.89** which is (not surprisingly) substantially more than the SVM achieved. We have a great model, it's time to deploy it. But first, we have to store it in a secure place." + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": { + "executionInfo": { + "elapsed": 25368, + "status": "ok", + "timestamp": 1656594537509, + "user": { + "displayName": "Schmelczer András", + "userId": "08401926777942666437" + }, + "user_tz": -120 + }, + "id": "fyNKltdquZSP", + "outputId": "e8c2cbb1-78e1-41a3-b7cf-b0cd573bc45d" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Configuration saved in pretrained/config.json\n", + "Model weights saved in pretrained/pytorch_model.bin\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " adding: pretrained/ (stored 0%)\n", + " adding: pretrained/config.json (deflated 49%)\n", + " adding: pretrained/pytorch_model.bin (deflated 7%)\n" + ] + } + ], + "source": [ + "from great_ai import save_model\n", + "\n", + "# save Torch model to local disk\n", + "model.save_pretrained(\"pretrained\")\n", + "\n", + "# upload model from local disk to S3\n", + "# (because the S3 credentials have been already set, `save_model` will use LargeFileS3)\n", + "save_model(\"pretrained\", key=\"scibert-highlights\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next: [Part 3](/examples/scibert/deploy)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.10.4 ('.env': venv)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.4" + }, + "vscode": { + "interpreter": { + "hash": "02dd6d3afbfa9fbbe1037d64ad9014965528a1ccad21929d6e72f466389a68ad" + } + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/docs/examples/simple-mag/mag-confusion.png b/docs/examples/simple-mag/mag-confusion.png new file mode 100644 index 0000000..e1d3718 Binary files /dev/null and b/docs/examples/simple-mag/mag-confusion.png differ diff --git a/docs/examples/simple-mag/mag-distribution.png b/docs/examples/simple-mag/mag-distribution.png new file mode 100644 index 0000000..c3246cc Binary files /dev/null and b/docs/examples/simple-mag/mag-distribution.png differ diff --git a/docs/examples/simple-mag/train.ipynb b/docs/examples/simple-mag/train.ipynb new file mode 100644 index 0000000..09faf2c --- /dev/null +++ b/docs/examples/simple-mag/train.ipynb @@ -0,0 +1,908 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Train a field of study (domain) classification of sentences on the [MAG](https://github.com/allenai/scibert/tree/master/data/text_classification/mag) dataset\n", + "\n", + "[SciBERT achieves an F1-score of 0.6571 on this dataset.](https://paperswithcode.com/sota/sentence-classification-on-paper-field) \n", + "This notebook shows that better results can be achieved without even using transformers." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 84000/84000 [00:16<00:00, 4964.08it/s]\n", + "100%|██████████| 22399/22399 [00:05<00:00, 3847.04it/s]\n" + ] + } + ], + "source": [ + "import json\n", + "from typing import Tuple\n", + "from great_ai.utilities import clean, simple_parallel_map\n", + "from tqdm.cli import tqdm\n", + "\n", + "\n", + "def preprocess(line: str) -> Tuple[str, str]:\n", + " data_point = json.loads(line)\n", + "\n", + " return (clean(data_point[\"text\"], convert_to_ascii=True), data_point[\"label\"])\n", + "\n", + "\n", + "with open(\"../../tutorial/data/train.txt\", encoding=\"utf-8\") as f:\n", + " training_data = simple_parallel_map(preprocess, f.readlines())\n", + "\n", + "X_train = [d[0] for d in training_data]\n", + "y_train = [d[1] for d in training_data]\n", + "\n", + "\n", + "with open(\"../../tutorial/data/test.txt\", encoding=\"utf-8\") as f:\n", + " test_data = simple_parallel_map(preprocess, f.readlines())\n", + "\n", + "X_test = [d[0] for d in test_data]\n", + "y_test = [d[1] for d in test_data]" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "

" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from collections import Counter\n", + "import matplotlib.pyplot as plt\n", + "\n", + "domains, counts = zip(*Counter(y_train).most_common())\n", + "\n", + "# Configure matplotlib to have nice, high-resolution charts\n", + "%matplotlib inline\n", + "plt.rcParams[\"figure.facecolor\"] = \"white\"\n", + "plt.rcParams[\"font.size\"] = 18\n", + "plt.rcParams[\"figure.figsize\"] = (8, 5)\n", + "\n", + "fig, ax = plt.subplots()\n", + "\n", + "plt.xticks(rotation=90)\n", + "ax.bar(domains, counts)\n", + "ax.set_ylabel(\"Count\")\n", + "fig.tight_layout()\n", + "fig.savefig(\"mag-distribution.png\", dpi=500)\n", + "None" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.naive_bayes import MultinomialNB\n", + "from sklearn.pipeline import Pipeline\n", + "from sklearn.feature_extraction.text import TfidfVectorizer\n", + "\n", + "\n", + "def create_pipeline() -> Pipeline:\n", + " return Pipeline(\n", + " steps=[\n", + " (\"vectorizer\", TfidfVectorizer(sublinear_tf=True)),\n", + " (\"classifier\", MultinomialNB()),\n", + " ]\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fitting 3 folds for each of 24 candidates, totalling 72 fits\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
mean_fit_timestd_fit_timemean_score_timestd_score_timeparam_classifier__alphaparam_classifier__fit_priorparam_vectorizer__max_dfparam_vectorizer__min_dfparamssplit0_test_scoresplit1_test_scoresplit2_test_scoremean_test_scorestd_test_scorerank_test_score
122.3527210.2579361.3573990.0945801True0.055{'classifier__alpha': 1, 'classifier__fit_prio...0.6772830.6703980.6656710.6711180.0047681
152.5449580.0519761.2456580.1371081True0.15{'classifier__alpha': 1, 'classifier__fit_prio...0.6769700.6702440.6661230.6711120.0044702
182.4728880.0539781.4471810.0511701False0.055{'classifier__alpha': 1, 'classifier__fit_prio...0.6756780.6693210.6653050.6701010.0042713
212.4676370.0053581.2162540.0483191False0.15{'classifier__alpha': 1, 'classifier__fit_prio...0.6755690.6694820.6652250.6700920.0042454
32.4776120.1348801.4285210.0174170.5True0.15{'classifier__alpha': 0.5, 'classifier__fit_pr...0.6752250.6689120.6656520.6699300.0039745
02.4848100.0678361.2499790.2099590.5True0.055{'classifier__alpha': 0.5, 'classifier__fit_pr...0.6752640.6687810.6653940.6698130.0040956
92.4524530.0493761.2796940.0892000.5False0.15{'classifier__alpha': 0.5, 'classifier__fit_pr...0.6741990.6680050.6644560.6688870.0040267
62.7486280.0980771.2552130.1013340.5False0.055{'classifier__alpha': 0.5, 'classifier__fit_pr...0.6739960.6680480.6645720.6688720.0038918
132.3719070.2048201.3751430.1939841True0.0520{'classifier__alpha': 1, 'classifier__fit_prio...0.6564590.6474330.6448640.6495850.0049729
162.5574860.1843321.2721370.1339801True0.120{'classifier__alpha': 1, 'classifier__fit_prio...0.6561960.6469600.6454360.6495300.00475410
42.3620930.1097961.3449600.0835620.5True0.120{'classifier__alpha': 0.5, 'classifier__fit_pr...0.6544240.6446900.6449910.6480350.00451911
12.6680120.1317511.3834410.0491570.5True0.0520{'classifier__alpha': 0.5, 'classifier__fit_pr...0.6546220.6449010.6444250.6479830.00469912
192.5175760.1541921.3742690.0267731False0.0520{'classifier__alpha': 1, 'classifier__fit_prio...0.6551250.6455860.6431660.6479590.00516313
222.3862400.0697180.9676380.0767661False0.120{'classifier__alpha': 1, 'classifier__fit_prio...0.6542540.6454090.6435140.6477260.00468014
72.4162110.1380011.3167850.0364020.5False0.0520{'classifier__alpha': 0.5, 'classifier__fit_pr...0.6527270.6436910.6427490.6463890.00449815
102.3977680.2449511.3300070.0089830.5False0.120{'classifier__alpha': 0.5, 'classifier__fit_pr...0.6522900.6429750.6434210.6462290.00429016
142.5901270.0543961.1559760.1876021True0.05100{'classifier__alpha': 1, 'classifier__fit_prio...0.5870970.5774110.5801700.5815600.00407517
172.4975560.0859521.1698080.0613361True0.1100{'classifier__alpha': 1, 'classifier__fit_prio...0.5857130.5771970.5807630.5812240.00349218
22.4676110.1683991.3139360.1096950.5True0.05100{'classifier__alpha': 0.5, 'classifier__fit_pr...0.5863460.5769870.5798520.5810620.00391519
52.3393220.0925951.2095150.1328250.5True0.1100{'classifier__alpha': 0.5, 'classifier__fit_pr...0.5856340.5762170.5803200.5807230.00385520
202.6444880.1199671.2385540.0488711False0.05100{'classifier__alpha': 1, 'classifier__fit_prio...0.5810960.5728330.5762800.5767360.00338921
82.4560300.0721361.2404630.0923830.5False0.05100{'classifier__alpha': 0.5, 'classifier__fit_pr...0.5808410.5723910.5757310.5763210.00347522
232.3357960.0823380.7861870.0734991False0.1100{'classifier__alpha': 1, 'classifier__fit_prio...0.5797690.5723730.5766990.5762800.00303423
112.5303310.1071991.2478420.0782290.5False0.1100{'classifier__alpha': 0.5, 'classifier__fit_pr...0.5797430.5716070.5763520.5759010.00333724
\n", + "
" + ], + "text/plain": [ + " mean_fit_time std_fit_time mean_score_time std_score_time \\\n", + "12 2.352721 0.257936 1.357399 0.094580 \n", + "15 2.544958 0.051976 1.245658 0.137108 \n", + "18 2.472888 0.053978 1.447181 0.051170 \n", + "21 2.467637 0.005358 1.216254 0.048319 \n", + "3 2.477612 0.134880 1.428521 0.017417 \n", + "0 2.484810 0.067836 1.249979 0.209959 \n", + "9 2.452453 0.049376 1.279694 0.089200 \n", + "6 2.748628 0.098077 1.255213 0.101334 \n", + "13 2.371907 0.204820 1.375143 0.193984 \n", + "16 2.557486 0.184332 1.272137 0.133980 \n", + "4 2.362093 0.109796 1.344960 0.083562 \n", + "1 2.668012 0.131751 1.383441 0.049157 \n", + "19 2.517576 0.154192 1.374269 0.026773 \n", + "22 2.386240 0.069718 0.967638 0.076766 \n", + "7 2.416211 0.138001 1.316785 0.036402 \n", + "10 2.397768 0.244951 1.330007 0.008983 \n", + "14 2.590127 0.054396 1.155976 0.187602 \n", + "17 2.497556 0.085952 1.169808 0.061336 \n", + "2 2.467611 0.168399 1.313936 0.109695 \n", + "5 2.339322 0.092595 1.209515 0.132825 \n", + "20 2.644488 0.119967 1.238554 0.048871 \n", + "8 2.456030 0.072136 1.240463 0.092383 \n", + "23 2.335796 0.082338 0.786187 0.073499 \n", + "11 2.530331 0.107199 1.247842 0.078229 \n", + "\n", + " param_classifier__alpha param_classifier__fit_prior \\\n", + "12 1 True \n", + "15 1 True \n", + "18 1 False \n", + "21 1 False \n", + "3 0.5 True \n", + "0 0.5 True \n", + "9 0.5 False \n", + "6 0.5 False \n", + "13 1 True \n", + "16 1 True \n", + "4 0.5 True \n", + "1 0.5 True \n", + "19 1 False \n", + "22 1 False \n", + "7 0.5 False \n", + "10 0.5 False \n", + "14 1 True \n", + "17 1 True \n", + "2 0.5 True \n", + "5 0.5 True \n", + "20 1 False \n", + "8 0.5 False \n", + "23 1 False \n", + "11 0.5 False \n", + "\n", + " param_vectorizer__max_df param_vectorizer__min_df \\\n", + "12 0.05 5 \n", + "15 0.1 5 \n", + "18 0.05 5 \n", + "21 0.1 5 \n", + "3 0.1 5 \n", + "0 0.05 5 \n", + "9 0.1 5 \n", + "6 0.05 5 \n", + "13 0.05 20 \n", + "16 0.1 20 \n", + "4 0.1 20 \n", + "1 0.05 20 \n", + "19 0.05 20 \n", + "22 0.1 20 \n", + "7 0.05 20 \n", + "10 0.1 20 \n", + "14 0.05 100 \n", + "17 0.1 100 \n", + "2 0.05 100 \n", + "5 0.1 100 \n", + "20 0.05 100 \n", + "8 0.05 100 \n", + "23 0.1 100 \n", + "11 0.1 100 \n", + "\n", + " params split0_test_score \\\n", + "12 {'classifier__alpha': 1, 'classifier__fit_prio... 0.677283 \n", + "15 {'classifier__alpha': 1, 'classifier__fit_prio... 0.676970 \n", + "18 {'classifier__alpha': 1, 'classifier__fit_prio... 0.675678 \n", + "21 {'classifier__alpha': 1, 'classifier__fit_prio... 0.675569 \n", + "3 {'classifier__alpha': 0.5, 'classifier__fit_pr... 0.675225 \n", + "0 {'classifier__alpha': 0.5, 'classifier__fit_pr... 0.675264 \n", + "9 {'classifier__alpha': 0.5, 'classifier__fit_pr... 0.674199 \n", + "6 {'classifier__alpha': 0.5, 'classifier__fit_pr... 0.673996 \n", + "13 {'classifier__alpha': 1, 'classifier__fit_prio... 0.656459 \n", + "16 {'classifier__alpha': 1, 'classifier__fit_prio... 0.656196 \n", + "4 {'classifier__alpha': 0.5, 'classifier__fit_pr... 0.654424 \n", + "1 {'classifier__alpha': 0.5, 'classifier__fit_pr... 0.654622 \n", + "19 {'classifier__alpha': 1, 'classifier__fit_prio... 0.655125 \n", + "22 {'classifier__alpha': 1, 'classifier__fit_prio... 0.654254 \n", + "7 {'classifier__alpha': 0.5, 'classifier__fit_pr... 0.652727 \n", + "10 {'classifier__alpha': 0.5, 'classifier__fit_pr... 0.652290 \n", + "14 {'classifier__alpha': 1, 'classifier__fit_prio... 0.587097 \n", + "17 {'classifier__alpha': 1, 'classifier__fit_prio... 0.585713 \n", + "2 {'classifier__alpha': 0.5, 'classifier__fit_pr... 0.586346 \n", + "5 {'classifier__alpha': 0.5, 'classifier__fit_pr... 0.585634 \n", + "20 {'classifier__alpha': 1, 'classifier__fit_prio... 0.581096 \n", + "8 {'classifier__alpha': 0.5, 'classifier__fit_pr... 0.580841 \n", + "23 {'classifier__alpha': 1, 'classifier__fit_prio... 0.579769 \n", + "11 {'classifier__alpha': 0.5, 'classifier__fit_pr... 0.579743 \n", + "\n", + " split1_test_score split2_test_score mean_test_score std_test_score \\\n", + "12 0.670398 0.665671 0.671118 0.004768 \n", + "15 0.670244 0.666123 0.671112 0.004470 \n", + "18 0.669321 0.665305 0.670101 0.004271 \n", + "21 0.669482 0.665225 0.670092 0.004245 \n", + "3 0.668912 0.665652 0.669930 0.003974 \n", + "0 0.668781 0.665394 0.669813 0.004095 \n", + "9 0.668005 0.664456 0.668887 0.004026 \n", + "6 0.668048 0.664572 0.668872 0.003891 \n", + "13 0.647433 0.644864 0.649585 0.004972 \n", + "16 0.646960 0.645436 0.649530 0.004754 \n", + "4 0.644690 0.644991 0.648035 0.004519 \n", + "1 0.644901 0.644425 0.647983 0.004699 \n", + "19 0.645586 0.643166 0.647959 0.005163 \n", + "22 0.645409 0.643514 0.647726 0.004680 \n", + "7 0.643691 0.642749 0.646389 0.004498 \n", + "10 0.642975 0.643421 0.646229 0.004290 \n", + "14 0.577411 0.580170 0.581560 0.004075 \n", + "17 0.577197 0.580763 0.581224 0.003492 \n", + "2 0.576987 0.579852 0.581062 0.003915 \n", + "5 0.576217 0.580320 0.580723 0.003855 \n", + "20 0.572833 0.576280 0.576736 0.003389 \n", + "8 0.572391 0.575731 0.576321 0.003475 \n", + "23 0.572373 0.576699 0.576280 0.003034 \n", + "11 0.571607 0.576352 0.575901 0.003337 \n", + "\n", + " rank_test_score \n", + "12 1 \n", + "15 2 \n", + "18 3 \n", + "21 4 \n", + "3 5 \n", + "0 6 \n", + "9 7 \n", + "6 8 \n", + "13 9 \n", + "16 10 \n", + "4 11 \n", + "1 12 \n", + "19 13 \n", + "22 14 \n", + "7 15 \n", + "10 16 \n", + "14 17 \n", + "17 18 \n", + "2 19 \n", + "5 20 \n", + "20 21 \n", + "8 22 \n", + "23 23 \n", + "11 24 " + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from sklearn.model_selection import GridSearchCV\n", + "import pandas as pd\n", + "\n", + "optimisation_pipeline = GridSearchCV(\n", + " create_pipeline(),\n", + " {\n", + " \"vectorizer__min_df\": [5, 20, 100],\n", + " \"vectorizer__max_df\": [0.05, 0.1],\n", + " \"classifier__alpha\": [0.5, 1],\n", + " \"classifier__fit_prior\": [True, False],\n", + " },\n", + " scoring=\"f1_macro\",\n", + " cv=3,\n", + " n_jobs=-1,\n", + " verbose=1,\n", + ")\n", + "optimisation_pipeline.fit(X_train, y_train)\n", + "\n", + "results = pd.DataFrame(optimisation_pipeline.cv_results_)\n", + "results.sort_values(\"rank_test_score\")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
Pipeline(steps=[('vectorizer',\n",
+       "                 TfidfVectorizer(max_df=0.05, min_df=5, sublinear_tf=True)),\n",
+       "                ('classifier', MultinomialNB(alpha=1))])
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ], + "text/plain": [ + "Pipeline(steps=[('vectorizer',\n", + " TfidfVectorizer(max_df=0.05, min_df=5, sublinear_tf=True)),\n", + " ('classifier', MultinomialNB(alpha=1))])" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from sklearn import set_config\n", + "\n", + "set_config(display=\"diagram\")\n", + "\n", + "classifier = create_pipeline()\n", + "classifier.set_params(**optimisation_pipeline.best_params_)\n", + "classifier.fit(X_train, y_train)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " precision recall f1-score support\n", + "\n", + " business 0.6412 0.7258 0.6808 3198\n", + " economics 0.6635 0.7146 0.6881 3189\n", + " geography 0.7461 0.6791 0.7111 3207\n", + " medicine 0.8806 0.9021 0.8912 3187\n", + " politics 0.5563 0.5895 0.5724 3169\n", + " psychology 0.7654 0.6811 0.7208 3252\n", + " sociology 0.5165 0.4698 0.4921 3197\n", + "\n", + " accuracy 0.6803 22399\n", + " macro avg 0.6814 0.6803 0.6795 22399\n", + "weighted avg 0.6817 0.6803 0.6796 22399\n", + "\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from sklearn import metrics\n", + "import matplotlib.pyplot as plt\n", + "\n", + "y_predicted = classifier.predict(X_test)\n", + "\n", + "%matplotlib inline\n", + "plt.rcParams[\"figure.figsize\"] = (20, 18)\n", + "plt.rcParams[\"figure.facecolor\"] = \"white\"\n", + "plt.rcParams[\"font.size\"] = 22\n", + "plt.rcParams[\"axes.xmargin\"] = 0\n", + "\n", + "print(metrics.classification_report(y_test, y_predicted, digits=4))\n", + "metrics.ConfusionMatrixDisplay.from_predictions(\n", + " y_true=y_test,\n", + " y_pred=y_predicted,\n", + " xticks_rotation=\"vertical\",\n", + " normalize=\"pred\",\n", + " values_format=\".2f\",\n", + ")\n", + "plt.tight_layout()\n", + "plt.savefig(\"mag-confusion.png\", dpi=600)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.10.4 ('.env': venv)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.4" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "02dd6d3afbfa9fbbe1037d64ad9014965528a1ccad21929d6e72f466389a68ad" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/docs/examples/simple/data.ipynb b/docs/examples/simple/data.ipynb new file mode 100644 index 0000000..31dc3fc --- /dev/null +++ b/docs/examples/simple/data.ipynb @@ -0,0 +1,233 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Simple example: data engineering\n", + "\n", + "Here, we solve a problem similar to the tutorial's but with an explainable Naive Bayes classifier and more best practices. In short, we train a domain classifier on the [semantic scholar dataset](https://api.semanticscholar.org/corpus) by taking full advantage of `great-ai`. Subsequently, we create a production-ready deployment.\n", + "\n", + "![position of this step in the lifecycle](/media/scope-data.svg)\n", + "> The blue boxes show the steps of a typical AI-development lifecycle implemented in this notebook.\n", + "\n", + "Since the true scope of `great-ai` is the phase between proof-of-concept code and production-ready service, it is predominantly used in the [deployment notebook](/examples/simple/deploy). Feel free to skip there, or continue reading if you'd like to see the full picture.\n", + "\n", + "### Extract\n", + "\n", + "This can be achieved by downloading a public dataset (such as in this case), or by having a Data Engineer setup and give us access to the organisation's data.\n", + "\n", + "In this example, we download the semantic scholar dataset from a public S3 bucket." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "MAX_CHUNK_COUNT = 4" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'Processing 4 out of the 6002 available chunks'" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import urllib.request\n", + "from random import shuffle\n", + "\n", + "manifest = (\n", + " urllib.request.urlopen(\n", + " \"https://s3-us-west-2.amazonaws.com/ai2-s2-research-public/\"\n", + " \"open-corpus/2022-02-01/manifest.txt\"\n", + " )\n", + " .read()\n", + " .decode()\n", + ") # a list of available chunks separated by '\\n' characters\n", + "\n", + "lines = manifest.split()\n", + "shuffle(lines)\n", + "chunks = lines[:MAX_CHUNK_COUNT]\n", + "\n", + "f\"\"\"Processing {len(chunks)} out of the {\n", + " len(manifest.split())\n", + "} available chunks\"\"\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Transform\n", + "\n", + "- Filter out non-English abstracts using `great_ai.utilities.predict_language`\n", + "- Project it to only keep the necessary components (text and labels), clean the textual content using `great_ai.utilities.clean`\n", + "- We will speed up processing using `great_ai.utilities.simple_parallel_map`." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 4/4 [04:22<00:00, 65.51s/it] \n" + ] + } + ], + "source": [ + "from typing import List, Tuple\n", + "import json\n", + "import gzip\n", + "from great_ai.utilities import (\n", + " simple_parallel_map,\n", + " clean,\n", + " is_english,\n", + " predict_language,\n", + " unchunk,\n", + ")\n", + "\n", + "\n", + "def preprocess_chunk(chunk_key: str) -> List[Tuple[str, List[str]]]:\n", + " response = urllib.request.urlopen(\n", + " f\"https://s3-us-west-2.amazonaws.com/ai2-s2-research-public/\"\n", + " f\"open-corpus/2022-02-01/{chunk_key}\"\n", + " ) # a gzipped JSON Lines file\n", + "\n", + " decompressed = gzip.decompress(response.read())\n", + " decoded = decompressed.decode()\n", + " chunk = [json.loads(line) for line in decoded.split(\"\\n\") if line]\n", + "\n", + " # Transform\n", + " return [\n", + " (\n", + " clean(\n", + " f'{c[\"title\"]} {c[\"paperAbstract\"]} '\n", + " f'{c[\"journalName\"]} {c[\"venue\"]}',\n", + " convert_to_ascii=True,\n", + " ), # The text is cleaned to remove common artifacts\n", + " c[\"fieldsOfStudy\"],\n", + " ) # Create pairs of `(text, [...domains])`\n", + " for c in chunk\n", + " if (c[\"fieldsOfStudy\"] and is_english(predict_language(c[\"paperAbstract\"])))\n", + " ]\n", + "\n", + "\n", + "preprocessed_data = unchunk(\n", + " simple_parallel_map(preprocess_chunk, chunks, concurrency=4)\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "X, y = zip(*preprocessed_data) # X is the input, y is the expected output" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Load\n", + "\n", + "Upload the dataset (or a part of it) to a central repository using `great_ai.add_ground_truth`. This step automatically tags each data-point with a split label according to the ratios we set. Additional tags can be also given.\n", + "\n", + "#### Production-ready backend\n", + "\n", + "The MongoDB driver is automatically configured if `mongo.ini` exists with the following scheme:\n", + "\n", + "```ini\n", + "mongo_connection_string=mongodb://localhost:27017/\n", + "mongo_database=my_great_ai_db\n", + "```\n", + "> You can install MongoDB from [here](https://www.mongodb.com/docs/manual/installation) or [use it as a service](https://www.mongodb.com/cloud/atlas/register)\n", + "\n", + "Otherwise, TinyDB is used which is just a local JSON file." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[38;5;226mEnvironment variable ENVIRONMENT is not set, defaulting to development mode ‼️\u001b[0m\n", + "\u001b[38;5;226mCannot find credentials files, defaulting to using ParallelTinyDbDriver\u001b[0m\n", + "\u001b[38;5;226mThe selected tracing database (ParallelTinyDbDriver) is not recommended for production\u001b[0m\n", + "\u001b[38;5;226mCannot find credentials files, defaulting to using LargeFileLocal\u001b[0m\n", + "\u001b[38;5;39mGreatAI (v0.1.6): configured ✅\u001b[0m\n", + "\u001b[38;5;39m 🔩 tracing_database: ParallelTinyDbDriver\u001b[0m\n", + "\u001b[38;5;39m 🔩 large_file_implementation: LargeFileLocal\u001b[0m\n", + "\u001b[38;5;39m 🔩 is_production: False\u001b[0m\n", + "\u001b[38;5;39m 🔩 should_log_exception_stack: True\u001b[0m\n", + "\u001b[38;5;39m 🔩 prediction_cache_size: 512\u001b[0m\n", + "\u001b[38;5;39m 🔩 dashboard_table_size: 50\u001b[0m\n", + "\u001b[38;5;226mYou still need to check whether you follow all best practices before trusting your deployment.\u001b[0m\n", + "\u001b[38;5;226m> Find out more at https://se-ml.github.io/practices\u001b[0m\n" + ] + } + ], + "source": [ + "from great_ai import add_ground_truth\n", + "\n", + "add_ground_truth(X, y, train_split_ratio=0.8, test_split_ratio=0.2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Next: [Part 2](/examples/simple/train)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.10.4 ('.env': venv)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.4" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "02dd6d3afbfa9fbbe1037d64ad9014965528a1ccad21929d6e72f466389a68ad" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/docs/examples/simple/deploy.ipynb b/docs/examples/simple/deploy.ipynb new file mode 100644 index 0000000..abe5ac8 --- /dev/null +++ b/docs/examples/simple/deploy.ipynb @@ -0,0 +1,251 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Hardening and deployment\n", + "\n", + "> Part 3: Create production inference function\n", + "\n", + "![position of this step in the lifecycle](/media/scope-deploy.svg)\n", + "> The blue boxes show the steps implemented in this notebook.\n", + "\n", + "In [Part 2](/examples/simple/train), we trained our AI model. Now, it's time to create **G**eneral **R**obust **E**nd-to-end **A**utomated **T**rustworthy deployment.\n", + "\n", + "## Create the inference function\n", + "\n", + "Next to the prediction, we also return the top-n most influential words based on their weights." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[38;5;226mEnvironment variable ENVIRONMENT is not set, defaulting to development mode ‼️\u001b[0m\n", + "\u001b[38;5;226mCannot find credentials files, defaulting to using ParallelTinyDbDriver\u001b[0m\n", + "\u001b[38;5;226mThe selected tracing database (ParallelTinyDbDriver) is not recommended for production\u001b[0m\n", + "\u001b[38;5;226mCannot find credentials files, defaulting to using LargeFileLocal\u001b[0m\n", + "\u001b[38;5;39mGreatAI (v0.1.6): configured ✅\u001b[0m\n", + "\u001b[38;5;39m 🔩 tracing_database: ParallelTinyDbDriver\u001b[0m\n", + "\u001b[38;5;39m 🔩 large_file_implementation: LargeFileLocal\u001b[0m\n", + "\u001b[38;5;39m 🔩 is_production: False\u001b[0m\n", + "\u001b[38;5;39m 🔩 should_log_exception_stack: True\u001b[0m\n", + "\u001b[38;5;39m 🔩 prediction_cache_size: 512\u001b[0m\n", + "\u001b[38;5;39m 🔩 dashboard_table_size: 50\u001b[0m\n", + "\u001b[38;5;226mYou still need to check whether you follow all best practices before trusting your deployment.\u001b[0m\n", + "\u001b[38;5;226m> Find out more at https://se-ml.github.io/practices\u001b[0m\n", + "\u001b[38;5;39mFetching cached versions of small-domain-prediction\u001b[0m\n", + "\u001b[38;5;39mLatest version of small-domain-prediction is 2 (from versions: 0, 1, 2)\u001b[0m\n", + "\u001b[38;5;39mFile small-domain-prediction-2 found in cache\u001b[0m\n" + ] + } + ], + "source": [ + "import re\n", + "import numpy as np\n", + "from sklearn.pipeline import Pipeline\n", + "from great_ai.utilities import clean\n", + "from great_ai import (\n", + " MultiLabelClassificationOutput,\n", + " ClassificationOutput,\n", + " GreatAI,\n", + " use_model,\n", + " parameter,\n", + ")\n", + "\n", + "\n", + "@GreatAI.create\n", + "@use_model(\"small-domain-prediction\", version=\"latest\")\n", + "@parameter(\"target_confidence\", validate=lambda c: 0 <= c <= 100)\n", + "def predict_domain(\n", + " text: str, model: Pipeline, target_confidence: int = 50\n", + ") -> MultiLabelClassificationOutput:\n", + " \"\"\"\n", + " Predict the scientific domain of the input text.\n", + " Return labels until their sum likelihood is larger than `target_confidence`.\n", + " \"\"\"\n", + "\n", + " preprocessed = re.sub(r\"[^a-zA-Z\\s]\", \"\", clean(text, convert_to_ascii=True))\n", + " features = model.named_steps[\"vectorizer\"].transform([preprocessed])\n", + " prediction = model.named_steps[\"classifier\"].predict_proba(features)[0]\n", + "\n", + " best_classes = sorted(enumerate(prediction), key=lambda v: v[1], reverse=True)\n", + "\n", + " results = MultiLabelClassificationOutput()\n", + " for class_index, probability in best_classes:\n", + " results.labels.append(\n", + " get_label(\n", + " model=model,\n", + " features=features,\n", + " class_index=class_index,\n", + " probability=probability,\n", + " )\n", + " )\n", + "\n", + " if sum(r.confidence for r in results.labels) >= target_confidence:\n", + " break\n", + "\n", + " return results\n", + "\n", + "\n", + "def get_label(\n", + " model: Pipeline, features: np.ndarray, class_index: int, probability: float\n", + ") -> ClassificationOutput:\n", + " return ClassificationOutput(\n", + " label=model.named_steps[\"classifier\"].classes_[class_index],\n", + " confidence=round(probability * 100),\n", + " explanation=[\n", + " word\n", + " for _, word in sorted(\n", + " (\n", + " (weight, word)\n", + " for weight, word, count in zip(\n", + " model.named_steps[\"classifier\"].feature_log_prob_[class_index],\n", + " model.named_steps[\"vectorizer\"].get_feature_names_out(),\n", + " features.A[0],\n", + " )\n", + " if count > 0\n", + " ),\n", + " reverse=True,\n", + " )\n", + " ][:5],\n", + " )" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Check accuracy on the test split\n", + "\n", + "Anything under `if __name__ == \"__main__\":` will not be run when the script is executed by the `great-ai` CLI app. This, combined with `query_ground_truth` and the `/traces/{trace_id}/feedback` endpoint are ideal for creating a continuous-integration job for checking the quality of the model before deployment." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 12272/12272 [01:10<00:00, 174.77it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " precision recall f1-score support\n", + "\n", + " Art 0.54 0.38 0.45 126\n", + " Biology 0.77 0.84 0.80 1215\n", + " Business 0.47 0.73 0.57 311\n", + " Chemistry 0.82 0.67 0.74 1205\n", + " Computer Science 0.77 0.76 0.76 1277\n", + " Economics 0.69 0.55 0.61 270\n", + " Engineering 0.55 0.52 0.53 754\n", + "Environmental Science 0.56 0.55 0.55 227\n", + " Geography 0.54 0.39 0.45 276\n", + " Geology 0.74 0.67 0.70 265\n", + " History 0.35 0.18 0.24 140\n", + " Materials Science 0.72 0.81 0.76 1011\n", + " Mathematics 0.77 0.70 0.74 498\n", + " Medicine 0.96 0.77 0.86 2835\n", + " Philosophy 0.57 0.06 0.10 71\n", + " Physics 0.66 0.75 0.70 611\n", + " Political Science 0.44 0.61 0.51 291\n", + " Psychology 0.52 0.84 0.64 574\n", + " Sociology 0.33 0.59 0.42 315\n", + "\n", + " accuracy 0.71 12272\n", + " macro avg 0.62 0.60 0.59 12272\n", + " weighted avg 0.74 0.71 0.71 12272\n", + "\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABPMAAATQCAYAAACWWAA2AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOzdd3hTVeMH8G+6R7r3HtACBVmC7I3sIfiKg9Ei0y0goKBSVFA2Ku9P4AUBZQgqICAiIENWGbJXoRu6927Spvf3R9qkIelKgXjh+3mePg/c3JN8e3pycnPuuedKBEEQQERERERERERERP96RoYOQERERERERERERHXDwTwiIiIiIiIiIiKR4GAeERERERERERGRSHAwj4iIiIiIiIiISCQ4mEdERERERERERCQSHMwjIiIiIiIiIiISCRNDByAiIiIiIiIiInHp38samVkKQ8d4ZJw9euLAgQOGjqETB/OIiIiIiIiIiKheMrMUOPenr6FjPDLPDckwdIRq8TJbIiIiIiIiIiIikeBgHhERERERERERkUjwMlsiIiIiIiIiIqoXAUA5yg0d46nEmXlEREREREREREQiwcE8IiIiIiIiIiIikeBgHhERERERERERkUhwMI+IiIiIiIiIiEgkeAMMIiIiIiIiIiKqJwEKgTfAMATOzCMiIiIiIiIiIhIJDuYRERERERERERGJBAfziIiIiIiIiIiIRIJr5hERERERERERUb0IAMohGDrGU4kz84iIiIiIiIiIiESCg3lEREREREREREQiwcE8IiIiIiIiIiIikeBgHhERERERERERkUjwBhhERERERERERFRv5Sg3dISnEmfmERERERERERERiQQH84iIiIiIiIiIiESCg3lEREREREREREQiwTXziIiIiIiIiIioXgQIUAiCoWM8lTgzj4iIiIiIiIiISCQ4mEdERERERERERCQSHMwjIiIiIiIiIiISCa6ZR0RERERERERE9VYOrplnCJyZR0REREREREREJBIczCMiIiIiIiIiIhIJDuYRERERERERERGJBAfziIiIiIiIiIiIRII3wCAiIiIiIiIionoRACh4AwyD4Mw8IiIiIiIiIiIikeBgHhERERERERERkUhwMI+IiIiIiIiIiEgkuGYeERERERERERHVWznXzDMIzswjIiIiIiIiIiISCQ7mERERERERERERiQQH84iIiIiIiIiIiESCa+YREREREREREVG9CAAUAtfMMwTOzCMiIiIiIiIiIhIJDuYRERERERERERGJBAfziIiIiIiIiIiIRIKDeURERERERERERCLBG2AQEREREREREVG9lRs6wFOKM/OIiIiIiIiIiIhEgoN5REREREREREREIsHBPCIiIiIiIiIiIpHgmnlERERERERERFQvAgQoIBg6xlOJM/OIiIiIiIiIiIhEgoN5REREREREREREIsHBPCIiIiIiIiIiIpHgmnlERERERERERFQ/AqDgknkGwZl5REREREREREREIsHBPCIiIiIiIiIiIpHgYB4REREREREREZFIcDCPiIiIiIiIiIhIJHgDDCIiIiIiIiIiqhcBQLmhQzylODOPiIiIiIiIiIhIJDiYR0REREREREREJBIczCMiIiIiIiIiIhIJrplHRERERERERET1JIECEkOHeCpxZh4REREREREREZFIcDCPiIiIiIiIiIhIJDiYR0REREREREREJBJcM4+IiIiIiIiIiOpFAFAuGDrF04kz84iIiIiIiIiIiESCg3lEREREREREREQiwcE8IiIiIiIiIiIikeBgHhERERERERERkUjwBhhERERERERERFRvCkgMHeGpxJl5REREREREREREIsHBPCIiIiIiIiIiIpHgYB4REREREREREZFIcM08IiIiIiIiIiKqFwFcM89QODOPiIiIiIiIiIhIJDiYR0REREREREREJBIczCMiIiIiIiIiIhIJDuYRERERERERERGJBG+AQURERERERERE9VYu8AYYhsCZeURERERERERERCLBwTwiIiIiIiIiIiKR4GAeERERERERERGRSHDNPCIiIiIiIiIiqhcBgAJcM88QODOPiIiIiIiIiIhIJDiYR0REREREREREJBIczCMiIiIiIiIiIhIJrplHRERERERERET1IkACBeeIGQRrnYiIiIiIiIiISCQ4mEdERERERERERCQSHMwjIiIiIiIiIiISCQ7mERERERERERERiQRvgEFERERERERERPVWLkgMHeGpxJl5REREREREREREIsHBPCIiIiIiIiIiIpHgYB4REREREREREZFIcM08IiIiIiIiIiKqFwGAAlwzzxA4M4+IiIiIiIiIiEgkOJhHREREREREREQkEhzMIyIiIiIiIiIiEgmumUdERERERERERPUkgULgHDFDYK0TERERERERERGJBAfziIiIiIiIiIiIRIKDeURERERERERERCLBwTwiIiIiIiIiIiKR4A0wiIiIiIiIiIioXgQA5ZwjZhCsdSIiIiIiIiIiIpHgYB4REREREREREZFIcDCPiIiIiIiIiIhIJLhmHtFjYGxjDRMnB0PH0It5fJGhIxAREVVLsLMydAS9SXL5GUtEVBcSM1NDR9BLcVke5IpiQ8d4pBSQGDrCU4mDeUSPgYmTA9znvWPoGHoJnnDB0BGIiP79JCI/kBUEQyfQm6xbe0NH0Jv57+cNHYGI6kPMfb1E3Bflmbh7GDqCXk6nbDV0BHpCifsdTURERERERERE9BThYB4REREREREREZFI8DJbIiIiIiIiIiKqF0GQQCFwjpghsNaJiIiIiIiIiIhEgoN5REREREREREREIsHBPCIiIiIiIiIiIpHgYB4REREREREREZFI8AYYRERERERERERUb+WQGDrCU4kz84iIiIiIiIiIiESCg3lEREREREREREQiwcE8IiIiIiIiIiIikeCaeUREREREREREVC8CAAXniBkEa52IiIiIiIiIiEgkOJhHREREREREREQkErzMlsjATLLkcPnpHqxu5gGCgKIQW6S/4oMyJ/NaywZPuKBze/y8EMh8rXQ+ZnM2Cx5rY1DqYIrYpa0alB0AXDzlmBKehLbd8wEJcOmEDVbP80R6olmtZU3NyxE6KwW9R2ZDaqtA9A1LrF/ggetnpRr7SSQCRr2VhkFjM+HoUob70ebYssINJ/fbM7sIs4s9P7Mzu/75E9G2W9X8XkhPqmP+mcnq/DctsX6Bp1b+kZPT0KpzAYJaFsHJrQw/LnPD5uUeDym7OOvexaEAb78cgWebJUIiAf655YlV2zshLUtaY7kmfukY0v02WgWlwNWxALkFFrga5Y71u9shJcNGtZ+luRyzwk4g2DcTjnZFUCiMcC/VDjv/CsGhs0ENyg6IvO6Zndmfsvyi7uc95JgSfh9tu+Ups5+0wep5PvXInoTeI7IgtVMg+oYV1i/0xPWzNhr7jZyUilad89XZl7tj83LPBmcHAGfXYkyadhNtnsuARAJcPueEtSuaIz3Vsvb8ZgqMnXIHvQYkwlpaipi7ttiwqiluXHbS2M/GVo5XJ95Fh66pcHCSITvLHOdPuWLruiDk5dT+vY3oYePMPCIDksgU8F4SCbPkYqS87o+UiQEwS5XBe8kdSGSKOj1HbhcnJMxpqvEjd9P9gWJUVAaXnxJQZmf6UPKbW5Zj0Y5o+DSWYcn7vljyri+8AmRY/HM0zC1rzz992T0MfC0TPy5xx6ehAchKM8XCrTEIbF6ssV/orBSMmZGKvRuc8fGYQNy6aIW5a+PRvnces4ssu9jzMzuz65XfohyLdkTBp1Flfr+K/FF1y7+0Iv9SD3waFoisVFMs3BKNwOZFGvsNfC0T9k5lOPOnXYPyamQXcd2bm5VhxYz98HXPxVcbemDh+p7wds3Dihm/w8KstMayvdvHwN8zG78eaY7Z3wzA2p3tEeybgTVzd8PFoUC1n6lJORQKI2z5oxXmrnoen/+vF+KT7TF34nH8p+81vbMDIq97Zmf2pyy/qPt5i3Is2nEXPo1KsGSaP5a856/MvuNOHbPHY+CrmfhxmSc+DW2ErDQTLNwShcCQB7NnwN65DGf+tH9o2QHA3FyBhf8XAW+/Aiyf3wrLwlvB06cIX/5fBMwtymot/97cq+g/PAGb1wZj/oz2yM4wx+dfn0NgUG6VvQR8uvQCevZLwq+bG2HetOewc3Mguj+fhHnLLkC5chzR48WZefTUmjRpEtatW4f3338fK1asqHO5lStXwtfXFyNHjmxwBru/M2CaLkPcghYodbMAAMi8rRAw5xrsjqUjp797rc9RZm+GkkY1zzCo5Pzzfch8rFBmZwqrWw074AKUBxTufnJM7NYUSXHKAcSYmxbYcOo2Bo/Nws61LtWWDQwpRu+ROVg2zQcHtzsCAK6ekWLtsUiMm5mC8LAAAICdUylenJqOHf91xS+rXQEAV05L4ekvx+tzknH+iC2ziyi72PMzO7PrlX90Jtx95ZjYvZk6/y0LbDh5C4PHZmLnWtda8mcr8+9wUuc/ehvjPkhB+PhA1b6TezWFIEhgZCxgyLhMvfNqZBdx3Q/pdhseLvkY9/F/kJiu/OIbneiILV/swNAet/HzoWeqLbv1QEvkFmjO6Lge5YZtX27HkG6R2LDnWQBAXqEFvljXS2O/s9d94OOWi0Fd7uCXw9W/Rm3EXPfMzuxPW35R9/OjM+DuK8PEHiFIirOoyG6JDSduYPCYDOz8n1v12ZsVofeIbCyb7qfOHmGDtUduYtwHyQh/vZE6e++QKtkzHkp2AOj/QgLcPYswZVRPJN+3BgDE3rXF/345hoEjErB7W2C1ZQOC8tBrQBJWfN4Sh/f5AACuXXLEd9v+xpjJd/DZzPYAAE+fQoS0ysa3Xz6DA7t9lftddEJ5uQRvf3gdXr6FSEyo2/exJ48ECoFzxAyBtU5PpeLiYuzYsQMAsHXrVpSV1X7WptLKlSuxc+fOh5JDejkHJY2sVQN5AFDmYo7ixlJIL+c8lNeoZHE3H7YRWUgb7fvQnrNjvzzcvmilOmgBgNR75rhx3hqd+ufWUFJZtlQuwfE99qpt5QoJjv9mj2d75MPUrBwA0K5nPszMBfz1q4NG+SM7HRAYUgI3Hxmziyi72PMzO7Prlz8Xty9a687fr7b8uRX51bl05QcAQZDonbH61xdv3XdulYCbMS6qgTwASMmwwbUoN3RpFV9j2QcH8gAgNcsGOQUWcHYorPW18wrNoShv2GG2mOue2Zn9acsv6n7++crs6u8jqffMceOCtA71Xk32PQ54tkfeI88OAB26pSLyuoNqIA8AUpOtcPOqAzp2T621bGmpBCcOqS/3LVcY4e9DnmjbMQMmpsqZiaamypl3RYWac6EKC5RXOxkZcWYePX4czKOn0u7du5GXl4dBgwYhLS0NBw4cqLWMTKb/wUl1zJKKIfPS/sIg97SEWVJJnZ7D/lgaGk/5B43fuAjvJZGwvJOvvVNZOdx+iEd2fzeNgcOG8mtSgrjb2s8XH2kB3+Ca8/s1KUHKPTPIijW7ofhIC5iZC/D0l6v2k5dIkBRrprUfAPgF6/d3YXbDZBd7fmZndr3yB5cgLlJH/jt1yB9ckb/kgfx3KvM//M8mjdcXcd0HeGYjNtFRa3tckgP8PXPq/Xy+7tlwtC1BQrK9jkcFGBuVw9a6BEO63Ub7kPv4+XCLer9GVWKue2Zn9qctv6j7+eBixEVqfx+Jj7SAb5Ce2SMtH0t2APALLEB8jI3W9oQYKXwDCnSUUPMNzEdqkhVkMmON7fExUpialcPTu0j1/2sXHfHK63fRuGkOLCzLEBySg1cn3MX50y64F6f9+kSPGgfz6Km0adMmODg4YOPGjbC0tMSmTZs0Hg8PD4dEIsH169fRv39/SKVSjBo1Cv7+/oiPj8eWLVsgkUggkUgQFhamdw7jQgXKrbSvdldYm8C4qPbZgnkdHZE6xg+JM4KROs4PxgVl8F56B5a3NS+hdfwjBZIyAVmDG75AblU29goU5Bprbc/PMYaNXc1rbNjYl6EgR3fZysdVr5FnDEBS4371xezaZatmelTZVc8t0vzMrl22aiZmry6DopoMJnXIX93vbqJ6/FESc93bWMtQUKS9eHt+kTlsrOr3BdPYqBzTx5xCdp4Ffj/ZROvxEb1u4q8132PPys1477XT+HZ7Jxw807AbYIi67pm9xkzMXl0G8eZ/Mvt5E9jY1VwfNvZl1f7NKp/7UZPaylGQp70eeH6eGaQ2Na+PamNbioJ87bIFecrPDhu7yvISzJvWHonx1vh60yn8euxPrNhwCimJVlj44bMN/h2I9ME18+ipk5SUhMOHD2PSpElwcXHBCy+8gJ07dyI7OxsODppT7ocPH44JEyZg9uzZMDIygp2dHQYNGoRWrVohPDwcAODiUv36HY9ayiTNNSAKWtvD/9MbcN6VhHsfKdf8ME0tgePvyUh6qzEEU47fExER1dd7r51Gi0ap+PDb/igo0r7J1JHzgbgZ4wo7aQk6t0rAu6+eQXm5BHv/bmaAtERE9LC9O+camrTIwbdftcC9WCl8AgowZtJdzPnyH8yf0f6RXUb8bycAKOccMYPgYB49dTZv3gyFQoFx48YBAEJDQ7Ft2zZs374dU6dO1dj33XffxXvvvaexzdzcHM7OzujYsWODsyisjWGkYwaecWEZFDpm7NVGsDRGYUs72J5ULyrrui0BRU1tUdLIWvVaEoUAiaC8u61gYgTBTL8OuCDXGFIdZxtt7BXI13GW7sGyrt7aZ8sqz+BVno0syDWG1FYB5UeFpNr9mF0c2VXPLdL8zM7s+ijINYZUx+wEG/uyOuaX6yyrzFVz+YYSc93nF5lBaqWj7qxkyNcxIFedySPPYUi32/hyQw9cuOmtc5/cAkvVOnvnbvjAwrwMb7x0DvtPNYFCwc9YZmf2uhBz/iezny9Dfm7N9VF99sr6fLTZAaAg3xRSWx1/e1u5zll3GmXzTOHqXqy1XWqr/J3yc5Xl23dJRc/+SZjzVgdcueAMALhx2QkpiVZY8O05dOiWioi/a79xIdHDxCFUeups2rQJQUFB6NSpEwCgb9++8PT01LrUFgBGjBih9+usXbsW7dq1Q7t27aAo0L1YttzTEuaJ2mtRmCUXQ+75cNa2M0sqgfRaLhq/c1n1Y3s2CyY5pWj8zmU4/3pf7+eOj7SAXxPt/L7BJUi4U3P++EgLuPvIYW5ZrrHdN7gEcpkESXFmqv3MLNRrnVTdDwDi79T9CxmzGz672PMzO7Prlf+OBfx0rJnkG1SP/BYP5A+qzK9/rroQc93HJTkgwDNba7u/Zzbikuzr9BxjBl3CawOv4tufOuFQRN0vm42Mc4aVRSkcbbW/JNaVmOue2Zn9acsv6n7+jgX8grX7Kt/gEiTcrSX7HUvd2YOLH0t2AEiIsYFvoPaa4T4BBUiIrfkOswmxNnDzLIK5ueZgpm9AAUrlRki6bwUA8G+kfP47t+w09rtzw175Wv41r81H9ChwMI+eKhcuXMDNmzcxcuRI5OTkICcnB/n5+Rg5ciQiIiJw584djf09PPRfY27y5Mm4cOECLly4AGOptc59ClrbwyKmAKbp6rV7TDJksIwqRGFr+3q/plGxAtZXc1ESoH695CmBuDczWOOnsIUtyqQmuDczGDm9Xev9OpUiDtqiWdsiuPuq87t5y9G8fSEiDtrWXPaQLUzNBHQbkqPObyygx7AcXPzbBqVyZfd0/qgNSuUS9Bqp+YWsz4vZiL1lgdR7+h0kMLthsos9P7Mzu/75Cx/IL1PmP2RXQ8kq+YfWnP9REXPdn77sh5DANHg4q9eRdXfKR4tGqTh9pfY7u4/sfR0TR/yD/+1qh11Hm9frtVsFp6CoxBTZefqfmBNz3TM7sz9t+cXdz9vrzt6uABEHa8tuV1Hv6vo0MhbQY2j2Y8kOAGdPuKFp8xy4exaptrl6FCGkVTbOnnCrpawrTE0FdO2TrNpmZFyO7n2TcPGsM8pKlTMLszOV7aJJiObdfZu0yAEAZKQ/vBsMEtUVL7Olp0rl7LtFixZh0aJFWo//8MMP+OKLL1T/l0ge7doHud2dYX8kDZ7fRiFjhCcgkcB5VyJKHUyR00O9Fp9JhgwBH11D5lBPZA1T3jrd4UAKzFJKUNTUBmX2pjDNlMPhz1SY5JYiZVKAqmxJI+0zUmWnMmFmKkFx05oPjGqzf4sjho3PQPiGOGxa7A5BAEJnpiA9yQy//+ik2s/VS46NZ25hywo3bFmhnIIefd0Kx36zx9T5STAxFZCSYIYh4zLh7iPHorfVX7JyM02xc60zXnk7DcUFxoi6Zokew3LQqksBwsMCtDIx+787u9jzMzuz65ffCcPCMhD+fSw2LfZQ5p+VrDv/6ZvYssIdW1ZW5L9RkT88ESYmAlLumWHIuIyK/H4arxPUsghuPnIYGQkAlHdl7Do4BwBw/i9brbsN1i27eOt+34kmGNH7Jha8dQjrd7eDAOD14f8gLVuqsZadm2M+ti7cgU372uCHfW0BAL3bR+PtlyNw9po3Lt32REhgmmr/wmJTxCcr19gd2v0WQgLT8M8tL6RnW8PWugS92sWiZ7tYrPm1PcoU+l9iJua6Z3Zmf9ryi7qf3+qEYePTEf59NDYt9qyo94rsm52rZJdh46kb2LLSA1tWelTJ7oCp4fer1HtF9nc06zOoZaEye8XXK7+gEnQdnF2R3U6v7ABwYLcPhvwnDp8suYAf1wRDECQYMyUSGakW+GOX+m/v4l6E9b8ew7bvg7BtvXKmdcwdOxw/5IHJ027A2KQcqUlWGPRiPNw8i7FkXhtV2VPH3DF2aiSmz7uMn74Pwv14a3j7FeK1iXeRlmKBM8ee7ktsFU/peoGGxsE8emrI5XJs27YNHTp0wFdffaX1+LRp0/Djjz/i888/r/F5zM3NUVys/2UzVQnmxrj/QTBcfroH93WxkAhAUTNbpL3qA8FC8wuApByQCIL693G3gPRSNqSXcmBUrEC5hRGKG0uRGuaHksCap5Q/LLJiY8wa1QhTw5Mw85sESCTA5ZNSrP7UCyVF6vwSCWBsAkge+IxeNs0HYbOTETorBVJbBWJuWmLu6EBEXbPS2G/jVx4oLjTGCxPT4eBShvvR5lgwxQ9nD+s/GMnshsku9vzMzuz652+MqeGJmPlNvDr/vAfzCxX5BY3yy6b7VuRPVucfE4io65r5h41PR79R6tkR3YfmoHvFTI9xHZoh9X79Z5yIue5L5KaYtmwQ3hoVgTkTjkEiAS7e8sSq7R1RLFOvoySRAMbGAowk6np/rsV9GBkBHZ65jw7PaC5HcTnSHe8vHQIAiEl0RJfW8XjjP2dhYy1DboEFEpLt8eE3/RBxrfbZfzURc90zO7M/bfnF388HYWr4fcz8Oq4iuw1Wh3tXU+8PZJ/hh7BZSQidmaTMfssSc8c21s4elo5+o7J0Z+/YXK/sACArMcGctzpi0rSbmBF+BYCAKxecsXZFCEqK1cMdyvwCJBLN/Cs/b4VxUyMxbuodWEtLEXvXFp++/xyiI9WzEosLTTFjQheMnnQHL46NhqOTDFmZ5jh7whVb1wVrvA7R4yIRBEGofTci8du1axdGjhyJjRs3IjQ0VOvx1atX44033sCRI0dw/PhxzJ8/H6WlpTAx0eycR4wYgVOnTuH777+Hu7s7nJ2d4e/vX+Nrm/t7w33eOw/z13lsgidcMHQEIqJ/v0c8k/uRE/HhoGxwe0NH0Jv57+cNHYGI6kPMff2Do58iY+Kl//JHhnQ6ZStyZamGjvHINH7GCot3NzF0jEdm4cvGuHDh3/l9WNzvaKJ62LRpE2xsbPDSSy/pfPzVV1+FpaWlzhthVPXll1+iSZMmGDVqFNq3b4/w8PBHkJaIiIiIiIiISBvng9JTY/fu3TU+bmdnh6Ii9cKp1Q3SNW3aFCdOnHiIyYiIiIiIiIiI6oaDeUREREREREREVC8CJFDwgk+DYK0TERERERERERGJBAfziIiIiIiIiIiIRIKDeURERERERERERCLBNfOIiIiIiIiIiKjeyoUneY6YYOgA1XqSa52IiIiIiIiIiOiJwsE8IiIiIiIiIiIikeBgHhERERERERERkUhwzTwiIiIiIiIiIqoXAYDiiZ4jpjB0gGo9ybVORERERERERET0ROFgHhERERERERERkUhwMI+IiIiIiIiIiEgkOJhHREREREREREQkErwBBhERERERERER1YsACRSCxNAxnkqcmUdERERERERERCQSnJlH9BiYxxcheNIlQ8fQS/vL/97bcdfF+bZmho6gN2NHe0NH0JsiM8vQEfQnEfl5LqHc0An0ZuLnY+gIeiv1cDB0hAYxuRVn6Ah6M//9vKEj6E/C2QyGIjE2NnQEvQllZYaO8PQS8TGCmNs8AJTdu2/oCHoRhFJDR6AnlHh7IyIiIiIiIiIioqcMZ+YREREREREREVG9lXOOmEGw1omIiIiIiIiIiESCg3lEREREREREREQiwcE8IiIiIiIiIiIikeCaeUREREREREREVC+CACgEzhEzBNY6ERERERERERGRSHAwj4iIiIiIiIiISCQ4mEdERERERERERCQSHMwjIiIiIiIiIiISCd4Ag4iIiIiIiIiI6kmCckgMHeKpxJl5REREREREREREIsHBPCIiIiIiIiIiIpHgYB4REREREREREZFIcM08IiIiIiIiIiKqFwGAQuAcMUNgrRMREREREREREYkEB/OIiIiIiIiIiIhEgpfZEhmYi4ccU8Lvo223PEACXDppg9XzfJCeZFZrWVPzcoTOTELvEVmQ2ikQfcMK6xd64vpZG439Rk5KRavO+QhqWQQntzL8uNwdm5d7PpT8shTg3lIj5EUAggDYdgB8Z5bD3KPmconfSZC0Rvf5BImZgHbnygEAGb9JEDuv+vMOrQ8rYOqsX3Yx172zWwkmz7qLNh2zIJEAlyIcsXZxENJTLGrPbqbA2Ldj0XtwCqxtyhATKcWGlY1w/R8Hjf02/HEabl4lWuU/f+8ZnDnq0qD8Lp5yTAlPRNtu+cq6P2GD1fO86lH3yeg9MhtSWwWib1pi/QJPXD8r1dhv5OQ0tOpcoK77ZW7YvLyWhlmX7CJuN4+j3iUSAaPeSsOgMRlwdCnD/RhzbFnhjpP77RuU3dm1GJPeu4E27dMhkQCXzztj7dfNkZ5qVXt2MwXGTopEr/73YW1Tipi7dtjwf81w47KTxn62djKMf+sWOnRJhYVVGeKibLF5XRNcPOvaoOwA4OJUiKnjz6Nty2Rl3V/1wHcb2iE9Q1pr2fGvXURwo0wENcqErY0cS1Z1xqGjjTX2adk8BUs/O1jtc7z74UDcvqvf+9bZvQSTZ8egTedsZX9zxh5rv2qE9OS69DflGPtuHHoPTVP2N7etsWFZAK7/Y19tme4D0/DhstvISDHDuN4d9cpcSdnmk9C2e9U274n0xDq2+Vkp6jZ/wxLrF3hU3+bHZirbfLQ5tqxwa3CbV+cX53tWzP28s4ccU+bdQ9uuyn7+8klbrJ5fj35+RhJ6j8yEta0CMTessP5LL1w/90A/PzEVLTvnI7hlIRxdy7B5hQc2r3hY/bzY27w484v5+MDZQ4Ypn1a2eQGXT9li9XxfpCeZ1y37jET0HpEJa9syxNy0wvovfTTavFdACYaOS0WrTvlw95WhuNAYd65YY9MyL8Teqv1zvDZibjdE+uLMPHrkNm7cCIlEovoxNjaGl5cXRo0ahcjISNV+4eHhkEgk9X7+Y8eOQSKR4NixYw8x9eNhblGORTvuwqdRCZZM88eS9/zhFSDD4h13YG6pqLX89KXxGPhqJn5c5olPQxshK80EC7dEITCkSGO/ga9lwN65DGf+tH+o+RXFQOQkI5TEAgGflSPwi3LIEpTbFMU1l3UZKaDZDwqNnyZrFJCYCLDvIaj2s+umvV+zTQqY2Auwbi7oPZAn5ro3t1Dgy3WX4B1QhOUfh2DpnBB4+RXhq/UX65T9/fm3MWBkEn78vwCEv9MSWenm+Py7Kwhskq+174VTjpg25lmNn2sXGva7KOs+Cj6NZFjyvi+WvOunrPufo+pY9/cw8LVM/LjUA5+GBSIr1RQLt0QjsPmDdZ8Je6cynPnTrkF5tbOLtd08nnoPnZWCMdNTsHeDCz4eG4hbF60xd00c2vfO0z+7eRkWfnsG3n4FWP5Fayz7rA08fQrx5aozMLcoq7X8ex9dQf9h8di8rgnmf/AcsjPM8fmKCAQG5ar2MTFVYOG3Z/BshzR8/3/NsOCjdkhPs8S8JefwTJsMvbMDgLlZGRbPPwgfrzwsWdUFi7/pAi+PPCyZfxAW5qW1lh8+6DbMzBQ4e8G72n2iYhzx7ocDtX7i7tkhM9sSd6Kdqi1bY3YLBb7ccBXegUVYPqcJln7YBF5+xfhqw9W69TdfRGLAf5Lx47d+CH+zObLSzfD5/64jsGmBzv2tbcow+aNoZKXX/gWs1uyW5Vi0Ixo+jSvbvG9Fm4+uW5tfVtHml7jj09AAZKWZYuHWGAQ21/yAC52VgjEzUrF3gzM+HhOIWxetMHdtfIPaPCDy96zY+/mf7sCnUQmWTg/AkvcD4BlQgkXbI+uUfdrieAx4NQM/LPPEvPGNkZVmigWb72r18wNezYC9UylOP8x+XuxtXsT5xX18oMCibZHKNj8jAEumBcLTX4ZFP9W1zcdiwCvp+GGZF+a9Hqxs8z9GamRv2z0XrTrl49Cvzpg3IQirPvaDnVMpVu6+icYtChuWX8Tt5kmhgNET+/Nvxpl59Nj8/PPP8Pb2hkKhQHR0ND7//HP06dMHN27cgJ2dHSZOnIgBAwYYOuZjNXB0Btx9ZZjYIwRJccoZDjG3LLHhxA0MHpOBnf9zq7ZsYLMi9B6RjWXT/XBwh/JL2tUIG6w9chPjPkhG+OuNVPtO7h0CQZDAyFjAkHEN+1JaVfpOCWSJwDO7y2Hhq9xmFVyOq8OMkP6LBO5jhWrLmrkpf6rK2CeBUCaB89By1TZTR+VPVfkXgbIcCTynlkNfYq77AS8mwd27GJOHdUTyPeXZzNi7UqzbG4FB/0nErh99qy0bEJyPXoNTseKTpjj0m/JM7rUL9li96xzGvBWLz95tqbF/XrYpIq8+vC9JADBwdCbcfeWY2L0ZkuKUZ3xjbllgw8lbGDw2EzvXVj8LKjCkGL1HZmPZNB913Z+RYu3R2xj3QQrCxweq9p3cq2mVus98SNnF224eR73bOZXixSlp2PFfV/yyRvl8V07bwNNfhtc/SsL5I7Z6Ze8/PAHunoWY8kpvJCdaAwBio2zxv+1HMPCFeOz+qVG1ZQMa56JX/0SsWNAKh39XvjeuXXbCd5uPYczESHw2+zkAQLfeyQhonI8P3+qEa5eUZwn+iXDFqh+OY/xbtzB9Yje9sgPAwOfvwt21ABPeHY6kFGUdxMY7YMOq3Rjc7y5+3RtSY/kRY1+FIEjg6Z6H53vF6NynqNhMa+adq0sBfL1y8eveEJSX63dAOuA/KXD3LsHkwe2RnGCpzB5pjXV/nMegUcnYtan6AcaAJgXoNSQdK+YG49AudwDAtfP2WL3nAsa8HYfP3m6hVeb1GTGIvS1FVroZ2nTK1itzpYGvZcLdT46J3Zqq2/xNC2w4dRuDx2Zh59rqZyoq23yOss1vV34IXT0jxdpjkRg3MwXhYQEAKtr81HRlm19d2eal8PSX4/U5yXq3eUDc71kx9/MDXktX9vM9myM5XtnPx962xPfHr2Pw6AzsXFd9Px/QrAi9R2Rh2Qw/HPpZ2Y9cjbDB2sM3MG5GEsInqGfUTulbpZ8f+5D6ebG3eRHnF/PxwYBXK9p8r2eqtHkrfH/sKgaPTsfOde7Vlg1oVoTeL2Rh2Qf+OPSzizr7oesYNz0R4RODAADH9zhi7yZXAOqJG5dP22DTqat44fVULJ0eqOvp60TM7YaoIf7dQ430RGndujU6duyILl26YNy4cfjuu++QmJiI06dPAwC8vb3RsWPDLqcRm47P5+L2RWvVhz4ApN4zx40LUnTqn1tDSaBjv1yUyiU4vkd9aWS5Qvn/Z3vkwdRMPdAlCPWf8VgXOcclkD4D1UAeAJh7ATatgZxj9X/NzL0SmDgJsOtc834ZeyWQmApwGlj9YGFtxFz3HXpmIPKqnWogDwBSEy1x87IdOvaq+cCuY88MlJZK8Pef6oPKcoURjh9wxbOdM2Fiqv8AaV117FdZ9+pLN1LvmePGeWt06qdn3f9mj2d75D/yuhdzu3kc9d6uZz7MzAX8tVNzBP7Irw4IDCmBm49Mr+wduqYi8oaDaiAPAFKTrXDzmgM6dkuptWxpqQQnDqsvQypXGOHvw15o2yEdJqbKs/ZNmmejpMRINZCnJMGlcy5oEpIDJ+daphvXoFO7e7h911k1kAcAKWk2uHHbFZ3a36u1vL7toW/3GBgZAYeOVj/YWZsOvTMRecVWNZAHVPQ3l+zQsXfNgycde2Uq+5s/1F+kyhUSHP/DBc92zdbqb0La5KLX0DT83xeNH3wqvXTsl4fbF610t/la3695FW3eXjN7dW3+V81lCo7sbFibV2YQ73tW9P38JWvVoIYq+wUpOvbLqbFsp+eV2f/eq67PcoUEx/Y6om33x9HPi73Nize/qI8Pns/B7UtSHW3eBh2fz6mxbKfnc2po87mq7HnZpqg6kAcARfkmSIyxgJO7vGH5RdxuiBqCg3lkMLa2yi81paXKS4x0XWabl5eHt99+G56enjA3N0eTJk2wYsUKCELNgziCIGDFihVo0qQJzMzM4OHhgbfffht5eZrToNPT0/Hqq6/C1tYWDg4OGD9+PPbs2aNx2e4777wDNzc3Vc5K+fn5sLGxwYcffqh3HfgFFyMu0lJre3ykBXyDtNcq0yxbgpR7ZpCVaL6N4yMtYWYuwNP/0X+oFEcDlo21/xYWgQKKdU8eqZYsBcg7DzgNEiCpYc5weQmQfUgC++6ASQMmjIm57n0bFSIuylpre3y0NXwDa75UwbdRIVITLSErMdbYnhBlDVMzAZ6+mpdzdOiRgZ1nj+G3C0exfPMFdOqV3uD8fsEliIvUXmsr/o4FfIP1rPs7Fo+l7sXcbh5HvfsFl0BeIkFSrJnWfpWP65U9IB/xMTZa2xNibeDrr/tyzUq+gflITbKCTKbZscTH2sDUrBye3so2X14ugaJM+7CotFS5za+R9mXodeXnk4O4BHut7fH37ODrnaP389amb89o3I12RNw9h9p3roZv40LERWmvZxQfZQXfRkU6SlQtW4TU+xbV9zd+6gFSY5NyvDP/Ln7d4K0xcNgQfk1KEHdbR5uPrEObb1LR5osffL9Wtnm5aj+dbT6yss3r/74W9XtWzP18UDHidfXzdyxr7ed9g4uRasjsYm/zIs4v6uOD6tr8XQv4BtV8Iss3qBip98y1+vn4OxXZ/arPLrUrg3+TYtyLalifL+Z2Q9QQHMyjx0ahUKCsrAwymQy3bt3CnDlz4Orqip49e+rcv7y8HIMHD8aGDRswY8YM7N27FwMGDMD06dMxd+7cGl9r7ty5mD59Op5//nns3bsXs2bNwsaNGzF48GCUl6vPbo0cORJ//PEHvvzyS/z0008wNTXFO++8o/Fcb7zxBtLS0rBr1y6N7Vu3bkVhYSGmTJmiX4UAsLFXoCDXWGt7fo4JbOxqXgfKxr6smrLGqud+1BS5gLGOWeUmdkBZPZePyPxdApRL4Dy05oHa7KMSKAokcBrasBlkYq57G7tSFORpj3gW5JpAaltL9mrK5ueaVjyuLn/2uDO++yoYn7zRGos/ag65zAiffH0NvQbXPBOq1vz2ChTkVFf3NdddTX+3yscfJVG3m8dQ7zb2ChTkGePBs+8N/ftIbeUoyNdeQy0/zwxSm5rXnLOxlaMg31Rre0GeqepxAEhMkMJaWgYfP81Bu6Ytsiv2q31tu2ozSOXIL9SRv8AcNtKGzUioTrPgdHh75uPQMf1n5QHKPqEgV0f95ZpAWkudVN/fmKieu9JLE+7B1KwcO9ZWv0xAfVXfbo3r0ObLqnm/GKseV72GzjavuZ8+xPyeFXs/n6/j9QtyjOvUz1e2b82yym3SBrSHungi2rxI84v9+EB3m69b9ureL0DNbf7Nz+IBCbBrffWXINeFmNsNUUNwzTx6bJo2barxf09PT+zbt081Q+9B+/fvx8mTJ7FhwwaEhYUBAPr164fCwkIsW7YM06dPh7Oz9t0PsrKysGzZMoSGhmLVqlUAgP79+8PFxQVjx47Fvn37MGzYMBw8eBAnT57E9u3bMWrUKNV+w4YNQ0JCgur5QkJC0KNHD6xZs0a1HwCsWbMG/fr1Q0BAQIPqhZQy90lg1VSAVXDN+2XslcDEUYB918eT62m2+ivNP8aZv1ywfPMFhL0XjaO/V79+CpEYHTvohdETIjHtk8v4emErZGeaY8DwBLRolQUAKH/0V6A/VM/3jEZpqRGOnPj3f0Z5+Bbj5Sn38MW7ISiV8zwzEdGT7uU3k9D7hSwsn+mvcXkviY8ACcof0ZJOVDMeMdFjs2vXLpw/fx7nzp3D7t27ERISgkGDBuHWrVs69//7779hZGSE1157TWP7mDFjIJfLcebMGZ3lIiIiIJfLMWbMGI3tr7zyCkxMTHD8+HHVfsbGxhgxYoTGfv/5z3+0nvPNN9/E0aNHcffuXQDA+fPncenSpRpn5a1duxbt2rVDu3btUArdU68Lco0h1XHGqLozu3Urq9yWr+Ms08NmbAsodMzAK8sFTOqxDmzBNaAkVgKnWmblydOBvLOA08CaL8Wt02uKuO4L8nTPwJPalemcBaNZ1lRnWRs75Qybmn738nIJTh5yhYu7DA7O+l9OUJBrDKmOs8zVnd3VKlvN3w14DHUv5nbzGOq9INcYUlsFAKHG/eqrIN8UUhvtGWzVzbrTKFvN7L3KWWX5ecoZc4UFplgwpx3s7OT4v83Hse2Pg3h+SAK2fK8c1M7K1P/LRkGhGWysdeSXypBf0PC7tj7I1ESB7p3jcO6iF/LyG/YlqSDXBFI7HfVnV6aa3Vht2Wr7m4r2UPGemTonClfO2uP2FVtY25TB2qYMpqblgER5d1szc/1mpdT0nqtTm9f5fql8v5qo99PZ5jX304eo37Mi7+d1zeaR2ivq0M/rnslUOTupoAHtoS6eiDYv0vxiPz7Q3ebrlr269wugu80PGp2G8bMTsXGJFw7uqP7mFHUl5nZD1BAczKPHpkWLFmjXrh3at2+P4cOHY8+ePRAEAeHh4Tr3z8rKgqOjI8zMNL/ouLu7qx6vrhwAeHh4aGw3MTGBk5OT6vHk5GQ4ODjA1FTzy4ibm/ZU7xEjRsDd3R1r1qwBAKxevRqenp4YOnRotb/v5MmTceHCBVy4cAGmMNe5T/wdC/gFa69F4RtcgoS7NX8Bi79jCXcfOcwtNKeL+AYXQy6TaCwC+6hYNgKKo7XPxJTESGBZj5tSZe6VQGJS+w0tMn+XAIraL8WtCzHXfUK0Nfwaaa+N5xtYiIQY7bX0qoqPtoabVzHMLTQPXHwbFaJULkFSgvbaWDo14E+grHvtNUx8g0qQcKeWuo+00F33QSWPpe7F3G4eR73H37GAmYV6jRnVfhWvG1/L61QnIdYGvgHaa9b5+BcgIU5aa1k3zyKYm2t+wfYNyEep3AhJ99Vt/sYVJ0x4qTcmjeqFKa/2xOSXe0NRZoSSEiNE3dZ/kc74e/bw88nR2u7rnYuE+/Z6P291Ora/B1sbeYMvsQWAhCgr+OlYG8+3URESomvuL+KjrODmXVJ9fxNvqXqu53pk4eezp1U/PYekw9lNjp/PnkbYtDi9ssdHWsCviY42H1yPNm/54Pu1ss2bqfaruc3r/74W83tW3P28pc5+3i+ouA79vAXcdGT3e1zZxd7mRZxf1McHd6tp841LkHC35vXs4u9Yws1HptXP+wVVZI/XzN5nRAbe/iIev6x1w0+rPPEwiLndEDUEB/PIYCwtLREYGIirV6/qfNzR0RFZWVmQyzU7zZSUFNXj1ZWrul+lsrIyZGZmqh738PBAdna21o0tUlNTtZ7T1NQUEydOxMaNG5GWloaffvoJEyZMgIlJw87CRBy0R7O2hXD3Vc9ycvOWoXm7AkQcrPmLY8QhO5iaCeg2JFu1zchYQI+h2bj4t81juVTJvoegnFV3X71NlggUXFE+VhflpUDmnxLYdQVMdf9JVTL3SWAZLMCqac371YWY6z7imAuatsyDu5f6wMvVsxghrXMRcUz70vOqzh53hqmpgK790lTbjIzL0a1/Gi6ecURZafXZK/dLSzJHdqb+By0RB2111337QkQcqq3ubZV1PzSnSi4BPYblPJ66F3O7eQz1fv6oDUrlEvQaka1Rvs/IbMTeskDqPf3azdkT7mjaPAfunupBbFf3IoS0zMLZkzVf8n32lJuyzfdOrpK9HN37JOHiOReUlT541l6CpPtS3I+3gbmFAv2HxePoAW/ISvTv78+c90az4Ay4u6kHJN1cCtC8aRrOnPfW+3mr83zPaOTkmuPsPw1/7oijTmjaKg/u3lX7mxKEtMlDxFGnGsuePeakrPv+6hvnGBkL6DYgHRdPOaj6m69mNMPs0JYaPxdOOCA3yxSzQ1ti71b9vvAp23zRA21ermzzB2uePq5q80NyNLJX2+ZHPtDmX2xYm1fnF+d7VtT9/GE7NG2jnT2kXQEiDtnXWPbsYXud/Xz3Idm4eML2MfXzYm/z4swv6uODQ/Zo2qYA7j7qATFVmz9sX2PZs39VtPnBD7T5oVlabb5z/2xMXxqLAz+5YN2Ch7c+qpjbDVFDcD4oGUxRURGio6PRvHlznY/36NEDS5Yswc8//4zRo0ertm/ZsgVmZmbo1KmTznIdO3aEmZkZfvrpJ/Tp00e1ffv27SgrK1PdcKNjx45QKBTYtWuXxlp4P//8s87nnTJlChYuXIiXXnoJMpkMkyZNqu+vrGX/VicMG5+O8O+jsWmxJwQBCJ2ZjPQkM/y+WT0o4+olw8ZTN7BlpQe2rFTOOIy+YYVjvzlgavh9mJgKSEkww5BxGXD3kWPRO5prJAW1LISbjxxGFZPo/IJK0LXiQ/f8X3Zad8+qK5cXBaRtlyDqfSN4vaW8JCrx/4xg5ga4/Ec9mCdLAq4ONYLnZAFeUzQH+XL+BhS5EjgNrfkyqsJbQHGUBD4zHs7CVWKu+wO/emLoK/fx6TdX8cO3gRAAjH0rFump5vjjZ/WXXlePYqz/PQJb1/hj2xplrpjbNjj+hysmz7oLExMBKYkWGDwqEe5eJVjykfq92GNgCjr2zMD5k07ISLGAvZMcQ165j6CQfHw1S/d7tq72b3HCsLAMhH8fi02LPZR1P6ui7n9UDw64esmx8fRNbFnhji0rlQM2yrq3x9TwRGX+e1Xq/m0/jdcJalmkrHsjZZvzC5ah6+AcAMD5v2z1qnsxt5vHUe+5mabYudYFr7ydiuJCI0Rds0SPYTlo1aUA4eP1X7vtwB5fDPlPLD5ZdB4/rm0KQQDGTIpERqol/titfn0X9yKs33EE2zYEY9sG5eWxMXfscPywJya/dwPGJuVITbLCoJHxcPMowpLwNhqvEzr1FqIi7ZCXYwYP70K8+Fo0FGVG2PhdM72zA8Afh4MwbGAk5s8+io3bWkMQJAh99TLSM63x+yH12pSuLgXY9N9d2PxzS2z5uZVq+zMhKbC3lcHBQTmgFtwoEyXFylnlJyI02729bTHatU7Cvj+bQKFo+BfAA794YOjoJHy66gZ++MYfgiDB2HfikJ5ijj92qGfAu3qWYP2Bc9j6nR+2fafMFHNLiuP7XTD5wxh1f/NyMty9S7BklvqsTORV7S9bfV9IRalcgmvn7fXOvn+LI4aNz0D4hjhsWuxe8X5N0d3mz9zClhVu2LKios1fr2jz85OqvF8zK9q8+kuoss0745W301BcYKzZ5sMatl6hmN+zYu7n/9jqjGGh6Zi3LgqblngBAMbNSEJ6shn2b9Hs5zecuI4tX3tg69ee6ux7HDBl3j1V9sFj0+HuI8Pi93T0895ySCqy+waVoOugin7+iL79vNjbvHjzi/n44I9tLhgWmqZs80u9AAEYNyOxos2rL4N19ZJhw99XseVrT2z9xqsiuzWO7XHElHkJyuz3zDF4TBrcvWVY/J76Mp0Wz+Xjw2+iEXPLCod+cULTNuo70ZfKJYi+UfOVJTURc7t5Uiie8jli9+7dw7Rp03Do0CEIgoC+ffti5cqV8PWtfdA6ISEBn3zyCY4ePYr09HT4+Phg1KhR+Oijj2BtXfP7goN59NhcvnwZGRkZEAQBycnJWLVqFbKysrTuHltp4MCB6Nq1K6ZOnYr09HQ0b94c+/fvx7p16/DRRx/pvPkFoJyZN2PGDHz55ZewtrZWrcv38ccfo2vXrhg8eDAA5c00unTpgsmTJyMjIwONGzfGL7/8gitXrgAAjIw0OyUvLy8MGzYMu3btwtChQ+Hj49PgOpEVG2PWqCBMDb+PmV/HQSIBLp+0wepwb5QUqWeLSCSAsQlUB3yVls3wQ9isJITOTILUVoGYW5aYO7Yxoq5rXvo0LCwd/UapL0vuPjQH3SvOeI/r2Byp9/U7m2RsCTRZW457S40Q87ERIAC2zwG+M8thXDWCAEAhAcq1Z+tl7jWCsZ0A++41v1bGnopLcQc1/BJbQNx1Lys2xkcT22DyrLv4YOFNQAJcOeuANYuDUFJcpVuXAMYmgupLTqUVnzZD6DsxGPt2DKQ2ZYi9I8Unb7RC9C0b1T4piZawd5JjwvQo2NiWoaTYGHdv2uDjqa1w8XTNs3Hqkn/WqMaYGp6Imd/EV9S9FKvneT1Q94Luup/ui7DZyQidlays+5uWmDsmULvux6ej3yj1GVSNuu/QTO+6F3O7eRz1vnGRB4qLjPDChHQ4uJThfrQ5Fkz1x9nD+l+mKisxwZx3OmHSuzcw49NLAARc+ccZa1e20GjzEijb/IPZV37RGuOm3sa4yZGwlpYiNsoWn07vgOg79hr72TvKMPm9G7BzkCE32xxnjrtj87omOu+kWx8lMlPMCn8eU8dfwKx3T0EiEXD5mge++749SkrUSz1IABgbCzCSaOYf9/IVtGqhnjU+fGAkhg+MBAD0e3Gcxr69u8fCxER4KJfYAhX9zfiWmDw7Bh98FansbyLssebLRhrtBlC2ea3+Zm4wQt+Lw9j34pT9TaQUn0x+RqO/eVSUbb4RpoYnYeY3Ceo2/+mDbb7y/apZftk0n4o2n6Ju86MDEXXtgTb/lQeKC43xwsQqbX6KH84ersfisdXmF+l7VuT9/OxXgjHl03uYuTJWmf2UDdbM99HZbh44XMTyGf4Im5WIcR8kqvr5j8cFaWcPTcfzL2Wqsw/JRveKmVmhnVs0oJ8Xe5sXZ36xHx/MfrWJss2viKlo87ZY85lv3dr8BwEIm3Uf42bcr8huhY9DgxF1XT0Q0bpzHswsBAQ9U4QVO29rlE+9Z4bQrq2gLzG3GxK/oqIi9O7dG+bm5ti0aRMkEgk+/vhj9OrVC1evXq1xQK6wsBB9+/ZFaWkpPv/8c/j6+uL8+fOYN28e7t69i+3bt9f42hJBEB7ON2OiamzcuBHjx4/X2Obi4oIWLVpg9uzZ6N+/PwAgPDwc8+fPR9UmmZeXhzlz5uDXX39FZmYm/P398cYbb+D999+HRKI8JXXs2DH06tULR48eVc26EwQBK1euxOrVqxEbGwsnJyeMHDkSX375pcbdc9PT0/HOO+/g999/h7GxMYYNG4Y+ffogLCwMly9fRqtWmh8s27Ztw2uvvYZ9+/apBgXrwlbiiA7G/epVb/8W7S9qL9ouJufbPvzF5R8XY0d7Q0fQmyJT95qWovDgUZ7YCCK77WoVJn4NP0liKKUeDoaO0CAmt+IMHUFvipxcQ0fQn4R3ADQUifGjv1HYoyKUad9kgx4TI/G2GzG3eQAQSsX5neSs8BfyBBEfF9fCt4UtZvzynKFjPDI/jsnBhQsXqn3866+/xvTp0xEZGYnGjRsDAGJjYxEUFITFixdj+vTp1ZY9ePAg+vfvjz///BP9+qnHCj788EMsXboUeXl5sLKqfn1iDuYRPeDtt9/Ghg0bkJWVBXNzzbNbo0ePxqlTpxATE6M1c68mHMwzHA7mGQYH8wyIg3kGwcE8w+FgHulDzAMbHMwzIA7mGQwH8/6dnvbBvD59+qCkpASnTp3S2N6jRw8AwPHjx6stu2/fPgwdOhRnzpxBx44dVdu/+uorzJkzB/n5+TXO7ONltvRU27hxI3Jzc9G8eXPI5XIcOHAA3333HWbOnKkxkBcREYHLly9j+/btWL58eb0G8oiIiIiIiIjoyXLjxg0MHz5ca3vz5s2rXYu/Ut++fREUFITZs2fju+++g6+vL86dO4evv/4aU6dO5Zp5RDWxtrbGypUrER0dDZlMhoCAACxcuBAzZ87U2K9Tp06QSqUIDQ3Fm2++aaC0RERERERERP8OAoBy4emd6JKVlQUHB+2rMxwdHZGdna2jhJqFhQVOnjyJF198UeOmoBMnTsSqVatqfW0O5tFT7aWXXsJLL71U6368Gp2IiIiIiIjo6ZGeno527dqp/j958mRMnjz5oTx3SUkJXn75ZaSlpeHHH39Uzcz77LPPYGJigu+++67G8hzMIyIiIiIiIiIiqsLFxaXGNfMcHBx0zsCrbsZeVevXr8exY8cQFRWFRo0aAQC6d+8OOzs7TJ48GVOnTtW6IWdVT+98SCIiIiIiIiIiIj00b94cN27c0Np+8+ZNhISE1Fj22rVrcHBwUA3kVXruOeUNRW7dulVjeQ7mERERERERERFRPUmgeIJ/ajNs2DBEREQgJiZGtS0uLg6nTp3CsGHDaizr7u6O7OxsREVFaWw/e/YsAMDLy6vG8hzMIyIiIiIiIiIiqodJkybB398fw4cPx2+//YY9e/Zg+PDh8PHxwZQpU1T7xcfHw8TEBJ999plqW1hYGGxsbDBo0CBs2rQJR48exZIlS/DBBx/g2WefRZcuXWp8bQ7mERERERERERER1YO1tTWOHDmC4OBgjB07FqNHj0ZAQACOHDkCqVSq2k8QBCgUCpSXl6u2+fv7IyIiAq1bt8bHH3+MQYMG4X//+x8mT56MQ4cOwcio5uE63gCDiIiIiIiIiIionnx9ffHrr7/WuI+/vz8EQdDaHhISgh07duj1uhzMIyIiIiIiIiKiehEAlAu84NMQWOtEREREREREREQiwcE8IiIiIiIiIiIikeBgHhERERERERERkUhwMI+IiIiIiIiIiEgkeAMMIiIiIiIiIiKqNwUkho7wVOLMPCIiIiIiIiIiIpHgzDyix6VcYegEejnf2tjQERokeml7Q0fQW6MPIgwdQX8S8Z6hk7RtZugIDSJcvGXoCHorS0g0dAS9GSWnGjpCgyhkMkNH0JvERLyHs0JZmaEjPLVY96QPYwc7Q0fQmyI719ARGkasx5aCoQPQk4oz84iIiIiIiIiIiERCvKcyiYiIiIiIiIjIIARBgnKBc8QMgbVOREREREREREQkEhzMIyIiIiIiIiIiEgkO5hEREREREREREYkE18wjIiIiIiIiIqJ6U3DNPINgrRMREREREREREYkEB/OIiIiIiIiIiIhEgoN5REREREREREREIsHBPCIiIiIiIiIiIpHgDTCIiIiIiIiIiKheBADlkBg6xlOJM/OIiIiIiIiIiIhEgoN5REREREREREREIsHBPCIiIiIiIiIiIpHgmnlERERERERERFRPEigEzhEzBNY6ERERERERERGRSHBmHpGBuXjKMSU8CW275wMS4NIJG6ye54n0RLNay5qalyN0Vgp6j8yG1FaB6BuWWL/AA9fPSjX2k0gEjHorDYPGZsLRpQz3o82xZYUbTu63f6rze1gVYG7b0+jingiJRMCpFC988U9nJBfZ1Ot5poRcwszW53AhzR2vHB6u2j4yIBKLOx2rtlzHnWORUWKlV3Yx17s6fyLadqua3wvpSXXMPzNZnf+mJdYv8Kw+/5gMZf4Yc2xZ4d7g/M7OhZgy4R+0bZ0CSARcvuKB1f97FukZ1rWWDRt7GUGNMxHUKAu2tnIsW9kRh4400tpv8YJDaPlMmtb21euexe49TfXO7uIhx5Tw+2jbLU9Z7ydtsHqeTz3qPQm9R2RBaqdA9A0rrF/oietnNd8vIyelolXnfAS1LIKTWxl+XO6Ozcs99c78JGQHAGcPGaZ8koC2XfKU7eaUHVZ/7ov0JPPa85uVI3TGffR+IRPWtmWIuWmF9Yt8cP2crWofr4BiDB2bhlad8uDuI0NxoTHuXLXGpuXeiL2lXz9TScz9jbOHHFPm3UPbrsp2c/mkLVbPr0e7mZGE3iMzYW2rQMwNK6z/0gvXzz3QbiamomXnfAS3LISjaxk2r/DA5hUPp92Iue6ZndmftvzObiWYPCsKbTplQSIBLkU4YO2iIKSnWNSe3UyBsW/HoveQVFjblCEmUooNKxrh+j+amTYcOAM3rxKt8p+/1wJnjrjonV3sn7GP47hy5OQ0tOpcoM6/zA2bl3s8lPxE+uDMPNLLxo0bIZFIVD/Gxsbw8vLCqFGjEBkZ+UheUyKRIDw8/JE8t6GYW5Zj0Y5o+DSWYcn7vljyri+8AmRY/HM0zC0VtZafvuweBr6WiR+XuOPT0ABkpZli4dYYBDYv1tgvdFYKxsxIxd4Nzvh4TCBuXbTC3LXxaN8776nNb2Fcih/77EWgbQ5mRvTEB6d7w98mD1v67IOlcWmdn8fHOg9vNr+IjGJLrceOJfniP3++oPHz0sHhyCqxwJVMF70H8sRc7wBgblGORTui4NOoMr9fRf6ouuVfWpF/qQc+DQtEVqopFm6JRmDzIu3801Owd4MLPh4biFsXrTF3TVyD8publWHRF3/BxzsPS1d2wpIVneHpkYdFCw7D3Lys1vLDBkfC3EyBsxe8at03JtYe78/sr/Fz/G8//bNblGPRjrvwaVSCJdP8seQ9f2W977hTx3qPx8BXM/HjMk98GtoIWWkmWLglCoEhmvU+8LUM2DuX4cyf9npnfZKyK/MrsGjLbfgElmDpB4FYMqMRPP1LsGjr7Trln7YoFgNeSccPK7wwb0IwstLMsGBTJAKbFar2adstD6065eHQr86YNzEYqz7xg51jKVbuvIHGLQprePZasou4vzG3KMein+7Ap1EJlk4PwJL3A+AZUIJF2yPrVu+L4zHg1Qz8sMwT88Y3RlaaKRZsvqvVbga8mgF7p1KcftjtRsx1z+zM/pTlN7dQ4Mv1l+EdUITlHzfD0jnN4OVXjK++v1Sn7O9/FokBLybjx/8GIPztZ5CVbobPV19BYJN8rX0vnHTEtNFtNX6uXbBvQHaxf8Y+nuPKga9lwt6pDGf+tHuo+Yn0xZl51CA///wzvL29oVAoEB0djc8//xx9+vTBjRs3YGf3cDu6M2fOwNvb+6E+p6ENfC0T7n5yTOzWFElxytkZMTctsOHUbQwem4Wda6s/wxYYUozeI3OwbJoPDm53BABcPSPF2mORGDczBeFhAQAAO6dSvDg1HTv+64pfVrsCAK6clsLTX47X5yTj/BHbal/jSc7/cuPb8LHOR799LyO+QNlWb+c44vDQn/Bq0C18f7tlnZ7ns+dOYE9cEAJtc2AsETQey5JZIkumOcjXziUZjhYl+Obas3rlBsRd7wAwcHQm3H3lmNi9mTr/LQtsOHkLg8dmYuda11ryZyvz73BS5z96G+M+SEH4+EB1/ilpyvxrKvPbwNNfhtc/StI7/4D+UXB3K8DEN4ciOVl5xjk2zgHfr96DwQPuYudvzWos/+KroyAIEnh45OP53rE17ltcbIrbkc565dRl4OgMuPvKMLFHCJLilLMEYm5ZYsOJGxg8JgM7/+dWbdnAZkXoPSIby6b7qes9wgZrj9zEuA+SEf66enbh5N4hEAQJjIwFDBmX8dRnB4ABr6Qr8/dpieR4Zf7YW1b4/ugVDH4tDTvXV39mP6BZEXq/kIllMwNw6Bfle/vqWVusPXgN46YnInxSMADg+F5H7P3BFYBEVfbyGVtsOnEFL4xPwdIZ2jNA60LM/c2A1yrqvWdzdb3ftsT3x69j8OgM7FxXfbsJaFaE3iOysGyGHw79rHwfXo2wwdrDNzBuRhLCJzRW7Tulb5V2M/bhtRsx1z2zM/vTln/Ai0lw9y7G5KEdkHxPebI29o4U6/adxaCXErHrB99qywYEF6DX4FSs+KQpDu1Wfh5cu2CP1bvOYcxbsfjsXc1j0rwcU0RefXjfs8T+Gfs4jisBYHKvplXyZz60/GInACgXJLXuRw8fZ+ZRg7Ru3RodO3ZEly5dMG7cOHz33XdITEzE6dOnH/prdezY8YkbzOvYLw+3L1qpPngAIPWeOW6ct0an/rm1li2VS3B8j71qW7lCguO/2ePZHvkwNSsHALTrmQ8zcwF//eqgUf7ITgcEhpTAzUf2VObv4xWHy5muqoE8ALhfaIuL6e7o6xVXp+cY6ncXzR0ysPTKc3V+3ZEBdyBXGGFvfOPad66GmOtdmSEXty9a687fr7b8uRX51blqzL/TUTP/rw3L3/G5+7h9x0k1kAcAqalS3Ljlgo4d7tdaXjDgwU7H5yvrXX25T+o9c9y4IK1Du6mm3vc44Nkeeap6Bx7N7yjm7ADQsW8Obl+SqgaUACD1vjlu/GODjs/n1Fi2U99slMol+Hufui2XKyQ4ttcRbbvlqvLnZZui6kAeABTlmyAx1gJObnWfbayVXcT9Tcfnc3H7krVmvVe0m479cmos2+l5Zbv5e6+Oeu/+mNqNmOue2Zn9KcvfoWcGIq/aqgbyACA10RI3L9uiY6+aB6469spAaakEfx9QDzqVK4xw/IAbnu2SBRPT8hpKN5zoP2Mfw3ElYNhjOCJdOJhHD5WtrfJsVmmp8otDWFgY/P39tfbr2bMnevbsqfp/QUEB3nnnHfj6+sLc3Byurq7o27cvbt++rdrnwctsw8PDIZFIcPfuXQwePBhSqRR+fn747LPPUF6u+aGXnp6OqVOnwsvLC+bm5mjatCnWrl2rsU9KSgpCQ0Ph6ekJc3NzeHh4YMiQIUhLU65bVVZWhk8++QSNGjWChYUFnJ2d0bVrV5w8eVLv+vJrUoK429rraMRHWsA3WHs9jAfLptwzg6xY820cH2kBM3MBnv5y1X7yEgmSYs209gMAv2D9D7rEnD/ILht3chy1tt/NdUBju+xay9uayjC37RksutwBufLa10IBAHPjMgz0jcGRRL86l9FFzPWuLFuCuEgd+e/UIX9wRf6SB/LfqcwvU+2nM/8dC9XjemX3zUV8vL129gQ7+PrUfMBYX40Cs/Drth3Yt3Mrvvvmd/R/PqpBz+cXXIy4SO3LweMjLeAbpGe9R1pq1PujIubsygzFiL+jI/8dS/g2LtZRQs03qBip980hKzHWLHu3Ir9f9b+/1K4M/sHFuBf9dPY3fkHFiNfVbu5Y1tpufIOLkVqHvuZREnXdMzuzP2X5fRsXIS5KqrU9PsoavoFFOkpUKduoEKn3LbT6+YRoa5iaCfD01fyc6NAjAzvPHcdv/xzD8s3/oFPvdL0yVxL/Z+yjP64k+jfiZbbUIAqFAmVlZVAoFIiJicGcOXPg6uqqMVBXF9OmTcOePXuwcOFCBAUFITMzE6dOnUJOTk6tZUeMGIHx48dj2rRp2Lt3L+bNmwcfHx+MHz8eAJCXl4euXbuiuLgY4eHhCAgIwJ9//ok33ngDMpkM77zzDgBg7NixiI+Px5IlS+Dj44PU1FT89ddfKCpSfgAvWrQIK1aswIIFC9C6dWvk5eXhwoULyMrKqtfvWpWNvQIFucZa2/NzjGFjV/MaDzb2ZSjI0V228nHVa+QZ48EZGw/upw8x57czkyFPrr3wfI7cHLZmtX9wf9gmArH5dvg1pkmdX/N57zjYmMmxKza4XlkfJOZ6Vz23zgwmdchf3e9uonpctZ/O/Jr71ZeNVI78Au3FlAvyzWAjlev1nLpcu+GKI8cDkJhoA2upHH17xWLaO2fh6FCMbTue0es5a6o7G7ua/5429mXVtrnK536UxJwdAGzsypCfq33IVZBbt/z5OvIXVLRlaQ353wyPByTAru/d65m46uuLt7+xsVdUU3fGdax3HX8zVb3r3wfWldjrntmrz8Ts1WUQb34bu1IU5OnoM/JMIbWtpb+xK0VBnqnW9so+yMZOPbv67HEn3Llui9REC9g7yTH01UR88vV1LPmoGY7u06+vF/1n7GM4riT6N+JgHjVI06aad1X09PTEvn37VDP06urMmTMYPXo0JkyYoNo2YsSIOpWdMWOGauCub9++OHLkCLZt26ba9vXXXyM+Ph7Xrl1DUFCQar+cnBzMnz8fb7zxBkxMTHDmzBksXLgQo0ePVj33Sy+9pJGxX79+eO+991Tbhg4dWq/fk54M7VyS8ULAHQw/8CIePBisyciASGQUW+JYUvXrphABwI9bW2n8P+KsDz756DheeekGdu1pipIS7YN+oqpefiMJvV/IxPJZARqXmRIRkXit/lLzhPCZv1ywfMs/CHsvRu/BPCISJ15mSw2ya9cunD9/HufOncPu3bsREhKCQYMG4datW/V6nvbt22Pjxo1YuHAhLly4AIWi7mdBBg8erPH/Fi1aICEhQfX/AwcOoEOHDggICEBZWZnqp3///sjMzMTNmzdVGZYsWYKvv/4a165dgyBo3sygffv22L9/P+bOnYuTJ09CLq95Fs7atWvRrl07tGvXDqXQPdOrINcYUh1njKqbTaBVVsfZosozSJVnlApyjSG1VUC5PGn1++lDzPnzqpmBZ1/NjL2qvnjub/wc0xQpRdawMZXBxlQGY4kAY6Ny2JjKYGak/Xu5WBSis3si9sY3hkJoWNcr5nqvOYPuGUhaZXX+7mUVuYzV++nMr7lffRUU6p6BJ7XRPWPvYTr2tz/MzRUI8MvRq3xNdadrBlLdyla2B/3qs67EnB0ACvJ0zwSTVjNjT6Nsru6ZBZUzw3TNRhj0WhrGz7qPjUu9cfDn6heMrwsx9zcFubpn80jtFXWsdx1/M1W9P/rz4WKve2avPhOz15BBpPkL8kx0zsCT2uqesadZ1hRSW+21TSv7oPzc6k/glZdLcPKgC1zcZXBw1u+SUNF/xj6G40qqmQJGT+zPv9m/Ox3967Vo0QLt2rVD+/btMXz4cOzZsweCIGisbVcX3377LaZMmYLvv/8e7du3h6urK6ZNm6a6xLUmjo6a656Zm5ujpES9PkJaWhr+/vtvmJqaavxUzrrLzFTejWj79u0YNmwYFi9ejJYtW8LLy0tj/b05c+Zg/vz52LNnD7p16wYnJyeMHz8eGRm6F7WdPHkyLly4gAsXLsAUugeH4iMt4NdEey0H3+ASJNypeSZFfKQF3H3kMLfUXB/QN7gEcpkESXFmqv3MLNRrhVTdDwDi79Q8cFVbBrHmv5vrgCAda+M1tstGVK6DjhJV98nB6KCbuPTSRtVPO9cUtHFOw6WXNuK1oBtaZYYH3IWJkYCdMQ27xBYQd70ry1roXLPON6ge+S0eyB9Umd9c9Ro159dvplJ8gh38fLXXxvPzyUXCvYd7B+/qCPWYDVqVst6112fzDS5Bwt1a6v2Ope56Dy7WqPdHRczZKzP4BWnn9wsqRkKU9jpFD5Z185bB3ELzy4Zf44r8D8y66zMiA29/Hodf/ueOn/7r2fDsIu5v4u9Y6mw3fkHFdWg3FnDT0W78HuhrHiVR1z2zM/tTlj8hyhp+jQq1szcqQkKMlY4SVbJHW8HNu0Srn/cNLESpXIKkhJo/J1SE2nfR+fqi/4x99MeVRP9GHMyjh8rS0hKBgYG4evUqAMDCwkLnDLbKAbRKUqkUX375JaKiohAXF4c5c+Zg1apVmD9/foMzOTk5oXPnzjh//rzOn3bt2gEAXF1d8d///heJiYm4ffs2wsLCMG/ePKxZswYAYGpqitmzZ+PatWtITk7GihUr8Ouvv+Ktt97SO1vEQVs0a1sEd1/1mTQ3bzmaty9ExMGaL1WOOGQLUzMB3YbkqLYZGQvoMSwHF/+2Qalc+fY+f9QGpXIJeo3UHLjq82I2Ym9ZIPWe/h9SYs7/V6IfWjunwsc6T7XNyzofbV1S8VeiX41lRx8eqvVzM9sJkTmOGH14KA4kBGqVGRFwF7eyHXErx1mvvFWJud7V+QsfyC9T5j9U84CYKv/QOuYf8UD+kQ3LH3HOG02bZMDdLV+d3bUAIc3SEXHu0d5tu3fPOJTIjBEbZ69X+YiD9rrrvV0BIg7WVu92Fe1GXZ9GxgJ6DM3WqPdHRczZASDisAOatimAu4/6y4ablwwhzxYg4rB9jWXP/mWvzD9IvT6rkbGA7kOycPGknUb+zv2yMH1xDA5sd8G6hQ/ncn4x9zcRh+3QtI12uwlpV4CIQ/Y1lj172F5nu+k+JBsXT9g+nnYj5rpndmZ/yvJHHHNG05Z5cPdWD4q5ehYjpHUuIo7WfOx39pgzTE0FdO2XViV7OboNSMPF044oK62+v6ncLy3JHNmZ+rYbkX/GPobjSqJ/I66ZRw9VUVERoqOj0bx5cwCAn58fUlNTkZ6eDhcX5aU+0dHRiIyMROfOnXU+h5+fH2bMmIEtW7bg+vXrDc40YMAAfPvtt/D19YWrq2vtBQA0adIECxcuxOrVq3VmcHd3x8SJE7F///4GZdy/xRHDxmcgfEMcNi12hyAAoTNTkJ5kht9/dFLt5+olx8Yzt7BlhRu2rFCuhxF93QrHfrPH1PlJMDEVkJJghiHjMuHuI8eit9Vf4nIzTbFzrTNeeTsNxQXGiLpmiR7DctCqSwHCwwL0zi72/NujmmFs8A2s7vEnVlxpDwHA+y3PI7nIGtuiQlT7eVrl48iwbVh1/Vmsuv4sAOBsmvZsl3y5GYwlgs7Hmjuko4l9FhZe7KR33qrEXO/K/E4YFpaB8O9jsWmxhzL/rGTd+U/fxJYV7tiysiL/jYr84YkwMRGQcs8MQ8ZlVORXD8Iq87vglbdTUVxopJl/vP75//izMYYNjsS8ucexaUsrQJBg3OgrSM+wxv4DjdXZXQqwYe0ebPnpGWzdrr5hxTPNU2FnJ4ODg/JgPygoC8UV69+dPK2s/+YhaXj5xRs4FeGD1FQprK3l6Ns7Fp063Mf6ja0hk+n30b1/qxOGjU9H+PfR2LTYs6LdVNT7ZvUXDVcvGTaeuoEtKz2wZaUHgMp6d8DU8PtV2k1Fvb+jWZ9BLQvh5iOHUcUEQr+gEnQdrDzIP/+XndYd45707ADwx08uGDYuFfPW3sWm5d6AAIybfh/pyWbYv1X9ueTqJcOGY1ew5RsvbP3WS5n/pjWO7XXElE8TlPnvmWPwmDS4+8iw+P1GqrItnsvDh99EI+aWFQ794oymrQtUj5XKJYi+aa1XdjH3N39sdcaw0HTMWxeFTUuU9TluRpKy3rdotpsNJ65jy9ce2Pq1sg+PvmGFY3scMGXePVVfM3hsurLe39PRbrzlkBgpp8X4BpWg66CKdnNE/3Yj5rpndmZ/2vIf+NUTQ19NxKffXMMP3wZAECQY+3YM0lPN8cfP6mNDV48SrN8fga1r/LBttfL1Ym7b4Pgfrpg8O0rZ3yRaYPCoJLh7lWDJh+pj0h4DU9GxVwbOn3BCRoo57J3kGPJKIoJCCvDVzBCtTHUl9s/Yx3FcqcxfpMxf0df7BcvQdXBORX5bvfMT6YuDedQgly9fRkZGBgRBQHJyMlatWoWsrCzVHWJfeuklfPLJJxgzZgymT5+OjIwMfPnll3B21jxD1alTJwwbNgzPPPMMpFIpjh8/jitXriA0NLTBGadNm4bt27ejW7dumDZtGpo0aYLCwkLcvn0bJ06cwG+//Ybc3Fz07dsXo0ePRtOmTWFqaorffvsN2dnZ6NevHwBg+PDhaNWqFdq2bQsHBwdcunQJBw4cwJQpU/TOJis2xqxRjTA1PAkzv0mARAJcPinF6k+9UFKkXqNBIgGMTQDJA58Ry6b5IGx2MkJnpUBqq0DMTUvMHR2IqGua0/k3fuWB4kJjvDAxHQ4uZbgfbY4FU/xw9nD9blTyJOUvVphizF9DMLftGSztfAQAcCbFC19c7IyiMvXaJBIJYGIkwEii57ULAEYE3kFpuRF+i2tc+851IOZ6V+dvjKnhiZj5Tbw6/7wH8wsV+TXrftl034r8yer8YwIRdf2B/Is8UFxkhBcmVMk/1R9nD+t/OaxMZoLZc/tiysR/MHPaaUgAXL7qjjXrntW4KYVEAhgbC6oDvkpjX7uKls+oz7wPG3wHwwbfAQAMGKa8+U5WtiUkRgLGvnYVtrYyKMqMEBtnj6+WdsGxv/31z15sjFmjgjA1/D5mfh1XUe82WB3uXU27eaDeZ/ghbFYSQmcmKev9liXmjm2sVe/DwtLRb5R6Fln3oTnoXnHGe1zH5ki9X/+ZA2LOXpl/9uimmPJxAmYui1bmP22LNZ/5aeaHMv+D7Wb5zECEfXAP42YkQmpbhphbVvg4tAmibqgH6Fp3yoOZuYCgZ4qw4lfNdWtT75shtFtrvbOLtb+RFRtj9ivBmPLpPcxcGavMfsoGa+b76Mxu9ED25TP8ETYrEeM+SFS1m4/HBWm3m9B0PP+S+oqD7kOy0b1ilkpo5xYNajdirntmZ/anKb+s2BgfTWiNybOi8MHCW4AEuHLWAWsWNUZJcZWv3BIBxiaCakCr0opPmiL03RiMfScWUpsyxEZa45OpLRF9y0a1T0qiBewd5ZgwIwo2tmUoKTbG3Zs2+HhKS1w87QR9PQmfsY/juHLY+HT0G6WegaiRv0MzvfOLnQAJygX9loChhpEID67yT1QHGzduVN0ttpKLiwtatGiB2bNno3///qrtu3fvxscff4zo6GgEBwdjyZIlWLhwIQDg2LFjAIDZs2fj4MGDiImJQVlZGQIDAzFp0iS8++67queRSCSYN2+eaj2+8PBwzJ8/H6WlpTAxUX9IhoWF4dixY4iLi1Nty87OxmeffYbdu3cjMTER9vb2aNKkCV588UW8//77kMlkePfdd3Hy5EnEx8fDyMgITZo0wbRp0/Daa68BAJYtW4aff/4Zd+/eRVFREXx9ffHqq69i7ty5MDWt+c6SthJHdJD0qXc9U8NFL+1o6Ah6a/RBhKEj6E8i3g91ybPNDR2hQYSL9bsBET0cElNxnx8VZPotnP5vIDERb90LZdoL5hPRv5exk2PtO/1LKbK11/wVFaG89n3+hc6WH0aekFX7jiLl3twR47Y+ud9zj0yIxYULFwwdQycO5hE9BhzMMxwO5hkIB/MMhoN5hsHBPMPhYB4RPS4czDMgDub9K3Ewz3B4YTcREREREREREZFIcDCPiIiIiIiIiIhIJMR7XQIRERERERERERlMOeeIGQRrnYiIiIiIiIiISCQ4mEdERERERERERCQSHMwjIiIiIiIiIiISCa6ZR0RERERERERE9SIIgEKQGDrGU4kz84iIiIiIiIiIiESCg3lEREREREREREQiwcE8IiIiIiIiIiIikeCaeUREREREREREVG/lXDPPIDgzj4iIiIiIiIiISCQ4mEdERERERERERCQSHMwjIiIiIiIiIiISCQ7mERERERERERERiQRvgEFERERERERERPUiQIJygXPEDIGDeURUI+PGAYaO0CCNZp41dAS9jbqVYugIetvRzN3QEfQmXLhu6AgNIxHvHcWMgwINHUFvijvRho7QIBJTM0NH0J9QbugEejNq0dTQERpEiIwxdAS9CQqFoSPor1zE2QGYeIj3GKEsWbzHZkT0ZOEQKhERERERERERkUhwMI+IiIiIiIiIiEgkeJktERERERERERHVmwLiXeJFzDgzj4iIiIiIiIiISCQ4mEdERERERERERCQSHMwjIiIiIiIiIiISCa6ZR0RERERERERE9SIAKBe4Zp4hcGYeERERERERERGRSHAwj4iIiIiIiIiISCQ4mEdERERERERERCQSHMwjIiIiIiIiIiISCd4Ag4iIiIiIiIiI6kmCcoFzxAyBtU5ERERERERERCQSHMwjIiIiIiIiIiISCQ7mERERERERERERiQTXzCMiIiIiIiIionorh8TQEZ5KHMwjMjAXTzmmhCehbfd8QAJcOmGD1fM8kZ5oVmtZU/NyhM5KQe+R2ZDaKhB9wxLrF3jg+lmpxn4SiYBRb6Vh0NhMOLqU4X60ObascMPJ/fYNzu/sWoTJb19Hm3ZpkEiAS/+4YO03zyA9zarWsqGTbiKoaTYaB+fA1q4Uyxe2weEDfjr37T8kDiNfjoK7RxFSU6ywe0cj7N8T0KDsyrpPRNtuVeveC+lJdaz7mcnqur9pifULPKuv+zEZyrqPMceWFe4NrvuiZCNc/soWqafNIAiAWyc5Wn+UB2vP8lrLFiYZ4fo3Nkg/ZwZZlhEs3RXwGVCCZpMLYWIlAACK04xwd7MVUk+boyDBGEYmgF2TUjR/swAu7UsblB0Qd7sXf/ZH2+ZHTk5Dq84FCGpZBCe3Mvy4zA2bl3s0KDcAOLsUYfLbV9Hm2cq+xhVrV7WsW18z8TqCmuRU9DVyLP/qWZ19TZ/+8ejYORlBTbLh6l6MQwd8seKrdg3ODoi73Th7yDDl03to2zUPkAi4fMoWq+f7Ij3JvG7ZZySi94hMWNuWIeamFdZ/6YPr52xU+3gFlGDouFS06pQPd18ZiguNceeKNTYt80Lsrdr/vjVnl2PKvMrswOWTtlg936fubX5GEnqPzIS1rQIxN6yw/ksvjewAMHJiKlp2zkdwy0I4upZh8woPbF7h2aDcqvwuRZgy9RLatE2FBAIuXXLDmu/aID3dutayoeOvIjg4C42DsmFrK8eyJc/h8CHtz81pM86iabNMODsVQ2IEJCdZ488Dgdi3tzHKy/W/iEfM7cbFQ44p4ffRtpuy3Vw6aYPV8+rRbmYmofeILEjtFIi+YYX1Cz1x/ewD7WZSKlp1zlf3lcvdsXl5w9uNmPsaAHB2K8ak6ZFo0zETEgi4fM4Ja5c1RXqKZe35zRQY+0YUeg1KgrW0DDF3bLDhm2DcuOSo2qfv0ERMC79e7XOM6dcT2Zm1t1FdxFz3Ys7+JOQn0gcvsyUyIHPLcizaEQ2fxjIsed8XS971hVeADIt/joa5paLW8tOX3cPA1zLx4xJ3fBoagKw0UyzcGoPA5sUa+4XOSsGYGanYu8EZH48JxK2LVpi7Nh7te+c1LL95Gb5ceQrevvlYvrAtli54Fl7ehfjq65MwtyirtfzQF2NgZlaOc2fca9yv/5A4vPPBZZw67olPZnbCyWOeeHP6FQwaHqt/dotyLNoRBZ9GlXXvV1H3UXWr+6UVdb/UA5+GBSIr1RQLt0QjsHmRxn6hs1IwZnoK9m5wwcdjA3HrojXmrolrUN2XFQPHwhyRF2OM577MRYdFuSiIN8axMEeUFdV8ZqysSILjrzsi44IpWrybj25rshH4n2Lc2WiN83NtVftl3zDFvT8s4Nm7BJ1W5KD9wlwYmwk4GuqIpKP6HeRWEnO7F3X2x9TmB76WCXunMpz5007vrFrZzcvw5YoT8PYtwPKv2mHpwnbw8i7AVytO1K2vGRkDM3NFrX1N7+fvwd2rEJf+cUVhwcM73ynudqPAom2R8GlUgqUzArBkWiA8/WVY9FNknbJPWxyLAa+k44dlXpj3ejCy0kyx4MdIBIao203b7rlo1Skfh351xrwJQVj1sR/snEqxcvdNNG5R2IDs5Vj00x1l9ukBWPJ+ADwDSrBoe12zx2PAqxn4YZkn5o1vrMy++a5GdgAY8GoG7J1KcfpPe72z6sxvXoavFh+Ft08eli15DksWd4SnVwEWLTlap3Y/bPhdmJkpcO5szQNE5uYK7PktCAu+6IwvPuuCS5fcMOWNS5g05bL+2cXebnbchU+jEiyZ5o8l7/kr36877tSxr4zHwFcz8eMyT3wa2ghZaSZYuCVKq90MfC0D9s5lOPMQ242Y+xpA2W4Wrr4Ab/9CLJ/XAss+bQlP3yJ8ueZ8ndr8e5/eQP8R97F5dWPMf78tsjPM8fmqfxAYrM517oQLpod20PiZEdYBuTmmiLxuq/dAnpjrXszZn4T8RPrizDzScObMGaxYsQInT55ERkYGbGxs0LZtW4wZMwZjxozBjz/+iPHjx+Pu3bto3LixoeMiLCwMx44dQ1xcXJ3LhIeHo3v37ujdu/ejC1ZHA1/LhLufHBO7NUVSnPLgIeamBTacuo3BY7Owc61LtWUDQ4rRe2QOlk3zwcHtyjOOV89IsfZYJMbNTEF4mPLsu51TKV6cmo4d/3XFL6tdAQBXTkvh6S/H63OScf6IbbWvUZsBQ+Ph7lGIyWP6IjlRefYqNtoW67YcxqBhcdi1o+Y28tLAwRAECTy8CtB3wD2d+xgZlyN00k0cOeiDH9aFKH/PSy5wdCrB2Am38Oc+PygU9T8vMXB0Jtx95ZjYvZm67m9ZYMPJWxg8NhM717pWW1ZZ99nKut/hpMx0Roq1R29j3AcpCB8fCKCi7qekKet+TWXd28DTX4bXP0rSu+5jfrZC4X1jDNifARs/5UGKXZMy/DHAGdE7LNEkrKjashmXTFEQb4Lu67Lg3kUOAHDtIIc8V4LIDdYoK86FiSXg/KwcA//IgFGVTwn3rjL8OdQZt9dbw7OXTK/sgLjbvaizP4Y2DwCTezWFIEhgZCxgyLhMvbI+aMCQOGVfM65flb7GDuu2HMSgobHY9XNQjeVfGjy0Sl+TUO1+H8/sAkFQDog/+1zqQ8kOiLvdDHg1He6+Mkzs9QyS4y0AALG3rfD9sasYPDodO9dVP0Aa0KwIvV/IwrIP/HHoZ+XveDXCBmsPXce46YkIn6j8ux3f44i9m1yBKpfpXD5tg02nruKF11OxdHqgrqevPftrFdl7Nq+S3RLfH7+OwaMzsHOdW83ZR2Rh2Qw/HPrZWZ398A2Mm5GE8Anqz7cpfUPUbX5shl5ZdeYfGAN390JMmjAQyUnKWV2xsXZYv2E/Bg2Oxq5fm9RY/j8jRirbvWc++j4fV+1+Xy3srPH/i/+4w8mpBP36x2LNd231yy7idjNwdIYye48QJMUps8fcssSGEzcweEwGdv6v+nYT2KwIvUdkY9l0P3VfGWGDtUduYtwHyQh/vZFq38m9q7SbcQ+n3Yi5rwGA/iPuw92rCFNGdkXyfeXs09i7Uvxv10kMfPE+dm/xr7ZsQFAeeg1MxorwFji81wsAcO2iA77bcQpjpkbhs+nKtpyXY4a8HM3ZWs1bZ8POvhRbVuv/3UbMdS/m7E9CfiJ9cWYeqaxcuRJdunRBVlYWFi1ahMOHD+P7779HcHAw3njjDezbt8/QEbV88skn2LVrV73KzJ8/H0eOHHlEieqnY7883L5opfrgAYDUe+a4cd4anfrn1lq2VC7B8T32qm3lCgmO/2aPZ3vkw9RMebllu575MDMX8NevDhrlj+x0QGBICdx89B+U6dAlGZE3HVVfrgEgNdkaN687omPX5FrLV35prkmz5lmwd5Dj6EEfje1HDvrAzl6O5i31Gyzo2C8Xty9a6677frXVfW5F3avrtMa63+moUf7Irw2r+6Sj5nBsVaoayAMAqbcCzm1KkfSXRY1ly+XKOje1FjS2m9oKEMoBVPxNzGwFjYE8ADAyAeyblqI4rWEfHWJu9+LO/ujbPFC393V9deiso69JscbNa07o2OXh9DX12a++RN1uns/B7UtS1YCMKvsFG3R8PqfGsp2ez0GpXIK/96r7wHKFBMf2OqJt91xV9rxsU+CB9XaK8k2QGGMBJ3e5XrmV2XNx+5K1juxSdOxXW/bcGrLnPfI2DwAdOyXi9m1H1UAeAKSmSHHzhjM6dUqstXxDcuXlmUGh0L+86NvNRWvVQJ46u7QO79dq+so9Dni2x6NvN2LuawCgQ/c0RF6zVw3kAUBqkhVuXrFHxx5pNZftkY7SUglOHFIPFJcrjPD3QQ+07ZQBE9PqlyHpMzRR+bv/WfPs7ZqIue7FnP1JyC92ggAoBMkT+/NvxsE8AgD8/fffmD59Ot5++20cPnwYY8eORffu3TF8+HD897//xbVr1xAQ0LD1yR6FRo0aoU2bNo/s+WWyR9sx+zUpQdxt7cGX+EgL+AaX1Fo25Z4ZZMWab+P4SAuYmQvw9Jer9pOXSJAUa6a1HwD4Bev/O/r65yMuVvtMVHysLXz98/V+3qr8Kp7nwdeJr/i/vq/jF1yCuEgddX+nDnUfXFH3JQ/U/Z3Kupep9tNZ93csVI/rIy/KBHZB2peb2DYuQ150zROu3TrLIPUrw9VlNsiNMkZpoQSpEWa4+4MVGr1crFozTxeFHMi8YgbbwNovdamJmNu9qLM/hjb/qPgG5Onua+Js4Ov/77+8RdTtJqgY8ZHaa1XF37WAb1CxjhJqvkHFSL1nDlmJsWbZO5bK7H7VZ5LalcG/STHuRdW+TlZ1qs1+xxK+QTXXu29wMVIN2OYBwNcvD/Fx2perx8fbwtf3Ybd7AUZG5bC2lqNL13vo+3wcdu2seeZfTUTdboKLEacre6RFre2m2r4y0vKxtBsx9zUA4BdYgPhoqdb2hBgpfAMLaizrG1iA1ERL7XYTI4WpmQBPH91XLZiZK9C1byrOnXBBQV7t66tVm13EdS/m7E9CfiJ9cTCPAACLFi2Co6MjFi9erPPxRo0aoWXLlqr/Z2RkYPTo0bC1tYWnpyfeffddlJRodpZFRUWYPXs2AgICYGZmhoCAACxYsADl5eozY8eOHYNEIsHu3bsxZcoUODo6wt7eHu+//z4UCgXOnz+Prl27wtraGs2bN8eff/6p8RphYWHw9/dX/b+srAyffPIJGjVqBAsLCzg7O6Nr1644efIkAEAiUY6uL1iwABKJBBKJBOHh4arn8vb2xpkzZ9C5c2dYWlpi1qxZGDp0qM4Bw9jYWBgZGWH16tV1r+gH2NgrUJBrrLU9P8cYNnY1r/FgY1+GghzdZSsfV71GnjEePHv94H76sLGVoyDfVGt7Qb4ppNKG3yQBAKS2ctVzVpVf8X8bG/3OvtvYK6qpP5M61H11fzcT1eOq/XTWveZ+9SXPNYKZrfYZZjO7csjzaj6DZGwO9N6SBUEA/hzqgl3t3HB8vCM8esrQ9pOavxze+K8URSlGaDpR/7WIAHG3e9Fnf8Rt/lGxsZGjoED7S1ZBvhmkNg+nr3mUxN5u8nVkL8gxgY1dzc9pY19WTVnlNmkNmd78LB6QALvWV39JY22qz25cx+zaJ0cKKtp8TdkfFhsbOQrytdt9fr45pHp+9lXnuQ7J+P3Az/hl1y7M+fg09vwWhG1bmuv9fGJvN9X1d3XJXt17vfK5HyUx9zUAILUr1XlcmZ9rCqlNLXVfTdmC3IrjRVvdnxWdeqbBWlqGv/Z56ZG4yuuLuO7FnF313CLOT6QvrplHUCgUOHr0KF544QVYWNR8iV6lsWPH4tVXX8XOnTtx5swZhIeHw8HBAfPnzwegHFTr378/bt68iU8++QTPPPMMIiIi8PnnnyMrKwvLli3TeL73338fI0eOxPbt2/H333/jiy++gEKhwOHDhzFz5kx4eXnhiy++wMiRIxEfHw9nZ2eduRYtWoQVK1ZgwYIFaN26NfLy8nDhwgVkZWUBUK4J2KlTJ4SFhWHKlCkAAG9vb1X53NxcvPLKK/jggw+wcOFCWFpaIjMzE4MHD8a5c+fw3HPPqfZdu3YtrK2tMXr06LpXNpGBKWTAmel2kGUaocOiHFh5KJB5zRQ3/08KI2Pg2XDdA3rx+yxw+3/WCHmjEC7t/v2DJ0QkXi+/mYTeL2Rh+Ux/jcs06dG5fs0Z7771PKytS9GqTSpe/E8kIACbNrasvfC/BNsN6aPPkERkZ5rh/Cnd3y2IiP6tOJhHyMjIQHFxMfz8/Opc5rXXXlMN3PXt2xdnz57Ftm3bVNu2bduGkydP4vjx4+jevTsAoE+fPgCUa9bNnj0brq7qxdZ79+6N5cuXAwCef/55/P7771i1ahVOnDiBrl27AgA8PDzQqlUr/P777wgNDdWZ68yZM+jXrx/ee+891bahQ4eq/t2xY0cAgJeXl+rfVRUUFGDz5s0YPny4alt5eTkCAwOxZs0a1WBeaWkpNmzYgNGjR8PGxkbreQDlYN/atWuV+0P31OuCXGNIdZwxqu6M9oNlXb21B1Uqz/pWzpgpyDWG1FYBQEDVs0kP7qeP6mbFSG1KUVCgfXZU39eofM7sTHWd2FS8br6OWQt1et5cY0h1nCGvbkbAg2VdvbVnRVSelas8S1d93WvuV1+mtuWQ52lPrFbO2Kv+MlkAiPnFCunnzDHoz3RIfZW/v0v7UphKBfwzzw6NXimCfVPNs4tJR81xfo4dAl4sRot3ar7MpS7E3O5Fn/0Rt/lHpSDfDFKp9utLbXTPDv63EXu70TWzQVrNzLUHy7p56fi7VWQq0JFp0Og0jJ+diI1LvHBwR/WLltdF9dkVdchuAjcv7cvyKmeF6cr+sBUUmOqcgWdjI9M5Y68hiorMcPeuco26y5fdUFZmhFdfu4l9exsjM9Oq3s8n9naj+/1at+y6+8rK9+Ej7itF3NcAQEGeqc7jSuWsu1rqPs8Uru7al3BL7SqOF/O0PyscnGVo/VwW9m73RbkeN1PTeH0R172Ys6ueW8T5ifTFy2xJL4MHD9b4/zPPPIOEBPUdAg8cOAA/Pz907twZZWVlqp9+/fqhtLQUERERGuUHDhyo8f+mTZvC2tpaNZBXuQ0A7t3TfddTAGjfvj3279+PuXPn4uTJk5DL63cZiqmpKYYMGaKxzcjICFOmTMFPP/2E3FzlIqq7d+9GamqqanafLpMnT8aFCxdw4cIFmEL3be7jIy3g10R7LQff4BIk3Kn5rHJ8pAXcfeQwt9S83NI3uARymQRJcWaq/cws1Gs+VN0PAOLv6M5WFwlxNvDTsV6Vr38eEuJ0D3Lq8xoAtF6ncp0sfV8n/o6FzjXrfIPqUfcWD9R9UGXdm6teo+a612/mgF3jMuRFaR805EWbwLZRzdP8c++awMyuXDWQV8mpZanqOapKPWOG0+/bw6tPCdrNfzhrNIm53Ys6+2No849KQpwt/AK018f09c9HQty//w5yom43dy3hF6z9BdmvcQkS7ta8Lln8HUu4+chgbqHZ3/gFFSuzx2tm6jMiA29/EY9f1rrhp1WeeuV98PV1Zg8qRsLdWur9jgXcdLR5v8fU5gEgPt4Ofn46PmN985CQ8Gjb/d07jjA2FuDurt+yCuJuNxY6s/sGl9Sh3Vjq7iuDix9LuxFzXwNUrI3XSPukoU9AARJitNfS0yxrDTevYq124xtQgFK5BEn3tAelew1MgrGJgL/2PYR2I+K6F3P2JyH/k6BcMHpif/7N/t3p6LFwcnKCpaUl4uPj61zG0VHz7pzm5uYaN4tIS0tDfHw8TE1NNX4qZ7ZlZmregdTBQfPOQGZmZrC3t9faBkBrbb6q5syZg/nz52PPnj3o1q0bnJycMH78eGRkZNTp93JxcYGxsfYZnAkTJkChUODHH38EAKxevRrPPfdcg2++EXHQFs3aFsHdV113bt5yNG9fiIiDNR+oRxyyhamZgG5DclTbjIwF9BiWg4t/26BUrnx7nz9qg1K5BL1GZmuU7/NiNmJvWSD1nv4fPhGn3NE0JBvuHuqDfVf3QoQ8k4WIU/rfEayqW9cdkZtjhl7P39fY3rvffeTlmuLmNSe9nldZ94UP1L1MWfeHtBcc1yhbWfdDc1Tbaqz7EQ/U/ciG1b1nLxkyr5ii4J66rRYmGiPjkik8e9e80K+FcznkuUbIj9ds55lXlWesLd3UB8EZl0xx6m17uHWUocPiXEge0ieGmNu9+LM/2jb/qESc9kDTkCztvqZFJiJOezzS134YRN1uDtmjaZsCuPuo+xY3bxlC2hUg4rB9jWXP/mWvzD5YncnIWED3oVm4eMJWo9107p+N6UtjceAnF6xb4KtXVq3sh+3QtI12mw9pV4CIQ7VkP1yRfcgD2Ydka2V/VM6e8UTTZplwd1cPbri6FSKkeQYizjR88KEmz7RMQ3k5kJxc8wBKdUTdbg7a6+4r2xUg4mBtfaWdznbTY2j24+krRdzXAMDZ4y5o2iIX7lVmxbp6FCOkdQ7O/u1aQ0ng7N+uMDUV0LVvSpX85ejeLwUXI5xRVqpd932GJCHmjhQxdxo+OC7muhdz9ichP5G+OB+UYGJigp49e+LQoUOQyWQwN294Z+Tk5ISAgADs2LFD5+NVb1rxMJmammL27NmYPXs2UlJSsG/fPkyfPh1FRUXYvn17reUrb5DxICcnJ4waNQpr1qxB//79cfToUaxbt67BefdvccSw8RkI3xCHTYvdIQhA6MwUpCeZ4fcf1YNUrl5ybDxzC1tWuGHLCuUgWfR1Kxz7zR5T5yfBxFRASoIZhozLhLuPHIveVh/Q5maaYudaZ7zydhqKC4wRdc0SPYbloFWXAoSHNewOxQf2+mPoiFh8+uVZ/LCuGQQBGDvhFtLTLPHHHvVzu7oVYf22Q9i6qQm2bWqq2t6iVQbs7GVwcFJ++AY1zUFxsbJbOnVcuRCxQmGEH9c1w5vTryAzwwKXLrigVdsMPD8oHqu/bomyMv0OjPdvccKwsAyEfx+LTYs9lHU/K1l33Z++iS0r3LFlZUXd36io+/BEmJgISLlnhiHjMirqXn25urLuXfDK26koLjTSrPvx+td94EvFiNpqhVNv2aPFewWABLj+jRRW7goEjlLPJihMNML+/i4IeaMAzd9SDoIEjCjGnY1WODHFASFTC2DlUY6s6ya4+Z0UDs1L4dy2YoZejDFOvuEAM3sBTSYUIfuG5uUpTq31XzdPzO1e3NkffZsHgKCWRXDzkcPISHnJt1+wDF0H5wAAzv9lq3WXx7o4sM8fQ0dE49MFZ/DD+hBlX/N6RV+z94G+Zuuf2LqpKbb90Ey1vUWrdNjZy+HgqBxYCGqSrdXXAICPX57qDtlmZuVwdStClx6JAIBrl52Rl6vf56OY280f21wwLDQN89ZFYdNSL0AAxs1IRHqyGfZvUV/O6Oolw4a/r2LL157Y+o2yTqNvWOPYHkdMmZegzH7PHIPHpMHdW4bF7wWqyrZ4Lh8ffhONmFtWOPSLE5q2UQ9elcoliL5hrV/2rc4YFpquzL5EmWncjKSK7Or1sVy9ZNhw4jq2fO2BrV97VmS3wrE9Dpgy756qzQ8emw53HxkWv6dZn0EtC+HmLYekos37BpWg6yDlF77zR+z0avMA8McfjTB0WBQ+nX8SP2x8BoIAjAu9hvR0K+z/vZE6v2shvt/0O7Zubo6tVW5a8cwzacrPWIeKdh+chZISZbs/ecIHAND+uST06x+LsxGeSEuzgqVlGdq3T8aAQTH44/dGyMrS766wYm43+7c6Ydj4dIR/H41Niz0r3q8VfeVmzXaz8dQNbFnpgS0rPSqyW+HYbw6YGn6/yvu1oq98R0e78ZHDqOLQ0y+oBF0rBjDP/6VfuxFzXwMAB3Z5Y8jLCfhk+SX8+H9BEARgzBt3kZFigT9+Va9x7eJejPW/ncC2dYHY9r/GAICYSFsc/9Mdk2fchrGJgNRESwz6zz24eRZjycfaaz82apoH/8YF+N9y/e/aXJWY617M2Z+E/ET64mAeAQA+/PBD9OzZE7NmzcLXX3+t9XhsbCzy87UvcarOgAED8Ouvv0Iqlaouj33c3N3dMXHiROzfvx/Xr19XbTczM0NxsfblE7V588030alTJ0ycOBF2dnZ45ZVXGpxRVmyMWaMaYWp4EmZ+kwCJBLh8UorVn3qhpEg9c0oiAYxNoDUzatk0H4TNTkborBRIbRWIuWmJuaMDEXVN81KCjV95oLjQGC9MTIeDSxnuR5tjwRQ/nD3csDORshITfPR+F0x+5xo+mPsPIAGu/OOMNd8+g5LiKt2LRICxiaD6cl9pzOu30LKNepbm0JGxGDoyFgAwqLv6C/b+PQEQAIx8OQovvhKFtDRLfLeyJX7fHQh9Keu+MaaGJ2LmN/Hqup/3YN0LFXWvmX3ZdN+Kuk9W1/2YQERdf6DuF3mguMgIL0yoUvdT/XH2cM1n92tiYiWgx4YsXP7KFmdn2wEC4NpJjjYf5cPUumpOCQSFBIKgHqS29lKgz0+ZuPFfKa59bQN5thEsKwYBQ6YUqNpY5hUzyHONIM8FjoVqzsQFgFG3UrS21ZWY2734sz/6Nj9sfDr6jVKfue4+NAfdK2b0jevQDKn36z8gJisxwUfTumHyW1fxwZwLyr7mogvWrGqp3dcY6+hrxt9Cy9bqGdpDR8Rg6IgYAMCgniPVWXvdx+iw26r/t2qTgVZtlOVmv98N1y7rtxaX2NvN7FebYMqn9zBzRYwy+ylbrPnMV2d2oweyL/8gAGGz7mPcjPvK7Les8HFoMKKuqwdaWnfOg5mFgKBnirBi522N8qn3zBDatZX+2V8JVmZfGVuR3QZr5vvULfsMf4TNSsS4DxIrslvi43FB2m0+NB3Pv6T+LOs+JBvdK2ZmhXZuoVebB5Tt/sNZPTF56mXMnBUBSJTr2a35rg1KSqqcYJEAxsaC1nt2zLjraNkqXZ1zeBSGDY8CAAzs9zIA5cw7iUTAuLBrsLeToaDQFEmJNli25DkcO1r3tZS1sou83cwaFYSp4fcx8+u4iverDVaHe1fzfn2gr5zhh7BZSQidmaRqN3PHNtZuN2Hp6DcqS/V/jb6yY3P9+koR9zWAss3Pmdoek6bfxozPrir7+vNOWLu0qUZfr8wv4MFz8Cvnt8C4N+9i3Bt3YW1Thti7Nvj0nWcRfVs7V58hiSgrk+DYHw9ndreY617M2Z+E/ET6kgiCUPNq6fTUWLlyJaZPn44+ffogLCwMvr6+yM7Oxl9//YV169Zh69atyM7Oxvjx43H37l00btxYVTY8PBzz589HZXMqLS1F3759ERUVhRkzZqBVq1aQy+WIjo7Gnj17sHv3blhZWeHYsWPo1asXDh06hL59+6qeLywsDIcPH8b9+5qXVkokEsydOxdffPGFar9jx44hLi4OADB8+HC0atUKbdu2hYODAy5duoQ5c+ZgypQpWLFiBQCgTZs2KC4uxrfffgsHBwd4enrC09Oz2tesqm3btrh06RLeeecdfPPNN3WuW1uJIzpI+tR5/38T48biPtukiI4zdAS9jbqZbOgIetvR7OFcZk16qGaGsRgYB+k/QG9oijvRho7QIBLTh3tDhcdKKK99n38pSdPGte/0LyZExhg6gt4EhfaC+aJRLuLsAEw8xHuMUJas/8lMejqdFf5CnpBV+44i5dTMBYM2Dq99R5G69dZlXLhwwdAxdOKaeaTy/vvv4+TJk7C3t8cHH3yA3r17IywsDLdu3cKaNWs07gpbG1NTU/z555+YNGkS1q5di0GDBmH06NHYtGkTOnfurFr/7mHr3r07Dh48iAkTJmDAgAH47rvvMGvWLCxevFi1z6pVq2BtbY2hQ4eiffv2qjvO1sVLL70EADXe+IKIiIiIiIiI6FHhzDyieujSpQuMjIxw4sSJepXjzDzD4cw8w+DMPAPizDyD4Mw8A+LMPIPhzDwD4cw8g+HMPKovzswTt3/zzDyumUdUC5lMhosXL+Lw4cM4ffo0fvvtN0NHIiIiIiIiIqKnFAfziGqRnJyMzp07w97eHnPmzMGwYcMMHYmIiIiIiIiInlIczCOqhb+/P3g1OhEREREREZGmcoh3iRcx4w0wiIiIiIiIiIiIRIKDeURERERERERERCLBwTwiIiIiIiIiIiKR4Jp5RERERERERERULwKAcoFr5hkCZ+YRERERERERERGJBAfziIiIiIiIiIiIRIKDeURERERERERERCLBNfOIiIiIiIiI/p+9+w6Pqlr3OP6dtElPSEIqpBASAkhHDEhv0lGx0z0I2AUEPEpVOdKxXQWkithQsCJSFBAhCNJLAqSTRgrpPTP3j0kmDJkUJmLc8n6eh3uuk71nfnmzy5q1115bCHHLNFoZI9YQpOpCCCGEEEIIIYQQQiiEdOYJIYQQQgghhBBCCKEQ0pknhBBCCCGEEEIIIYRCSGeeEEIIIYQQQgghhBAKIQ/AEOLvoFKhUqsbOoVJyq5EN3SEejGzs2voCCb7sqVnQ0cwWaeTmoaOYLI/O1k2dIR60fRo29ARTHfgZEMnMJ2ZeUMnqBdtSXFDRzCZma1tQ0cwmeZ8RENHqBeLAL+GjmCy0qiYho5wxypLy2joCCZTWSj367NZo0YNHaF+iooaOoFJVLn/8vFTWhUaraqhU9yR/uVblhBCCCGEEEIIIYQQ/x7SmSeEEEIIIYQQQgghhEJIZ54QQgghhBBCCCGEEAqh3Jv+hRBCCCGEEEIIIUSD0AIaZM68hiAj84QQQgghhBBCCCGEUAjpzBNCCCGEEEIIIYQQQiGkM08IIYQQQgghhBBCCIWQOfOEEEIIIYQQQgghxC3TaGXOvIYgI/OEEEIIIYQQQgghhFAI6cwTQgghhBBCCCGEEEIhpDNPCCGEEEIIIYQQQgiFkM48IYQQQgghhBBCCCEUQh6AIYQQQgghhBBCCCFuiRZ5AEZDkZF5QgghhBBCCCGEEEIohHTmCSGEEEIIIYQQQgihENKZJ4QQQgghhBBCCCGEQsiceUI0MDevIqbMjaPjvdmg0nLqdydWv+FLaqK61nUtrTSMn3GVvvenY+dYStQFW9Yvacq5Pxz1y/gEFDB87DXadc3Gs2kRBXnmXDpjx+aVTYi+aFvv/I29i5myIJGOPXNABSd/c2D1fG9SE6xqz6/WMH5WMn0fvI69YxmR521Yv8iLc0ftDZZTqbQ88uw1hoxNx6VxKVcj1Wxd5cGhnc71yu7mWcSU16LpcG8WKhWcPOzEmjcDSE2qW+3HTYuj74hU7BzLiLpoy4Zlfpw75qRfxsaujJf+d4XmrfNwaVxMaamKhGgbvv3Yi1+/a1yv7EquO0BxMsQvV5F9FNCC4z3Q9GUtVl41r5e4WkXSGuPzcqistHQ8qgUg7TuInV/99aq2ezRYupmWvbFXMVMWXKVjj2xd7Q85sHp+U1IT61j7mYn0fSADe6cyIs/bsv5/3pw76mCw3INPpdCuWw5BbfNx9Shly0pPPlnpbVrgG7O75DF13B90apMIwMlzXnzwcRdS0+1rWROefPRPgpulExSQjqNDEcs+vJfdB4OqLKe2KuXREWfp0y2axq55ZOWoOX3ei83b2pOS5mDkneuYXeHbvKK3GwXX3s2riCmvxVQe5393Ys2b/rd2nB+ZpjvHXrRjw1I/zh2rPMfa2JXx0luRNG+di0vjkvLjvLXuOP9t/Y7zUFH7BDr2uLH2Prew3SRV1v6CDesXeVep/YOTr9GuW27ldrPCg09W1nIwrgM39wKeev4sHe5ORaWCU8cbs/bdu0hNqb3tMW7yBYJCMmneIhNHpxJWLerA3p98jS573/AYHngsEk+vfFKSbfjmi0B++jagXtmVvM0rOTuU77Pz4unYvaJd7MjqhXVsF6s1jJ+RQN8HbmgXv9WUc39UHit9AgoZPi6Fdl1z8PQtbxeftmPzCp96t4vdvIqZMr8iO5w65MjqhbdwnJ+RSN8H03XtyvO2rH/Lp2r28ak3ZDfTZV/uXf/sHoVMnnmJDqHpumPlURfWLm1BarJ17dmtyhj7bBR9hyZh51BKVIQDG99uzrkTjaos6+peyNhnI+ncPR0HxxLSU9Uc3OXJpneb1y+/ZxGT/xtJh26Z5W16Z9a+1YzUpLrk1zD2xRj6Dr+mq324HRuXB3DuuFO16/Qcco1XVkaQlmzFuN731Cv7v4HMmdcwZGSeEA1IbV3Gkq3hNG1WyPKXm7FsRiDe/oUs+TQctU1ZretPWxLNoMdS+XiVD/P/E0zGNSsWbY6gWcs8/TIde2TTrms2e752Y/6kYN6f64eTSwlvbz9P87vyanj3OuS30bDky0iaNi9i2Uu+LHvBF5+AIpZui6xT/ukr4hn8RDpblnkyb3wAGdcs+d+nUTRrXWCw3PhZyYyZkcL3G92YM6YZF0/Y8traWO7um216dusyFm85T5NmBayY1ZxlLwfh7VfIkk/O1a32b11h0CMpbHnHlwWTQ8hIteLNDRcNam9hqaGsTMUXq31YODWEpdODiY+0YdaKy9w/IdH07AquO4CmAC5NVlEYAwGvawl4Q0thHERMVlFWUPO6bg9oabFZY/AvaLUGLLQ496pczqk7VZZrsUmDubMW29Zakzvy1NYalnx5maaBhSyb5s+yF/11tf/yUt1qvzyWwY+ns2WFN/PGB5JxzYL/bb1Cs1b5BssNfiINZ7dSjvzsbFpQY9mtSlk2ZxdNvbNY+mF3lnzQAx/PbJbP/RlrdUmt64+87yJWVqWEnWxS43LTJ//Ow8POsfOXYF5b0p9NX3akTctkls7ZXafPMZpd4du8orcbBdded5y/oDvOz2zOspeb4+1fwJKt5+t4nI9k0KPX2PJOUxY81ZKMa1a8ufFC1eN8Kbrj/JQQlk4LIj7SllkrrnD/RNOP87r8GpZ8eYWmgRW19yuv/ZU6bjfltV/uxbwJzchIseR/WyNp1vrm7SYdZ9dSjvxc/RfXW86uLuV/7/xOE79cVi7qyIo3OuLdJJe33v0dtXVpresPfygKK3UZfxz2rHG5+4bH8NzM0xw+4MW8GaEc+tWHZ2acYcj90aZnV/I2r+DsUN4u/iyCpoGFLJ8RwLJpzfD2L2LJ5xF122eXlreLV/gw/8lgMq5ZsmhLhMGxsmPPLNp1zdG1i/8TxPtz/HByLeHtby7Uq12sttaw5PNLuuzTA1j2UgDeAYUs+aKu2WMZ9HgaH6/wZv7E5rrsn1y+KXu2LvtXrsx/sjnvv+aLk0spb38bTvM29clexlsf/UmTgDxWzm3N8tda4+Obz+J1f9Yp+0sLLjLowQS2fBDIgufbk5FmxRsfnqRZixyD5dy9C1i19Rg+fvmsWdKC16Z2ZOuHzSgrq19HkNq6jLc2naFJQAErXwlm+awW+PgXsHjz2brlX3SJQQ8ns+U9PxZMbUXGNSveWHeOZiG5Rpe3cyhl8n+jyLhmWa/cQtSXjMwrd+TIEVatWsWhQ4dIS0vDwcGBjh07MmbMGMaMGYO5uXlDRzTZN998Q1RUFNOnT/9bP3PlypWEh4eTk5ODu7s7HTp0YOrUqQwaNKjO7zNhwgT2799PTEzM7QvbgAY9loqnbxGT+rUlKVZ35Sj6oi0bfj3N0CeusX199VfGA1rm0/f+dFbMDGDPV7qr/2eOOrJ291nGTU9gwVPBABz43oXvP3YHKk+Up444svm309w/MZnlMwJNzj/4iXQ8/YqZ1COExBjdFdOoC9Zs/D2coWMz2L62+lEJzVoV0PfBTFZMa8ruL1x0+Y/Ys3Z/BONmJrNggu6qupNrCaOmpvLl/7nz1Wp3AE4ftsfbv5gnX03i2C+O1X5GTQY9moJn00KeGtiBpDgbAKIjbFm/5wRDHkthx8bqR7MEhOTRZ0QaK18JZM/XHrrsfzixZudJxr4Yx8KpLQHIybRk6fRgg3WPHWiET0ABAx+6xjebTBsxo+S6A6TugKIEaL1Di3X5QAubYC3nRqpI+wo8xla/rpWH7t+N0n8ASlW4DtfoX7N00f27Uc4JKMtU4TpVg6kGj07T7bO9WpEYo9tnoy7asPG38wwdk8b2jzyqXbdZy3z6PnCdFdP92P2lKwBnwhxY+8sFxr2cxIInK/fFyX1bodWqMDPXMmxcmsl5bzSk7yU8PXJ5cvoDJKbo/n7RcY3YtGo7Q/td4uudrWtc//7/jEarVeHtkc3AnpFGl1FbldIrNIYvv7+LbT/cpX/9epY1b72yl7taXOP4GZ9bzq70bV7J242Saz/o0Wvlx/n2JMWWH+fDbVm/9yRDHk9hx4ZajvMj01g5O5A9X+synfnDkTU/nWLsS/EsnBIC1OE4X8O5pDaDR6fj6VvMpJ4tK2t/0ZqNhy4ydGw629e6V7uurvbXdbWv2G6O2LP213DGvZzMgonN9MtO7hNyw3aTbnLeG903IhZP7zymPNGPpATdqK7oSEc++mwfg0fG8M0XNY/CeeS+oWi1Krx8cuk/ON7oMmbmGsZNvsgvPzfl47WtdL/jyca4uBUyZlI4P3/vR1nZrY9bUPI2r+TsAIMeL28X92lT2S4Ot2XD/jMMHZ3K9nXVd+7q2sUZrHjZnz3bytvFYQ6s3XNO1y6epBtJfuA7F77ffFO7+LADm38/w/1PprB8ejNjb1979ifKs/dufUN2GzYcOMfQ0WlsX1f9cT6gZT59H8hgxQw/9mxzq8y+9zzjZiSy4D/Nb8je+Kbsjmw+fJb7n7zG8mmmjUgd9GACnk0KmDyyG0nxuhF+0ZcdWPfdYYY8dJUdW/yqzx6cQ5+hyaya14o93+qOd2f/dGb19jDGPBPJ6y+21y/73Jxw0q+peWVSJ8pKdfvmuT+rjt675fwPJ+PZtJDJgzvf0Ka3Y93PxxjyaBI7NlV/ETKgRS59hqey6tUg9mzXbV9njzmz+oc/GfNCLK8/U7Vt9OTMaKIj7MhItaJD18x65xfCVDIyD3j77be59957ycjIYMmSJezdu5cNGzYQHBzM008/zQ8//NDQEeulomPt7/Luu+/ywAMPEBQUxPr16/nxxx+ZM2cOAL/88sstvdfcuXPZsWPH7Yj5jxDaP5Pwk/b6kz5AylU15/90IHRAZo3rdu1/nZJiFQd/qOyx0JSp2P+9Cx17ZGFppeuwyL5uyY0nfYD8HAsSoq1x9TBtlIw+/8Bswk/Y6huMACnxas4fs6PrfVm1rltSrOLAd84G+Q9860ynXjn6/J1752Cl1rLva8OT/S/bG9GsVSEeTYtMy973OuGnHPQnfYCUq9ZcOOFI1/4ZNa/bL0NX+x8rh3dpylQc+NGNTj0y9dmrk51piaYeVyGVXHeArAMq7Nqg78gDUPuAfTvI3H/rdUn/XoWFqxbHrrUvp7LU4lL36wlVhA7IIvyEnb5DBsprf9y+DrXPKq99ZU01Zbr/7tQr22C70d6G2xW6doon/HJjfUceQHKqA+cvudOtc1yt69clk5mZFnNzLXkFhler8/J0txipVNpbTK2j9G1eyduNkmsf2i9Dd5yPvfk471CH43z5OfZHV8PsdT3OX7eo13EedH973XZjpPYDTdxubqo93J7t5p57k4k476LvyANISbLjwlkXQrsn17p+XTK1bH0d50bF/Pqz4Rf1X3c1wcm5mNZtTeuYVPQ2r+DsAKEDjLSL49WcP16HdvGATN0++72RdnHPOrSLo6xx9SyuR/Yswk/aGcluT+jA2rJn1ZA9+4bsFkaym5MQpcbV0/Q2/T29U4k446TvyANISbDhwiknQnun1rhuaO9USkpUHPy5srNSU2bGgV0edOqWjoWlLrtnk3w635vO95811Xfk/VXu6ZtOxGlHwzZ9gjUXTjoS2q/m40Bo3/I2/c7Kjm5NmYoDOxvTqft1ff4KrTpk0Wf4NT54vX63BQvxV7jjO/MOHjzI9OnTee6559i7dy9jx46lZ8+ejBw5kv/7v//j7NmzBATUb96Nf6OioupP1MuXL+f+++9n/fr1DB8+nL59+/LUU0/xzTffsHjx4lv6nMDAQDp06FDfuP9YfsEFxF6yqfJ67CUbfJvXfL+hb1ABKVfVFBUajhqNvWyDlVqLt19htevaO5XiH1xAfGTt80jUxK9FITHhVd8jNsIa3+DqP79i3eR4K4oKDA9DsRHWuvz+xfrligtVJEZbVVkOwC/YtEajb1A+sZerzi8Se9kG3+b5Rta4IXvz/Gpqb4ullRYv35t/dy1m5locnEsY/GgynbpnsmOj6fMRKbnuAAWRYGOkDWQTCIVRt/ZexcmQcxxcBoOqhrHmmkK4vheceoBFPe4k8wsuICbCyD4bYY1vUC21Dy6vfeHNtS/fZ/1Nr2ld+DW5TnS8c5XXY6464+uT+Zd8RkGhJXsOBvLAoIu0a5WEtboEvybXeWr0cSJjGnHynGnbvdK3eUVvNwquvW9QNefYy7a1nmP9gqo7ztvojvNVzrE3HudT6NQjq8aRf3XhF1xITISR2l+qQ+2r224uWf89201ADrHRVefIjItxwNc/x8gat843QHdLZ2y04Uiwiv9uGmDa5yh5m1dydgC/oAJijR0rL1vjG1SHdnG8kX32UkW7uPpc9k6l+LcoIP5K1c+uq2qzX7Kp9TjvG1xAion7qy57IfGXTW/T+wbmERNZde7c2Eh7fJvVfPuub2AeKQk2VeoeF2mPpZUWb19dm7pV+0wAigrNWLT6BN8e28cXv+1nxpvncHAyvRMVwLd5PjFG2/R2+AbW3Kb3bZ5HSoJ11fzlbXpvv8rtztxCw/OvX+HrDU0MOg7vdFpUaLT/3n//ZHd8Z96SJUtwcXFh6dKlRn8eGBhI27Zt9f/9xx9/0L9/f+zt7bGzs6Nfv3788ccfButMmDCBJk2acPz4cbp164aNjQ0tWrTgxx9/BGDlypX4+/vj6OjIyJEjSU01vOKhUql47bXXWLRoEU2aNMHGxoaePXty6tQpg+X8/f2ZMGFClcwqlYoFCxbos2zevJmEhARUKhUqlQp/f3/9sqmpqUydOhUfHx/UajUhISGsXbvW4P02bdqESqXi4MGDPPzwwzg7O3PPPdVP9JmRkYGnp/Fh8GZmhptcdHQ0Y8eOxdPTE7VaTbNmzXjxxRcNanljXoD8/Hxmz55NQEAAVlZWBAQEsGjRIjSayisn+/fvR6VS8d133/Hcc8/h5uaGm5sbY8aMITMz0+D9SktLWbJkCa1atcLa2prGjRszaNAgwsPDb6lOpnBwKiUnq2oPRG6WBQ5ONc8p4+BcSk5W1du/czN172fvXP0cEc8siAUV7NhQ81w0tXFwLiPXSIacTHMcnGqeo8LBuZTcTOPrVvxc/xnZ5tx8JfLm5W6Vg1MpuUZqn5Nlib1j7bXPzTa2roXRTMPHJPNj+BG+PHaMp+dFs/pNf/Z9U/3tUbVmV3DdAcqywNzIcxDMnaD0Fr97pf8IaFS4Dq95xFfmr6DJrX252lRf+7rts9X93Sre+3ZysC8mN6/qJNw5uWoc7OrXkL7R8tX38vsxP5bP/ZnvN21l3bJvsTDXMPt/91FaZtqUFUrf5hW93Si49g5O1RyrMy1MP86Xn2Nv/rsNH5vMjxFhfHn8OE/PrzjO1+8BGA7OZdXUz6IOta9+m6v4+e1k71hMbk7V+aRysq2wd6jfXQEVHBx173Pz5+SU/7eDiZ+j6G1ewdkr3ru6tq3p7WLda/Y15Hrm9fJ28frqb4WtTfXZzeuY3cj3AX2bvqbs8aDSsmN9PdqVTiVGj3e5WXU4Vlazrr5NXL6furrr2hnTFl4gIdaWec92YOPbzbm7RzpvfnjS5JH7ugzG2/R1yu9c3feBqsf6hyddxdJKw5drmpqcVYi/0h09Z15ZWRm//vor999/P9bWtV/NOHPmDL169aJVq1b6Dq7FixfTq1cvwsLCaNeunX7Z7Oxsxo0bx8svv4y3tzeLFi1i1KhRPPvss1y6dIn/+7//IyUlhZdeeolnn32WL7/80uCzPv74Y3x9fXn//fcpKipi3rx59OvXj8uXL+Pi4nJztGrNnTuX1NRUjh07xnfffQeAWq3WZ+zevTsFBQUsWLCAgIAAfv75Z55++mmKiop4/vnnDd5r9OjRPP7443z11VeUllZ/YOzSpQubN2+mWbNmjBw5kuDgYKPLRUdH06VLF2xtbXn99dcJCgoiLi6O3bt3V/vepaWl3HfffVy4cIG5c+fSpk0bwsLCeOONN8jIyGDFihUGy7/44osMGzaMTz/9lIiICGbNmoW5uTmbN2/WL/PYY4/xzTff8NJLL9G/f38KCws5ePAgSUlJhISE3HKd/ukefTqRvvens3JWgMGtAOL2ObjTjfBTDjg2KiG0XwZPz4tGo1Hx0+f160wVkPGjCpsQLbbGDzN66T+osHDR4tT978l1J5vw6En6dY9kzSediYh0w90tj7EPnuJ/r+xhxuuDKCySCaPFv8/BH90IP+mAo0sJof2u647zZSp++tz0zgEhxO336DOJ9L0/g5Uz/RXXLn702ST6PpDBypf9/vHZKzrrzhxvxAdv6eYcPf2HC/m5Fryy9ByduqVz/HcTn072N/DyLeDRqfG8+VxLSorv+PFQ4h/iju7MS0tLo6CgAD+/6if1vNHrr7+OWq1m3759ODs7AzBgwAD8/f1ZuHAh27dv1y+bk5PD6tWr6dmzJwDe3t60a9eOH374gQsXLugfqHHu3Dnee+89ysrKDB6yUVBQwO7du7GzswPgnnvuISgoiFWrVvHGG2/U+XcMDAykcePGWFlZERoaavCzd955h9jYWM6ePUtQkG5S2P79+5OZmcnChQt5+umnsbCo3EQeeuihakcw3mj16tU89NBDzJo1i1mzZuHq6sqAAQOYOHEiAwcO1C83f/58CgoKOH36NN7elbeijB8/vtr3/uyzzzh06BAHDhzQ17Zfv34ALFy4kNmzZ+PuXnllqmfPnrz33nsADBw4kIiICNatW6fvjP3ll1/4+uuveeedd3jhhRf0691///0m1+lW5GYbv1pnX82IPYN1syzw8Kk6mqbi6p2xq6tDnrjGxFlX2bS8Cbu31W/EgC6DOfZGrvRWd3Xy5nXdm1S9al4xWqBi9EBuljn2jmWAlhuvAt+83C1nz7bA3kjtq7vCeKOcLAvcvave8lDxt7w5U1aGJVkZug6MP39rhNpGw6TZMez+yt2keUOUXHcAc0coMzICrywLLIyM2KtO3jkojFbRZGbNc1eVpEL2UXB/rOZbceui+trXZZ81x71J1X22sqa390FLuXlW2BsZgedgX0SOkRF7pvBrcp3HR55lxZpu7Npf2cMafqUxm1ZtZ3Cfy+zY1eqW31fp27yitxsF1z432/iojOpG3d2o2uN8+Tn25r+bwXH+YCPU1homvRLD7q8amzw/VG6WudFR9tWNQLp5XePbTcV56jZvNznGR+A5VDNiz7TP0L2PvUMJ19Mrf5+KEXk5Jn6Oord5BWeveG9jIwjt63isNN4u1r1frpFcQ0ZfY+LsBDYt82H3l/VrF1efvayObfqqt4NWtumNZB+TysTZiWxa6s3uL+vXCZabbfyuFPtqRjffvK67V9XbiPVt4mzdfpiTpfvfk2GGg1JOHNbNS9osJMfkzrzq2vR1yl9bm778bzf1tUhOhzkRftoROwfdzywttaDSPd22pFhFcZFyH5gplEm6lW/BwYMHGTZsmL4jD8DR0ZERI0Zw4MABg2Xt7Oz0nU0AISG6KxD9+/c36LQLCQmhtLSUpKQkg/WHDBmi78gD3S21oaGhHDly5C/7fXbt2sU999xDQEAApaWl+n/33Xcf6enpXLhwwWD5Bx54oE7vGxwczMmTJzlw4ACvvfYa7du3Z8eOHdx33328+eab+uV2797NsGHDDDry6pLZz8+Pbt26GWQeOHAgJSUlhIWFGSw/dOhQg/9u06YNRUVFpKSk6DOoVCqeeuqpGj/zVupUYe3atXTu3JnOnTtTojU+V0bsJRv8jMwB4hdUQFwt83bEXrLBo0kRamvDhoNf8wKKi1Qk3nSFrt8DaTz3RgxffeTJ5/9Xv3l89BkirPFrUfV38w0uJO5SzVcIYyOs8WxajNrGsCPGN7hQlz/GSr+clXXlXC03LgcQe0mNKWIv2+BnZG483+YFxF2pOu/GjeKu2BqtvW/zfEqKVSTF1fy7Xz5rj629hkZupt0CpOS6g25uvAIjD0MtiALrW3iIXPr3KlQWtT/QIn0nUFb/W2xBN3+NX3DVfdY3uJC4Wuarib1ko6u99c21L99nY0yvaV3EXHXGv0lmldf9fDKJS3D+Sz4joOl1ACKiDBvkCcmO5ORamTw3n9K3eSVvN0qufexl4+dY3XG+5nNs3GXj51jf5gW643wto2Aun7Or13EeKrYbI7UPuoXa37zdBBX+LdtNXLQDvkbmrGvqn0NczC1ctalBxZx8fuVz51Wo+Nx4I3P21el9lbzNKzg7lO+zRo6Vfs0Libtch3ZxUyPt4qCKdrFhrn4PpPHcm7F8tdaDz9+vf7s49lI12YMK6nCct8bDyP7qV83+2u/BdJ57M46v1njw+fumz8FcIS7SDr/A3Cqv+zbLJS7KzsgaN2SPtMPDp6DqsbJZLiXFKhLjbMuXqzon343q8yCeuCu21bTp84mLrLlNH3vFFg+fwmrb9InlD1DybZ5Pl97X2XbsiP5f72GpuHkUs+3YESZMjzE5vxCmuqM781xdXbGxsSE2NrZOy2dkZODlVfWA6enpyfXr1w1eu7HDD8DKSncCbNSokdHXCwsNT7weHlVvy/Dw8CAhIaFOWevi2rVrHDx4EEtLS4N/Dz/8MADp6YZP/zH2u1fH3Nycnj178uabb7J3716ioqJo06YNCxcu1NcqPT2dJk2qf1R4dZljY2OrZO7SpYvRzDffklxxi3FFvdPT03FxccHGpvoGwq3WqcLkyZM5fvw4x48fx1Jl/CQetrcRIR1y8Wxa+ff38CmiVadcwvY611AJOLrPGUsrLT2GVD6Rz8xcS89hGZw45GQwBLzbwAymL41i1xeNWfc/X2NvZ5Kw3Y607JiPp2/lFS2PJsW0vjuPsN2ONawJYXscdfmHZRrk7zUikxMHHfT5j/3qQEmxij4PGu5j/UZdJ/qiNSnxpjUaj/7iQkj7HIPau/sU0qpjDmH7GtWwJhz9pZEu++DKv72ZuZaeQ9M5cci51uH3bbpkk59rRma6aaMGlFx3AKdeWvLOQtHVyteKEiH3NDj3qluHm6YEMn4Gx3vBspaZB9J/UGETpMW2hcmR9cJ2O9OyY95NtS+idedcwnbX/GSNsD1O5bWvrKmZuZZew68b1P52OfJnU1oGpeLpXvkF28Mth9bB1zjy518z/0tGpu5YGhKYZvC6j2cWDvbFpGXU/KWgOkrf5pW83Si59kf31XScr/nAcfQXF+PH+SF/z3EeKmpvZLu5O4+wPbVtN+W1H55pkP/m2t8uRw95EtLqOp7elZPnu3vm06pNBkd//2ummAg/50LWdSt6D7hq8HqfgfFkZ1ly4axrNWvWTMnbvJKz6zI4V20XNymiVedbaBcPNTxW9hyewYnfHA3bxfddZ/ryaHZ93ph1i/6adnHYXidCOlTdX1t1ziVsTy3Z9zobPc73HHa9muwx7PrcjXWLbu17VLXZ9zcmpE02njeMDnT3LqBV+yzCDtQ8YvHoATcsLbV0H5ByQ3YNPe5L4cQRV0pLdNnDzziSkWpFp26GTxLvdK/uGHvpXM3bZ435f3ElpF02nk0qO1PdfQpp1SGbsF9qPg4c/dUVSyst3QdVtlvMzLX0GJzKid8b6fMvnh7C7HFtDP4d/60RWRkWzB7Xhu+3/jUDJZRKg+pf+++f7I6+zdbCwoLevXuzZ88eioqK9B091XFxcSE5ObnK68nJyVU66eqrYuTYza/5+Pjo/9va2priYsOrYtV1LBnj6uqKu7s777zzjtGft2hh+M1XpTJ9Y/b29mbSpEm8+OKLXL58mS5duuDm5nbLnZOurq4EBARUmWOwws0Py6iNm5sbGRkZFBQUVNuhd6t1uhU/fd6YEeNSmL/2MptXNgEtjJt+ldQkK3Z+Wnm7sLtPERv3n2bruz58+p5uG4i8YMf+712YMi8OC0styfFqho65hmfTIpa+FKhf964u2bzybiRRF23Z85UbIe0rr7yVFKuIvGDal2uAnVtdGDExjQUbY9i81BOtFsbPTCY10Yoft1SePN19itl05CJbV3mwdZWuER95zpb93zozdWGiLn+cFcPGpePZtJglz1U2rLLSLdm+1o3HnrtGQa45V87a0GtEJu3uzWXBBNOfNP3TFx4MH5PMvA/D+XiVL1otjHspjtRkK3beMJedu3chG/ad4NP/a8qn7+s6PCIv2HPgB1cmvxaNuYWWlKtqhj6RjGeTQpZOD9KvO/ixZELa53DqsDNpyVY4OJfSc3AaPQans2GZr76BcKuUXHcAtwch9Qu4Mk2FzzO6WxQSP1Bh5QFuD1UuV5QI50ao8HpKi/cUw/fIOghlWSpch9d8i23+RSi8oqLJ9JqXq6udn7oyYmIqCzZEsnmpd3ntk3S1/6RyNJq7TxGbfj/P1re92Pq27kJI5Hlb9n/biKkLrt5Q+zRd7Z83rGlQ2zw8mhZjVn7Y9QsqpHv5F5Rj+5yqPPGuLn76JZiRA8N5fcY+Nn7ZEYDxD58kNd2OH/ZWHsfc3XL5+O2v+WR7Oz7Z3l7/etuWyTg5FOLirGssBzdLp6BQ11Hx2x/+AJwL9yAyphFTxhzD3q6YS1GuuLvlMfr+0+TmWbL7YOWx6VYofZtX8naj5Nr/9IU7w8cmMW/1jcf5eN059rPKi6bu3kVs+OUEn77f5IbjvJ3uOD8nBnNLLSnx1gwdnYxn00KWzqh8HPfgx1LKj/NOlcf5Ien0GJzBhqWmH+cBdm51ZcSENBZsiGbzUi9d7WclGa/94QtsXeXJ1rfLa3++vPYLErCw0JIcf8N285zh9DJBbfN1242Z7mKKX3AR3YdmAnBsn6NJ282u7/0YNiqauW8dZctHLdFqYcxT4aRds+Gnb/31yzX2yGf9F3v5bFMLPttUeRy6q30aTs7FNHLRdeo0D8mkoED3teX3/bovzWVlZmxZF8IzM86QnmbDqeONadcxlQFD41j9dhtKTby9WcnbvJKzA/z0WWNGjL/G/HVX2LzcR9cunpGg22e3VnYqufsUsfHgGba+482n75a3i8/bsf87F6bMv6ld3KSIpS9WDvu/q0vODe1iV0I63NQuPm9au/inT90YMT5Vl32ZLtO4GYnl2Q2P8xt/O8fWd7z49B3v8uy27P+uEVPmx+v316FjU3Vt+hcra3pXlxxeeS9al33bzdnNiDxf8yi06uza7sPwx+KZ985pPn4/EK1WxdhnI0lNseanbZXfPd29Clj/w2E+XRvAZ2t0NY0Kd+TALg8mz7qky55gw9BHruLpU8iy/96lX1dTZsbGd5oz480LPDfnIr/vc8e7aT7jno/k9LFGnP7D9O/Su7Z5Mnx0IvM+uMDHb/uj1cLYF2NJTVbz0xeVg1HcvQtZv/sYn37gy2cf6I6DURftOfCjG5P/G6XLf1XN0MeT8GxSyLKZIfp1I05X7Wzs/0AKJcVmnP3D2eTsQtTHHd2ZB/DKK6/Qu3dvZs2aZbSzJjo6mpycHNq2bUuvXr3YuXMnOTk5ODjohu7n5OTw/fff07t37780186dO8nLy9PfahsTE0NYWBivvPKKfhk/Pz/OnTtnsF7FE3NvpFarKSioOux70KBBvPfee/j6+hrMM1dfSUlJRkfxVTwdtuJJtwMHDmT79u3VLm/MoEGD+Prrr7G3t9ffulwfAwcOZPHixaxbt67aB1ncrjoBFBWYM3t0CFPmxDFzRSQqFZw67Mia1/0ozK+8HVsFmFugb2hXWDmzGRNejmfcjATsHUuJumjLnPEtuHJDQ6R912ys1FqC2uSz6uuLBuunXLVifI/29co/65FApi5IZOa7cbr8h+xZPc/HML9Kl191U7t6xbSmTJidxPhZydg7lhF1wYbXRjfjylnDxsimxV4U5Jlz/6RUGjUu5WqkmkVT/Di61/SreEUF5rwytjWTX4tm5vLLgJZTR5xZs8jfIDsV2W96ytbKV5ozfnoc46bF6WofbsecJ1sReaHyNoKYCFu69stg0uwYHJxLycqwJD7ShnlPhXBsf90fZGMsu1LrDmBuA8FrtMQvVxE9VwVacOgCTWdqMb+5HVqm+3n5/9FL/16FuZMWp57UKP17FVhocRlSr8h6utoHMXXBVWa+E1NeewdWL2hSTe0Nc6+Y4ceEWYmMn5moq/1FG14b25wr5wx/8RETUhn4SOXV657DM+lZPsJmXGhrUq7e+siHwiJLZr55H0+PPcbsZ35DpdJy8pwXH37cxeChFCq0mJtrq2zz4x46SbtWlReaRt4Xzsj7dMf1AY9PAECjNWPmovt44v6zDO0bwfiH88nKUXPhkjubt3UgNb3m22yqo/RtXsnbjZJrX1RgzitjWjP5tRhmLr+C7jjvxJo3bz7Oa41mXzk7kPEz4hk3Lb78HGvHnCdbEnn+puN8/wwmvRJbfpy3ID7SlnmTQji2v34XenW1b87UBQnMfDe2svbzb6691vh2M923vPZJlbUf06zqdjMxlYGPVI4IMthu7mlp2nZTaMGrL3bjqefPMWPuCVBpOX28MWvfbUNhQeXXD912o62SffR/wmnbofIC9fBR0QwfFQ3A0O4j9a//9G0AWlQ8+NgVRj1+hWspNqxe1ZYfd5jeqaT0bV6p2Svyz368BVPmxTNzVZQu/++OrHnd12h+s5v32ZcDmDDrKuNmXC0/VtoyZ3wwV87d0C7ulo2VdXm7eHu4wfop8VaM794OUxQVmDP7sWBd9rejy7M7sGZh07pln+HPhFkJjHs5QX+cnzMuyGB/bX9vTmX2HRFVs9/bxuTs/32qE5NnRvDyovOggtNHXVizLNhgf6V8fzW7qX2wal4rxj8fydjnIrF3KCX6kj1zn2lPZLjh9rDve2+0WhUPTYxhwMhEcrIs+fVHTza905ybn458y/kntGHyf6N4eWmELv8RZ9a81cxom/7m2q96NZjx02IZ+2IM9o6lRIfbM/epuwza9EL8E6m0Wm39JxFSuLfffpvp06fTr18/JkyYgK+vL9evX2ffvn2sW7eOTz/9lJEjR3LmzBnuuece2rRpw+zZs1GpVCxZsoQzZ84YPM12woQJ7N27l6tXDYf9q1QqXnvtNYN54zZt2sTEiRO5fPkyzZs31y/XpEkTfH19mTlzJkVFRcyfP5/U1FSDp9lu3LiRJ598kpdeeolhw4Zx+vRpNm3axNmzZ5k/fz4LFiwAdA9weOmll/jggw/o3Lkz1tbWtGnThqysLEJDQ9FoNEybNo0WLVqQl5dHeHg4v/32G99++221GWvi6upK//79GTJkCAEBAWRnZ7Nz505Wr17Nww8/zBdffAHoOijvvvtu7O3tefXVV2nevDkJCQns2rWLTz75RF/L/fv3ExMTA0BJSQn9+/fnypUrzJgxg3bt2lFcXExkZCTfffcd33zzDba2tuzfv58+ffqwZ88e+vfvX6Xe0dHR+lF8Dz30EN9++y3Tpk2jb9++lJSUcPDgQYYOHUrv3r3rXKeaOJq5EqoeXOty/0TaoqqTwiqJmZ3pIw8bmiYvr/aF/qE6nfxrRsI1hD87Kftpq5oebRs6gsnMDpxs6AimM1P4xNeaqhO3K4WZrWmjUf4JNEYutiqJRUDdHiL3T1QaFdPQEe5YKsu/5qFLDUKr3PaN2V98J9nfTqHfSY7kfktWaVrtCyqUU4gH3dY+1tAxbpvU6b9z/Pjxho5h1B0/Mg/gpZdeokuXLqxatYqXX36ZtLQ0HBwc6Ny5M2vWrGH48OEAtG3blv379/Paa68xfvx4tFotoaGhHDhwQN+R91cZN24cdnZ2PPfcc6SlpXH33Xfz+eefG8wBN378eOLj41m/fj1r1qyhR48e7Nixo0qH26RJkwgLC+PVV18lMzMTPz8/YmJicHJy4vDhw7z++ussWbKEhIQEnJ2dadGiBaNGjTI5+6JFi9i5cyfz5s0jJSUFc3NzgoODWbx4MS+99JJ+OX9/f8LCwpgzZw7//e9/yc3NxcfHh5EjR1b73paWlvz8888sXryYtWvXEh0djZ2dHYGBgQwdOlQ/B+Gt+Pzzz1myZAmbN2/m7bffxsnJibvvvptJkyYB3LY6CSGEEEIIIYQQiqUFTT0eYCJMJyPz/oGMjeATyiYj8xqOjMxrGDIyr+HIyLwGIiPzGoyMzGs4MjJPmEJG5jUMGZnXMP71I/NaeBC69vGGjnHbpM849I8dmXdHP81WCCGEEEIIIYQQQgglkc48IYQQQgghhBBCCCEUQubM+weSO5+FEEIIIYQQQgjxT6ZF5sxrKDIyTwghhBBCCCGEEEIIhZDOPCGEEEIIIYQQQgghFEI684QQQgghhBBCCCGEUAjpzBNCCCGEEEIIIYQQQiHkARhCCCGEEEIIIYQQ4pbJAzAahozME0IIIYQQQgghhBBCIaQzTwghhBBCCCGEEEIIhZDOPCGEEEIIIYQQQgghFELmzBNCCCGEEEIIIYQQt0SLSubMayAyMk8IIYQQQgghhBBCCIWQzjwhhBBCCCGEEEIIIRRCOvOEEEIIIYQQQgghhFAImTNPiL+DVou2qKihU9yZAps2dALTnQlv6AQm+7ODcq8V2Rxwa+gI9VLQ+1RDRxDib6XJz2/oCHessrirDR1BKJC2pLihI5jMvHHjho5gsrK0tIaOUC9manVDRzCNRtvQCcS/lHTmCSGEEEIIIYQQQohbppUHYDQI5Q6dEEIIIYQQQgghhBDiDiOdeUIIIYQQQgghhBBCKIR05gkhhBBCCCGEEEIIoRAyZ54QQgghhBBCCCGEuGUaZM68hiAj84QQQgghhBBCCCGEUAjpzBNCCCGEEEIIIYQQQiGkM08IIYQQQgghhBBCCIWQOfOEEEIIIYQQQgghxC3RakGjlTnzGoKMzBNCCCGEEEIIIYQQQiGkM08IIYQQQgghhBBCCIWQzjwhhBBCCCGEEEIIIRRCOvOEEEIIIYQQQgghhFAIeQCGEEIIIYQQQgghhLhlWnkARoOQkXlCCCGEEEIIIYQQQiiEdOYJIYQQQgghhBBCCKEQ0pknhBBCCCGEEEIIIYRCyJx5QjSwxt7FTFmQSMeeOaCCk785sHq+N6kJVrWua6nWMH5WMn0fvI69YxmR521Yv8iLc0ftDZZTqbQ88uw1hoxNx6VxKVcj1Wxd5cGhnc53dH43t3ymTDlJh44pqNBy8pQHa1Z3IDXVrtZ1x084Q3BQBs2DruPoWMyKFV3YuyegynLTph8lJCQdN9cCVGaQlGTHz7ua8cMPzdFoTL+eouS6Kz2/5loZJe/noDleDFow62SF5fMOmHmY1239mFJKNuSiOVUMBVpUHuZY3G+LxUO2+mW0mRpKVudQdrhIt0ygBZZP2mPeRV2v7Lq6J9Cxx4119yE1sY51n5lUWfcLNqxf5F2l7g9Ovka7brkEtc3H1aOULSs8+GSlV71yV2ZX5jYD0NirmCkLrtKxR7Yu/yEHVs9vegu1T6TvAxnYO5URed6W9f/z5txRB4PlHnwqhXbdciprv9KTT1Z61z+7gmuv5OxKz+/mVcyU+fF07K7b5k8dcmT1wlvY5mck0vfBdOwcy4g6b8v6t3w498dN2/ykFNp2yyG4bR4u7qV8ssqLT1bJNq/U7ErP7+ZRyOSZl+gQmo5KBSePurB2aQtSk61rz25Vxthno+g7NAk7h1KiIhzY+HZzzp1oVGVZV/dCxj4bSefu6Tg4lpCequbgLk82vdvc5OxKbh8AuHkVMWVOLB26Z+va9IedWPOGH6mJtbebLK00jJt+lb73p2HnWErUBTs2LGnKuWOO+mV8AgoYNiaFdl2z8WxaREGeOZfO2PHxyiZEh9f+veHfTYVG5sxrEDIy7w61adMmVCqV0X/Ozs4NHe+22r9/PyqViv379zd0FNQ2GpZ8GUnT5kUse8mXZS/44hNQxNJtkahtympdf/qKeAY/kc6WZZ7MGx9AxjVL/vdpFM1aFxgsN35WMmNmpPD9RjfmjGnGxRO2vLY2lrv7Zt+x+dXqUhYv+ZUmTbNZsbwLy5aF4u2dy5Ilv6JWl9a6/ogRl7FSl/HH0Zq/NKityvjuuyAW/a8bb75xLydPejBl6kmemnzK9OwKrrvS82sLtRS/dB1tXClW/3XE6jVHtFfLdK8VaGtdXxNeQtHTGVCixWqmI1ZLGmHxiC3assp1tcVaiqZdp+yPYiynOmD1hjMqd3OKX8mk7GSxydnV1hqWfHmFpoEVdfcrr/uVutV9eXndl3sxb0IzMlIs+d/WSJq1zjdYbvAT6Ti7lnLkZyeTs1bJruBtBipqf5mmgYUsm+bPshf9dfm/vFTH2scy+PF0tqzwZt74QDKuWfC/rVdo1urm2qfh7FbKkZ+d65XXILuCa6/k7ErPr7bWsOTzSzQNLGT59ACWvRSAd0AhS76IqFP2aUtjGfR4Gh+v8Gb+xOZkXLNk0SeXq2zzgx5Pw9m1hMOyzSs+u9Lzq63LeOujP2kSkMfKua1Z/lprfHzzWbzuzzplf2nBRQY9mMCWDwJZ8Hx7MtKseOPDkzRrkWOwnLt3Aau2HsPHL581S1rw2tSObP2wGWVlpnemKLl9oMtfxuKtF2nSrJAVLzdj2YxAvP0LWbL1Yt2ON0uiGPTYNbasasKCSS3ISLXkzc3hNGuZp1+mY/cs2nXNZu/XjVnwVDD/N88fJ5dSVm0/T/O78mp4dyFuHxmZd4fbtm0bTZo0MXjNwuLfvVl07NiRI0eO0KpVq4aOwuAn0vH0K2ZSjxASY3RXjqIuWLPx93CGjs1g+9rG1a7brFUBfR/MZMW0puz+wgWAM0fsWbs/gnEzk1kwQTdKzMm1hFFTU/ny/9z5arU7AKcP2+PtX8yTryZx7BfHaj/j35x/0KAoPD3zeGrSYJKSdFf6o6OdWL9hJ0OGRrJje4sa139o1INotSq8vHLoPyCm2uUWL+5m8N8nTnji6lrIwIHRrFnd0aTsSq670vOX/VCANqkM9RZXzJrojpWqQEuKRqdR+l0+lo9Wf3VWq9FS/L8szDpaoV7kXPmDjoZXvcv2F6KNKsXq7UaYd9D9zOweK4qezKBkdQ7ma1xNyj54dDqevsVM6tmysu4Xrdl46CJDx6azfa17tevq6n5dV/cvdZ9/5og9a38NZ9zLySyY2Ey/7OQ+IWi1KszMtQwbl25S1irZFbzNAAwenYanbxGTerUiMUY3QiPqog0bfzvP0DFpbP/Io/r8LfPp+8B1Vkz3q6x9mANrf7nAuJeTWPBkoH7ZyX1b3VD7NJPzGmRXcO2VnF3p+Qc9karb5nu3JilWt81Hh9uw4cA5ho5OY/u66rf5gJb59H0ggxUz/NizzU2XPcyBtXvPM25GIgv+Uzn6aEr/G7b5sbLNKzm70vMPejABzyYFTB7ZjaR43Uj76MsOrPvuMEMeusqOLX7VrhsQnEOfocmsmteKPd/qLhKf/dOZ1dvDGPNMJK+/2F6/7HNzwkm/puaVSZ0oK9WNyzn3Z9XRe7dCye0DgEGPpeLZtIin+re74Xhjy/pfTjPkiWvsWF/96L+AkDz6jExn5axm7PlKt32dOerImp/PMHbaVRZO1n0fOPCDK99v8QAqO01PHXFk08FTjJyQzIqXA429vRC3lYzMu8O1b9+e0NBQg3+dO3du6Fi3laOjI6GhoTg6mt7Y+KuEDswm/ISt/sQJkBKv5vwxO7rel1XruiXFKg5856x/TVOm4sC3znTqlYOllQaAzr1zsFJr2fe14Yn+l+2NaNaqEI+mRXdk/tDQBMLDXfQdeQApKfZcOO9G19CEWtevzyPYs7Ot6nUFVcl1V3r+st+LMGtlqe/IAzDzMsfsLks0v9f8nppTJWhjy7B4xLbm5S6UgBp9Rx6ASqXC/G4rtOGlaFNrv8psTOjALMJP2Bmv+8Da6p5VXvfKehqrO9Rv36j+85W7zQCEDqiofeWtVinxas4ft69D/mpq/10jOvXKltr/S7MrPX/ogCzCT9rpv1jrsx+3J3RgZo3rdh2g2+YPfu9ikH3/9y507Cnb/L81u9Lz39M7lYgzTvqOPICUBBsunHIitHdqzdl7p1JSouLgz5Wd3JoyMw7s8qBTt3QsLHXZPZvk0/nedL7/rKm+I++voOT2AUBo/+uEn7Q3PN5ctebCnw507X+9lnUzdcebHwyPNwd+cKVTjyx9/uzrltzYkQeQn2NBQrQ1bp6m3zUhRH1IZ56oUXR0NGPHjsXT0xO1Wk2zZs148cUXDZb55JNPaNeuHdbW1ri5uTF27FiSkpIMlvH392fMmDF8/vnntGzZEjs7Ozp37syhQ4eqfOatvN+WLVto0aIFNjY29OjRg8uXL5OXl8eUKVNwdXXFw8ODGTNmUFpaedtkdbfZ7tixg3vvvRd7e3scHR3p0qUL3333nf7n77zzDi1btsTGxoZGjRrRuXNnduzYYWppAfBrUUhMeNV5NGIjrPENLqx13eR4K4oKDHfj2AhrrNRavP2L9csVF6pIjLaqshyAX7DpjS4l5/f1yyY2tuow/9hYR3x963ebSFVazMw02NkVc++98fTvH8OOHTWP/KuJkuuu9PyamFJUAVVHL6v8LdDE1Hx7tuZMeWOvWEvh0xkU9E2hYOQ1it/JRlt0wy26ZoCFkQavpe41TXTtt4Eb4xdcSEyEkbpfqkPdg8vrXnhT3S9V1N307aEulLzN6NYtICbCxnj+IBNrH2Ejtf8XZ1d6fr+gAmKNbfOXbGrd5n2DC0iR480dl13p+X0D84iJtK/yemykPb7Nar4N0zcwj5QEG4oKDefejYu0x9JKi7ev7nbVVu0zASgqNGPR6hN8e2wfX/y2nxlvnsPByfQOJSW3DwB8gwqIvVT1QmnsZRt8mxcYWaOSX1A+KVfVVWofe8kGS7UWL7/qf397p1L8gwuIu1L1WHen0WpV/9p//2T/7vspRa3KysoMOroAzMzMMDMzIzo6mi5dumBra8vrr79OUFAQcXFx7N69W7/s2rVrmTJlCo8++ihvvfUWiYmJvPrqqxw9epQTJ05gb195Uvvtt9+IiIjgjTfewNramrlz5zJs2DBiYmL08/TdyvsdPHiQyMhIlixZQnFxMS+99BKjRo2iWbNmNG/enM8//5yDBw/y5ptvEhgYyDPPPFNtHd577z1eeOEF7r//fjZv3oy9vT0nTpwgJiYGgK1btzJjxgzmzZtHjx49KCgo4MyZM2RkZNSr/g7OZeRmVZ00PyfTHAenmkffODiXkptpfN2Kn+s/I9ucm68m3bycKZSc38GhmNycqpP65uSqsXf4a6+wdemSxMLXfwNAo4Evv2zJZ5+2Nvn9lFx3/XsrNX+2BpVD1RO7ytEMcmueM0+brru6W7wwC4sHbDGbbI8mooTSDblor2n0t96aNbWgLE+LJqYUM//K07TmvG671GZrqrx3XTg4l1VTO4s61L26v5mF/ue3k6K3GWqun4NTze/r4Fxa7e9e8d63k5Jrr+Ts+vdWaH4H5zJyjGTPzTSv0zafk1X1K0pu+fHGvh41rQul112p2fXvrdD8Dk4l5GYb2W6zLLB3rGWbr2bdiv3AwbEEAFd3XTtg2sIL/PKDF19u8MeraT4TXojEt9lJXhrdxaTOByW3DwAcnErL/6ZVM9ibeo6tqH0N28MzC2JABd9s9Ly1wEL8RaQz7w4XEhJS5bWhQ4fyww8/MH/+fAoKCjh9+jTe3pWT/I8fPx7QdQTOnTuX3r178/nnnxu8Z48ePdiwYQMvvPCC/vXs7GxOnTpFo0a6Ydienp7cfffd7Ny5kyeeeOKW3y83N5ddu3bh5KQbXZWcnMyLL75Ily5dWL58OQADBgzgxx9/ZNu2bdV25mVnZ/Pqq6/ywAMPsH37dv3r9913n/7/P3LkCG3btmXevHn614YMGVJTaYXQO3fOjReeH4CdXQnt2qcwalQEaGHz5rYNHU38ncr74MwHWGP5H92FCfMOVqCB0jW5+s478/7WlGzMpfitLKxmOaJyNaf0+wI0Z3SNecz+2VcJhRBCCPHXU6l0Fw3PHG/EB2/pvsOd/sOF/FwLXll6jk7d0jn+u1tDRrxjPPJ0An1GprNqdoDB7b1C/J3kNts73I4dOzh27JjBv7fffhuA3bt3M2zYMIOOvBtFRERw7do1Ro8ebfB69+7d8fPz48CBAwavd+3aVd+RB9CmTRsA4uLiTH6/io48qOyYvLETruL1+Pj4amtw+PBhcnNzmTx5crXL3H333Zw6dYrnn3+evXv3kp+fX+2yFdauXUvnzp3p3LkzJRgfYp6bZY69kSte1V3RrrKukatdFVfAKq6I5WaZY+9YBmhrXM4USs6fm2tpdASeg32R0RF79ZGfb8Xlyy6cOuXB5k1t+eKLljz8SDiurrVvR8Youe7691ZqfgcztDlVR+BpszVgX3Mnm8pJ93PzzmqD180767Y3zWVdZ53KwQyrN5whS0vRkxkUjkyl7KcCLCboHq6hcjXt1F197UrrVnejfzPdFescI1f0/0qK3maouX7GRiDVbd2KXFL7Gj9fodn1763Q/LlZxkdS2TuX1WGbNz5itWJEXm49aloXSq+7UrPr31uh+XOzLY2OwLN3KjU66q4u61bsBznZlrr/zdL978kwF4PlThzWPXiiWYjhk2/rSsntA4Dc7Iq/adUMubUcb3KyLIznr6i9ke1hyBMpTJx5lc3Lm7B7W/UPBxHidpPOvDvcXXfdpe9wqvjXvLnuKWHp6elVnnR7o4pbTL28qj4hyNPTs8otqC4uhicetVr3hbawsNCk97uxYxDAysqq2tcrPsOY9HTd05Rq+l3HjRvHhx9+yNGjR7nvvvtwcXHhwQcf1N+Ga8zkyZM5fvw4x48fxxK10WViI6zxa1E1m29wIXGXar7KExthjWfTYtQ2hrfc+QYXUlykIjHGSr+clXXlXCE3LgcQe8l4trpQcv7YWCf8/KrOjefrl01c3O19OMrlSy6Ym2vx9DTtUfZKrrvS85v5m6M1MjeeNtbwllhjVLX8/MYRd+btrFB/5op6qyvqj11Rf+Kqm0dPDWbBliZlj71kjZ+RuW98g26h7tY31T2oou6mbw91oeRtRreuNX7BVeft8Q0uJO5yLfkv2RivfXCB1P5fnF3p+WMv2Rjd5v2CCuqwzVvjYWSb95Pjzb86u9Lzx0Xa4ReYWzV7s1zioqp/0j1AbKQdHj4FqK0NO5V8m+VSUqwiMc62fLmqc/LdyNT5vZTcPgCIvWSLX3DVC+S+zWufzy7usg0eTYqq1j6ogJIiVZVRd33vT+XZ12P4+iNPPv/Ap/7hhagH6cwT1XJzcyMhofqnelZ0ziUnJ1f5WXJycpXOu9r81e9XV25uuuHoNf2uKpWKKVOm8Mcff5CWlsbmzZv5448/ePTRR+v12WG7HWnZMR9P38qRex5Niml9dx5hu2vuUArb44illZYewzL1r5mZa+k1IpMTBx0oKdbt3sd+daCkWEWfBw2f5tRv1HWiL1qTEm/6SVbJ+Y+GeRMSko6nZ2XDy90jj1at0ggLMz4a9a/Spu01NBpISqq5UVYdJddd6fnN71WjuVCCJrGyQ0+TVIbmbAlm99b8nub3qMEKyo4ZjtQt+0P3hcKshWFnn0qlwqyJBWZ+FlCopeyHAswH2qCyMa2xrqt73k11L9LVfU/Vh8EYrFtR9+GZ+teM1f12UfI2o8vvbLz2nXMJ211b7Z3K81fmMjPX0mv4dan9vzi70vOH7XUipEPVbb5V51zC9jjXuO7Rvc5Gt/mew65z4jdH2eb/pdmVnj9sf2NC2mTj6VPZqeTuXUCr9lmEHWhc47pHD7hhaaml+4CUG7Jr6HFfCieOuFJaossefsaRjFQrOnUzHODQ6V7dwIRL50y7GK3k9gHA0X3OhLTPxbNpZYeku08RrTrlEra3UQ1rwtF9jXT5h1TW1MxcS8+h6Zw45GSQv9vADKYvjeLnLxqz7i2/v/4XUSgtoNGq/rX//slkzjxRrYEDB7J9+3aSkpKMjpZr0aIFHh4efP755/znP//Rv3748GFiY2OZMWPGLX3eX/1+ddWtWzfs7e1Zu3ZtlVt0jWnUqBGPPvooR48eZc2aNfX67J1bXRgxMY0FG2PYvNQTrRbGz0wmNdGKH7e46pdz9ylm05GLbF3lwdZVuklWI8/Zsv9bZ6YuTMTCUktynBXDxqXj2bSYJc/56tfNSrdk+1o3HnvuGgW55lw5a0OvEZm0uzeXBRMC7tj8P/0UyPARV5g3/xAfb26DFhg37iypqbbs3BlYmd09jw0bf+TTra359IaHVrRpcw0npyIaNdI1HIKCMigs0B1SDx1qCsDdXRIZOCCao0e9uXbNFhvbUu7unMSgwVH8tDOQjAzTnn6l5LorPb/5MFtKdxRQ/GoWlpPsQAUl6/NQuZtjMbzy76lJLqPoiTQsxtlhOUHXaatyMsNitB2lH+dRYqvCrKMVmohSSjfnYj7IGrMmlafkkrU5uhF4TmZoE0op/TwfzMFysmkdwAA7t7oyYkIaCzZEs3mpl67us5KM1/3wBbau8mTr2+V1P19e9wUJWFhoSY63Yti4tPK6GzZog9rm49G0GDMz3S1MfsFFdB+aCcCxfY5VnnhXt+zK3WYAdn7qyoiJqSzYEMnmpd7l+ctr/0nl/EbuPkVs+v08W9/2YuvbuvOurvaNmLrg6g35y2v/vGGuoLZ5utqXtz39ggrpPlT3hfXYPqc7rvZKzq70/D996saI8anMX3eFzct0o1fGzUgkNcmKnVsNt/mNv51j6ztefPqO7kJa5Hlb9n/XiCnz4/XHm6FjU/FsWsTSF41s802KUZUfb3yDCuk+pHyb/0W2eSVlV3r+Xdt9GP5YPPPeOc3H7wei1aoY+2wkqSnW/LStcgSXu1cB6384zKdrA/hsTTMAosIdObDLg8mzLum2+QQbhj5yFU+fQpb99y79upoyMza+05wZb17guTkX+X2fO95N8xn3fCSnjzXi9B81d1xVR8ntA4CfPndn+NgU5q29xMcrmqDVqhg3/aruePNZ5W2w7t5FbNh/ik/f8+HT93R3ZEVesOPA9y5MnhuLuYWWlKtqho5O0R1vpjXXr3vX3dnMfucKURdt2fN1Y0LaV97SXFJsRuSFmkdfCnE7SGfeHe7UqVOkpaVVeb1z584sXLiQnTt30q1bN1599VWaN29OQkICu3bt4pNPPsHc3JzXX3+dKVOmMGbMGMaMGUNCQgKvvfYaQUFBPPnkk7eU5a9+v7pycHDgrbfe4vnnn2fUqFGMHj0aBwcHTp06hbW1Nc8//zyTJ0/GwcGBrl274u7uzqVLl9iyZQsDBw6s12cXFZgz65FApi5IZOa7cahUcOqQPavn+VCYXznHhEoF5haguukct2JaUybMTmL8rGTsHcuIumDDa6ObceWs4ePZNy32oiDPnPsnpdKocSlXI9UsmuLH0b31u51UyfmLiix4ZXZvJk85xcyZYaCCU6c8WLOmA4WFN9zGqAJzc63+i0KFMWPP0bZtqv6/R4y4wogRVwAYPEg3YjMp0R6VmZZx48/i7FREbp4liYkOrFjehf37Tb+ip+S6Kz2/ykaF1apGlLyfQ/GibNCCWScrLJ9zQGV7Q1AtUHVKHizG24GNirJvCyj9Ih+VqxkWj9npXr+BNkND8fs5cF0Djcww767G8kl73VNzTaSre3OmLkhg5ruxlXWff3PdteV1Nwy/Yrpved2TKus+phlXzhnWfcTEVAY+UjnioefwTHqWX7Efd09LUq7e+qgHJW8zlfmDmLrgKjPfiSnP78DqBU2qyX9T7Wf4MWFWIuNnJuryX7ThtbHNq9Z+QioDH6kcXWBQ+9DWd1ztlZxd6fmLCsyZ/VgwU+bFM/PtaF323x1Ys7Cp0exmN2VfOcOfCbMSGPdygn6bnzMuqOo2Pz6VAQ+n6/+757Dr9Cwf0Te+212yzSsou9LzFxWY89+nOjF5ZgQvLzoPKjh91IU1y4L1F3t14cHcQouZyvA4v2peK8Y/H8nY5yKxdygl+pI9c59pT2S4YaZ933uj1ap4aGIMA0YmkpNlya8/erLpnebc/ITeW8mu1PZBRf5XxrRk8pxYZq6I1LXpDzux5g0/g/xUs92snBXI+JfjGTfjKvaOpURdtGXOhBAiz1e2zdp1y8ZKrSWoTT4rv7pgsH7KVSsm9OxgUnYh6kOl1WqrzuQt/vU2bdrExIkTq/15amoqbm5uREZGMmfOHPbs2UNubi4+Pj6MHDmSlStX6pf95JNPWLZsGeHh4djb2zNkyBCWLl1qMJrP39+f7t2788knnxh8jkqlYv78+SxYsKDe77d//3769OnDnj176N+/v/71CRMmsHfvXq5evWqw3K+//krv3r31y3311VcsW7aMM2fOYGlpScuWLZk7dy7Dhg1j8+bNbNy4kQsXLpCVlYW3tzf3338/CxcuxNGx9hO/o8qFe1T9al1O/PXM2lZ9YrNSaM6EN3SEO5LNAY+GjlAvBb2vNXQE0ym5SWJ2+yf5vq00VScAF6I2KgvljgvQllad/1SI2pg3rvmW2X+yMiMDOJTETH3759+7HcIKd5KlSa99QYWyC/ai9bvV9ysonWbObo4fP97QMYySzjwh/gbSmddwpDNP3CrpzGtASm6SSGeeuANJZ56400hnXsORzrx/JrsgL1r9izvztHP/uZ158gAMIYQQQgghhBBCCCEUQjrzhBBCCCGEEEIIIYRQCOnME0IIIYQQQgghhBBCIZQ70YUQQgghhBBCCCGEaDAaE5+krAT/5N9MRuYJIYQQQgghhBBCCKEQ0pknhBBCCCGEEEIIIYRCSGeeEEIIIYQQQgghhBAKIZ15QgghhBBCCCGEEEIohDwAQwghhBBCCCGEEELcEi2g1f6THxNRP//k30xG5gkhhBBCCCGEEEIIoRDSmSeEEEIIIYQQQgghhEJIZ54QQgghhBBCCCGEEAohc+YJIYQQQgghhBBCiFukQvMvnjPvnzz67Z+cTQghhBBCCCGEEEIIcQPpzBNCCCGEEEIIIYQQQiGkM08IIYQQQgghhBBCCIWQOfOE+BuozM0xd3Rq6BgmKcvMaugI9aIqKWvoCHckiwC/ho5gssJ+CQ0doV4ubejY0BFMFvLsxYaOYDqNpqET1IvK3rmhI5iutLShE5jO3LyhE9RLWcb1ho4gFMjcWZltYgA0ym1XmqnVDR2hfswUOg5J9e+dT040LOnME0IIIYQQQgghhBC3TKtt6AR3JoV2bwshhBBCCCGEEEIIceeRzjwhhBBCCCGEEEIIIRRCOvOEEEIIIYQQQgghhFAImTNPCCGEEEIIIYQQQtwyrVYe8tEQZGSeEEIIIYQQQgghhBAKIZ15QgghhBBCCCGEEEIohHTmCSGEEEIIIYQQQgihEDJnnhBCCCGEEEIIIYS4JVqtzJnXUGRknhBCCCGEEEIIIYQQCiGdeUIIIYQQQgghhBBCKIR05gkhhBBCCCGEEEIIoRDSmSeEEEIIIYQQQgghhELIAzCEEEIIIYQQQgghxC3TyAMwGoSMzBNCCCGEEEIIIYQQQiGkM08IIYQQQgghhBBCCIWQ22yFaGBunoVMnh1Fh27XUang5BFn1i4OJDXJutZ1La00jH0hhr7Dr2HnUEpUuB0bVwRw7k/natfpOfgar6wIJy3ZinF9Q+udv7F3MVMWJNKxZw6o4ORvDqye701qglXt+dUaxs9Kpu+D17F3LCPyvA3rF3lx7qi9wXIqlZZHnr3GkLHpuDQu5Wqkmq2rPDi007le2d0a5zP5mdN06Jiiq/0Jd9Z+0J7Ua7a1rjv+P2cJCr5O8+BMHB2LWbm0M3t/9q+yXL+BMYR2TSKoxXXcPfLZ87Mfq5beXa/coOy6A7i5F/DUC+focHcqKhWcOu7G2nfuIjWl9tpbWpUx9qlw+gy8ip1DCVGXndj4QSvOn3Y1WM7RqYiJz1zgnntTsLYtJeaKI5+sC+HEH+71y+5VzJT58XTsng0qOHXIkdULm5KaWMfaz0ik74Pp2DmWEXXelvVv+XDuDweD5R6clELbbjkEt83Dxb2UT1Z58ckq73rlBrBIL6bx5/HYns8GLeS3ciT1iaaUutaePXjin0Zfj13YkiLfyr9bwMtnsUwvrrJcwvOB5HV0Njk7gJtXEVNei6HDvVm6ffZ3J9a86U9qkrrWdS2tNIybFkffkWnYOZYSddGODUv9OHfMUb+MjV0ZL70VSfPWubg0LqG0VEVCtDXffuzFr982rn/2ObF06J6NCi0nDzux5g0/UhPrmH36VfreX579gh0bljStmn1xFM1b5+HifkP2TZ78+q1b/bJ7FDJ51mU6hGbo6h7mwtqlQaQm1+U8VcbY56LpOzRZd56KsGfj24Gc+7ORwXIbfzqMh09hlfXfeLENR341vfZKP8fqan+FDl0rat+ItUtusfbDUiprvyqwSv6Nu45UU/u7OPKL6bXXnacS6NjjxvOUT92PlTOTKs9TF2xYv8i7ynnqwcnXaNctl6C2+bh6lLJlhQefrPQyObNhdmWeY5WcHZS9zyp5f73d5yifgAKGjUmhXddsPJsWUZBnzqUzdny8sgnR4XYm5zbIr9D2gRCmUmm1Wm1DhxB/jU2bNjFx4kSjP3NyciIzM/O2fK6/vz+9e/dm06ZNt+X9/woTJkxg//79xMTENMjnO1k0pqvjyCqvq63LeH/Hn5QUm7HlXX+0Whj3Qgxqaw3PPNCJogLzGt935tKL3N0zg/XLm5F81ZphjyfSucd1ZjzRnqhw+yrL2zmUsubHY6BVoSmjTo2Wssysan+mttHw4Z4ISorN2LTUE7QwflYyahsNU/sF15p/9vuxdOmXzbo3vEmKs2L4hHTu7pPNSyOCiDpvo19uwuwkRk1NZfMSTy6fsaXXyOsMHp3BvHEBHPvFsYZPAPOWQcazq0t5f+1eSkrM2LKxNVqtinETz6G2LuOZpwZQVFjztY6vvv+GqEgnkpPs6T8wttrOvEVLD+LoVMSVS43o3vMqh3/3qXNnXtnFy8azK6DuFgF+1f5MrS7lvc0HdLVfGwJaGDs5HLV1Gc+O611r7V+e/yd3d01hw/+1JjnRlmGjoukUeo2Xp/Qg6rKT7vMty3h73UEcnYv5eE1LrmeoGTgsjtAeycx5qStnT1bfuVEWn1B9dmsNH/x8gZJiFZuX+aDVwviZCahtNDw9sFWttZ/1TjRd+max7n8+JMepGT4ulc59sph2fwhRFyo7xNbuO09+rhlXztkybGzaLXXmRXzUzujrqiINfvMuoLVUkfagDwBu2xNQFWuIfaMVWnXN2YMn/klWd1eyehvWrqiJLVp15UD/gJfPUuxlTfr9hl+oiz2t0djV/LcNefZitT9TW5fxfz+coaRYxccrfdEC46bFYW2j4emh7Wqv/YrL3N3nOuuX+JEcZ82wMcl07nWd6Q+3Ieqi7ouEg3MJT8+L5tQRJ65dtcbSSkPPoen0fzCVNYv8+GZjDX8Djabm7DvPUlJkxscrm+iO9TOuYm2t4ekhbWrPvuoKd/fJZP1bviTHqxk2NoXOvTKZPqq1YfYFsZw67Mi1q2osrbS67KPSWPOmL99sqLmDQ2Vv/MuU2rqM97f9odtf32umy/58lO5Y+dA9tZ+n3jrP3T3SWb8qkOSrNgx7NIHO3dOZMbYTURGVndgbfzpMfIwtWz8MMFg/IdqW3BzLGj+D0tLqs//Dz7GYV59BbV3G+18d0+V/P6C89tG62o/qUnv+xRd0tV8ZqMv/WAKdu2cwY0xHw9rvOkJ8tC1bP/Q3WD8hxpbc7JprX5ZxvZrsGj7cG05JUcV5SsX4WUm681T/FrWfp96LpUu/LNa96aM7T41P052nRgYRdb7yWPnR/ovk55hz5ZwNw8al31pnXjVfgZRwjq2OUrKbOzsZz6/gfVYJ+6s2L7/a7Lf7HDV8bDKDH7/G3q8bc+W8LfaOZTw0OYlmrfJ4+ZHWXDlXhw49M+M3Ff7T2wdhBT+SVZZW+++nUDbNvQlYPrmhY9w2tm/+wPHjxxs6hlEyMu9faNu2bTRp0sTgNQuL2/en3rFjB46OpjU6/i5z587lxRdfbOgYVQx6KBnPJoVMHno3SXG6RlJ0hB3rfjrGkEeS2LG5SbXrBrTIpc+wVFa9FsyeHZ4AnD3mzOrvjjPmuRhef+6uKus8OSOK6HB7MlKt6NDVeAP8Vgx+Ih1Pv2Im9QghMUZ35SvqgjUbfw9n6NgMtq+t/kpVs1YF9H0wkxXTmrL7CxcAzhyxZ+3+CMbNTGbBBN0XOifXEkZNTeXL/3Pnq9W6EVWnD9vj7V/Mk68mmdzgHTQ0Gk+vXCZPGERSoq6BFx3lxLqPdzFkWBQ7vgqucf2HR4xEq1Xh5Z1L/4Gx1S43Z3YPtOWTwna6O8WkrDdTct0B7hsRh6d3HlMe70tSQnntIx356PNfGDwylm++CKx23YDmWfQZmMCqRe3Zu9MXgLOnXPnwk18ZMymc12ffA0CPPokENM/hlee66Tvu/gxz5/3N+5n4zAWmP9XTpOyDnkjF07eISb1bkxSru9IeHW7DhgPnGDo6je3rPKrP3jKfvg9ksGKGH3u26TKdCXNg7d7zjJuRyIL/NNcvO6V/K7RaFWbmWoaN/WsagE4HUrFMLSLmrdaUeOiyFzW1IeCVczjtTyPzvuqzVyh1tqQwsOoXopuV2VvUablbMejRa3g2LeSpge1Jii0/Xobbsn7vSYY8nsKODdU3pANC8ugzMo2VswPZ87Vuez7zhyNrfjrF2JfiWTglBICcTEuWTjfc948daIRPQAEDH7pWc2deTdkfS8WzaRFP9W93w3Zjy/pfTjPkiWvsWF9954MuezorZzVjz1e6ffvMUUfW/HyGsdOusnByi8rsLzU3WPfYfmd8AgoZ+HBqrZ151WYflYhnkwImjwglKV7XiRJ92Z5134cx5KEEdmzxrT57cA59hqawam4Ie77V1e7scWdW7/iDMc9G8/oLbQ2Wz75uScQZ41/yTcqu8HOsvvbD76ms/SV71v1wlCEPJ7Dj45pqn1tZ+290f/saa5/519Z+8Oh0PH2LmdSzZeV56qI1Gw9dZOjYdLavrX6EtO48dV13nvpSN+L6zBF71v4azriXk1kwsZl+2cl9QiqPlePS/5rsCj7HKjk7KHufVfL++necow784Mr3WzyAygclnDriyKaDpxg5IZkVL1ff9qs1v4LbB0LUh8yZ9y/Uvn17QkNDDf517tz5tn1ehw4dCAw0/QB8OxUVFQEQGBhIhw4dGjhNVff0TSfitKO+wQKQkmDDhZNOhPatuVEa2iedkhIVB3+qbJhpylQc+Kkxnbpfx8LScJRIqw5Z9Bl+jQ/ebH7zW5ksdGA24Sds9Q1GgJR4NeeP2dH1vupH9FWsW1Ks4sB3zob5v3WmU68cLK10+Tv3zsFKrWXf14a3ZP2yvRHNWhXi0bTIpOz3dE0k4qKrviMPICXZjgvnXAntlljr+to6PrWprsvdCiXXHeCe7slEnG+k78gDSEmy48JZF0J7JNe6bkmJit/2VTaaNGVmHNzrQ8cuqVhYlgHQ4q7rFBaa3zQCT8XJP9xp0SoTV7cCk7KHDsgi/KSdvrEL5bU/bk/owMwa1+06IIuSYhUHv3e5IbuK/d+70LFntr72cHu2G/tTWRQG2uk78gBKG6spCLLH/mTN2f8JQvtlEH7KQd9QB0i5as2FEw507Z9Ry7rXdbX/sfJWbE2ZigM/utGpR6ZB7Y3Jvm6Bpsz0v0lo/+uEn7Q33G6uWnPhTwe69q/5C2Ro/0xd9h8Mt5sDP7jSqUdW7dkzLdCUmp79nt5pRJxx0n85hfLz1CknQvvU3NEc2jtNd576ubKjWFNmxoFd7nTqll7lPPVXU/o5Vld7RyO1d6y99n3Ka7+rstNMV3sPOt2bcdtrHzowi/ATdsbPUwNrO09llZ+nKs8/xs5TIOfYf1N2UPY+q+j99W84R2Vft+TGjjyA/BwLEqKtcfOsOjXHLeVXcPtAiPqQzrw7zKZNm1CpVISFhTF69GgcHR3x9vbmhRdeoLDQcP6FqKgohgwZgq2tLe7u7syYMYO1a9eiUqkMblf19/dnwoQJJn1Gfn4+s2fPJiAgACsrKwICAli0aBGam25XSk1NZerUqfj4+KBWqwkJCWHt2rVGf7eDBw/y8MMP4+zszD336EbpTJgwAX9/f/2yMTExqFQq1qxZw7x58/Dy8sLZ2Znhw4dz9erVKhmffvppXF1dsbe354EHHuDw4cOoVKp631rs2zyPmCtV5wiLvWKLb6DxofCV6+aTctWaokLDoeNxV+ywtNLi7VfZWWFuoeH5hZf5emMTgwZSffm1KCQmvOo8ILER1vgGV53P4+Z1k+OtKCowPAzFRlhjpdbi7V+sX664UEVitFWV5QD8gk1rNPr6ZxMTU/XqcWyMI75+2Sa9599FyXUH8AvIITaqau3joh3w9c+pcV3fgBxSkmwpKjIcbRwb7YCllQbvJnmAriFWZqQDo6RE93v7Nav5c6rNHlRAbETVfSj2kg2+QTXX3je4gJR4K4oKb6r9pYram17TurBKKKDIp2r2Ym8brBJqzl7B+ddUmj91guZTTtBkySVsLhmvo93pTJpPOUHzp07Q9I1w7E5k1ic6AL5BBcReMlL7y7b4Nq+5c9YvKJ+Uq+oqx8vYyzZYWmnx8rv599diZq7FwbmEwY+m0KlHVo1X9uuW3cix/rKN6dkv2WCpriX7Y9fKs3uanj0wj5grVW9/io20w7dZXq3rpiTYVH+e8jU8z93TK43tR/fz7fFfWfnJcbr2STU5Nyj/HOvbPJ+YK1VHuMZescO3WS35A/OM54+sqL3hdndPrzS2/3GAb//cz8pP/qRr3/rV3i+4kJgII+epS3U4TwWXn6ca6Fip5HOskrODsvdZJe+vf+85qpK9Uyn+wQXEXanf30DJ7QMh6kNus/0XKisro/Sm+WPMzMwwu2GegbFjx/L444+zfft2jhw5woIFC2jUqBELFy4EoLi4mAEDBlBUVMSHH35I48aNWbduHV999VWdc9T2GaWlpdx3331cuHCBuXPn0qZNG8LCwnjjjTfIyMhgxYoVAGRnZ9O9e3cKCgpYsGABAQEB/Pzzzzz99NMUFRXx/PPPG3zu6NGjefzxx/nqq6+q1OFmb731Ft26dWPDhg1cu3aNGTNmMGbMGPbv369fZvLkyWzbto0FCxbQuXNn9u3bx+jRo+tch5o4OJWSm1V1fovcLAvsHUtqWbeE3Oyqu3BOloX+vSs8/J94LK00fLm2+iH+pnBwLiM3q+o8FDmZ5jg4ldWybim5mcbXrfi5/jOyzbn5at7Ny90qB4dicnOqTgadm2OFvUPNtW9oSq47gL1jsdE5sHKyLWutvYNjifG/W7aV/ucACXH22NmX0tQvh/jYyrlmQu66Xr6caVeBHZzLyDFS+9xMc4N9zvi6pfr903Bd3Wv29ahpXZjnlaGxq5q9zM4c8/zaPzu7qwu57Zwoa2SJRVoxLrtSaLL0EldfDqYgpLLGue2dKAywo7SxFeZZpTjvu4bPe5EkPeVPTjfXGj6hZg5OpcaPeZkW2DvWXvvq1q147xsNH5vMM/NjACgpVrH6TX/2fWP6BNe67Mb2Owvs67DdGN3fK471zjdnT+GZhbpb/0uKVax+w499O+qT3fi5RneeqiV7tecpy/KfV65/9IAbl847kJJgg7NrMcMfu8rcd86y7L+t+PVH0zojFX+Ora722ZZ1rL2R46w+f+Xvf/SAK5fOOZKSYK2r/eMJzH3nHMv+25JffzCx9s5l1ZxrLOpwnqruHGeh//ntpORzrJKzg7L3WUXvr3/jOepGzyyIARV8s9H0C06g7PbBv8XtGCUtaiedef9CISEhVV4bOnQoP/zwg/6/n3jiCX2nWv/+/Tl69CifffaZ/rVNmzYRFRXF0aNH6dKlCwCDBw+mffv2xMXF1SlHbZ/x2WefcejQIQ4cOEDPnrr5q/r16wfAwoULmT17Nu7u7rzzzjvExsZy9uxZgoKC9O+XmZnJwoULefrppw3mBHzooYdYunRpnTL6+/vz6aef6v87NTWVmTNnkpiYiLe3NxEREXz66acsXryYWbNmATBgwADy8/N577336vQZDc3Lt4BHp8Tz5gutKCmWwbjizrB/TxNG/yeCaXNO8s5b7bmermbQyFjuaqe7TUcjjY5bljz5hgcTBENuB2f8517AbXsC8a9WnndSxxh+Ocrt5IzvG+G4fZVQr868v9PBH90IP+mAo0sJof2u8/S8aDRlKn76vPZ5BRvawR9dCT9lj2OjUkL7X+fp+TFoyuCnz/7Z2VcvNpyL6Mi+xqz85DgTXow0uTPv7/BvOMeufstI7bf+yYQXo0zuHBDin0rp++y/ZX995OkE+oxMZ9XsAIPbe//plNw+ELdPfHw806ZNY8+ePWi1Wvr378/bb7+Nr2/dLhhcvHiRefPm8euvv5KXl4evry/PPPNMrXP+K+8IJmq1Y8cOjh07ZvDv7bffNlhm6NChBv/dpk0bg066sLAwfH199R15ACqVilGjRtU5R22fsWvXLvz8/OjWrRulpaX6fwMHDqSkpISwsDD9cvfccw8BAQEGy913332kp6dz4cIFg8954IEH6pxxyJAhVTIC+pxHjx5Fq9Xy8MMPGyz30EMP1frea9eupXPnznTu3JlirfEh3rlZFtg7Vb3SaO9UWusTqaq70ldxBaniitjUV69w+qgz4acdsXMoxc6hFEtLDah0T/GyUpt+hTs3yxx7I1d6qxu9VGVdI1fXK664V1wRy80yx96xDNDWuNytys21wt6h6ugsewfjo8b+SZRcd4DcHOMj8HSj7mrZ7nMsjf/dykfa5ZTvN3m5lix67W6cnIr5YMt+Ptv5MwOGxrF1g24i5ow00xqOuVnGRzfYO5cZHXVnuK6F0dF7FSPycutR07ooszPHLK9qdvO8Mspsb/2ztTbm5LV1Qh1d8+1DmKnIubsRltdLMM80fdRrbrbxK+zVXVW/UU41o8gqRgzc/LfLyrDk8jl7/jzYiP+b34xfvmnMpFdiMLcwbd6i3OyK/clI9lq2m5wsC+P7e8WxPtNI9rP2/HnQmf+bF8AvO9yY9N+4emQ3Xjv7akZCGK5b3XlKtx3UtM9oNCoO7XGnsWcRjdxMu21P8efY6mrvaHwEUNX8Ro6z+vzV//4ajYpDuxvXs/bVnWtK63aeMnqOq9jma16/vpR8jlVydt17K3efVfT++jeeowCGPJHCxJlX2by8Cbu3Vf8wnLpScvtAKF9+fj59+/YlPDyczZs3s2XLFi5fvkyfPn3Iy6t5OhKA48ePc88991BUVMS6devYuXMnM2bMoKys9mORjMz7F7rrrrto3rzmyVxdXFwM/lutVusfFgGQlJSEu3vVg6uHR92vOtT2GdeuXSM2NhZLS+MnqPT0dP1yV65cqXW5Cl5edX9in7GMgH5uv6SkJIAqtahLHSZPnszkybrHdDtZGB9+HXfFFj8jc4D4BuYTF1l17oobxV6xpWv/NNTWZQbzPPgG5lFSrCKxfBJY38B8PHyK2Hb0cJX32Hb0MN987MPaxaY9wCQ2whq/FlXnwvANLiTuUs2dJbER1nQblI3aRmMwP4tvcCHFRSoSY6z0y1lZ6+ZquXFC54q5X2IvqTFFXIwjfkbmxvP1yyYu9p/9dGYl1x0gLtoR34Cqc6019c8hLsbByBo3rutA155JqNWlBvPm+frnUFJsRuLVyrm9zp925T+P9MO7SR5mZloS4u0Z9cQVCgvNuRJh2lPgYi/Z4BdctXPeL6iAuMu11P6SNd3uy0RtrTGYC8ovqKL2pte0Loq9bVAnVs1ulVhAsc/fdFW8HgMiYy/b4BdUNb9v89rn24m7bEO3ARlVj5fNCygpVtU6KuDyOTsGjEqlkVsJacm3/neKvWSLX7CRY31dsw+8XjV7UAElRXXIftaOAQ+lmZw9LtIOv8CqjVHfZnnERVWdS+9GsZF2dO2XWv15Kq7m85yetvZFjFH6OTbuSjW1D8wnLqqW/JG2xmvfrKL2dZyjysTax16yxs/IHG2+QXU9T2VVOVb6/k3HSiWfY5WcHZS9zyp7f/37zlF970/l2ddj+PojTz7/wMe0wDfnV3D7QCjfRx99RFRUFBEREfo+mLZt2xIUFMSaNWuYPn16tetqNBrGjRtHv3792LFjh/71Pn361OmzZWSeMMrLy4tr165VeT0lJeUv+wxXV1cCAgKqjCKs+Dd8+HD9ct26dat2uZuf1KtS/XW3z1V0DN5ci7+qDmG/uhLSLhvPJpUnIHfvQlp1yCbs15pvRzu63xVLSy3d76uc9NbMXEuPQamc+L0RpeUT/S+e0ZLZ49sa/Dv+WyOyMiyZPb4t339q+qStYbsdadkxH0/fyk5ajybFtL47j7DdNXeIhe1xxNJKS49hmQb5e43I5MRBB/2tD8d+daCkWEWfBw2fptVv1HWiL1qTEm/aiTPssDchrTLw9MrVv+bukUeru9IJO/LPnshWyXUHOHrIg5DW1/H0rmz0unvm06ptBkcP1dxRfvSQp26771v5xGEzcw09+yVy4o/GlJbcPPJAReJVe67GOaC2LuO+EbH8uqsJRYWmXcsK2+tESIe8m2pfRKvOuYTtca45+17n8tpX1tTMXEvPYdc58Zvjbb/dJ7eDE9aReVheq8xukVaEzZVc8to73/L7mRWUYXc6k8JmNXfoUKbF4Y/rlLhaUeZk+qjXo/tcCGmfg2fTyi+q7j6FtOqYQ9g+lxrWhKO/uOhqP7jy4o+ZuZaeQ9I5cci51tq36ZJNfq4Zmemm5T+6z5mQ9rk3ZS+iVadcwvY2qmFNOLqvkS77kMon8pmZa+k5NJ0Th5xqz35PTr2yh+1vTEjbbDx9bjxPFdCqfRZh+91qWFM3D56lpZbuAyvPoWbmGnrcd40TR1z05yljKpa7lqjmerqJx3mln2P3u+lq38RI7X+tpfb7q6n9oGucOFyH2g+qZ+13O9KyY9VjZeu78wjbU/PFFP15anjmDZmqnqduFyWfY5WcHZS9zyp5f/27zlHdBmYwfWkUP3/RmHVv+ZmU1XgG5bYPhPJ99913hIaGGgymCggI4N577+Xbb7+tcd39+/dz8eLFGjv8aiIj84RRoaGhbNy4kT/++EN/q61Wq+Xrr7/+yz5j0KBBfP3119jb2xud5+/G5d577z18fX2Njha8nbp06YJKpWLbtm36OfMAtm3b9pe8/66vvBg+OpF575/n43f90WpVjH0+htRkNT99WTnC0N27kPW7/uDTD/347EPdyS/qoj0HdjZm8itRWFhoSU6wZuijSXg2KWTZrMp6Rpyp2njrf38KJcUqzh5zrlf+nVtdGDExjQUbY9i81BOtFsbPTCY10Yoft1Q2utx9itl05CJbV3mwdZVuPo/Ic7bs/9aZqQsTsbDUkhxnxbBx6Xg2LWbJc5XzC2SlW7J9rRuPPXeNglxzrpy1odeITNrdm8uCCQFVMtXVrp0BDL//CvNeP8zHG+9Cq4WxE8+Tes2Wn75vVpndPY/1n+zi0y0t+WxLK/3rd7VNxcm5iEaNdA2HoODrFBToDqm/H2yiX66pX7b+6bhW6jLcPfK5t6fuiclnTzcmO+vWG15KrjvAru/8GDYqmrmL/2DL2hC0qBgzKZy0FBt++tZfv1xjj3zWf7mPzzYF89lG3e2xUZedOLDXm8kvnMfcQktKoi1DHojBwyufZQs7GnzO+KkXuBLuTHaWFV5N8hj1xBXKSs3YtLqlydl/+tSNEeNTmb/uCpuX6a4oj5uRSGqSFTu3VjbW3X2K2PjbOba+48Wn7+i+GESet2X/d42YMj9et8/GWzF0bCqeTYtY+qJhTYPa5uHRpBiVme4yu29QId2H6L44HfvFqcpTHusiq5cbzvtS8X73CmkP+oAK3HYkUuJiRWbvyuwWaUUEzD5H+ggvMkbqsjf6KRmr5CLyQxwobWSJZVoxjXYlY5FVSvKUyuwOYRnYncwkr60TpS5WWGSX4LQvFevYfJKm1m+7+ekLd4aPTWLe6nA+XuWLVgvjXorX1f6G+eDcvYvY8MsJPn2/CZ++3xSAyAt2HPjBlclzYjC31JISb83Q0cl4Ni1k6YzKxtfgx1IIaZ/DqcNOpCVb4eBcSs8h6fQYnMGGpb41fqGqMfvn7gwfm8K8tZf4eEUTtFoV46ZfLc9eeV5z9y5iw/5TfPqeD5++16Qy+/cuTJ4bq9vmr6oZOjpFt91MuyH74ymEdMjl1O9OpCVZ4dCoPPuQDDYsaWpy9l1fezP8savMe/cMH7/XDC0w9tloUlPU/LSt8kuvu1cB638M49M1/ny2Rve3jgp34MBP7kyedbnyPPVIAp4+hSz7b2v9ur0GJxPaO41jh1xJS9ZN6j7ssasEtcph8azWN0eqe3aFn2N3fe3N8McTmPfuWT5+L0CX/7koI7UvZP3OMD5d48dnq2+q/ewrN9Q+UVf7VyrPZb0GpxDaJ41jv7mSlqwur30CQa1yWTyzVZVMdbVzqysjJqSxYEM0m5d66c5Ts5KMn6cOX2DrKk+2vl1+njpffp5akKA/Vg4bl1Z+njLsAAhqm49H02LMyo+VfsFFdB+aCcCxfY4mHSuVfI5VcnZQ9j6r5P317zhH3XV3NrPfuULURVv2fN2YkPaVd2iUFJsReaGWC4M15Vdw++DfQIvqjn4Axvnz5xk5cmSV11u3bl1rn8GhQ4cA3V2BoaGh/PnnnzRq1IjHHnuMJUuWYGNT88hS6cz7Fzp16hRpaWlVXr95BFtNJkyYwJIlS3jwwQdZtGiR/mm216/rvkze+GRcU40ePZqNGzfSr18/ZsyYQbt27SguLiYyMpLvvvuOb775BltbW6ZNm8YXX3xBjx49mDZtGi1atCAvL4/w8HB+++23Wnu86yMkJIQnnniCuXPnotFo6NSpE7/88gvff/89UP86FBWY89+JbZk8O4qXF0eACk6HObPmrUAK8w1HGJlboG+sVlj1WjDjX4xh7Isx2DuUEh1hz9zJbYi8WPOtin+VogJzZj0SyNQFicx8Nw6VCk4dsmf1PB+D/CqVLr/qpnKtmNaUCbOTGD8rGXvHMqIu2PDa6GZcOWt4O8KmxV4U5Jlz/6RUGjUu5WqkmkVT/Di61/TbYYsKLfjvy72Y/PRpXn7lD13tT7qz5v/aUXjjqC0VmJtrMVMZ1n7M+PO0bV+5nw2/P5Lh90cCMKRf5ZyKPXvFM3r8Rf1/t2ufSrv2uqvGs6f35OzpW++gVnLdQVf7V1/oxlMvnGfGvJOg0nL6eGPWvnMXhQWVtdfl16K6qfZvL+rAuCkXGfdUOHb2JURfcWTejFAiLzkbLOfcqIjJL57DqVERWdfVHDnoxSfrWhh9Gm6dsxeYM/uxYKbMi2fm29G62v/uwJqFTY3W/uZDxMoZ/kyYlcC4lxN0tb9ow5xxQVw5Z1j7EeNTGfBw5VXinsOu07N8RN/4bneRcvXWO4G1anOuzgqm8WfxeH4UjQrIb+nAtSeaorU2PN6oNHBj2Yu9rLE/kYn9ieuYFZShsTanIMielCf9DUbmlTS2wiK7lMZfXsU8rxSNlTmFAbZcnd6c/Dam3dpcoajAnFfGtGbyazHMXH4F0HLqiBNr3vQ3PF6qtEa3+5WzAxk/I55x0+Kxdywl6qIdc55sSeR5e/0yMRG2dO2fwaRXYnFwLiUrw4L4SFvmTQrh2P6aRyfUnr0lk+fEMnNFJKjg1GEn1rzhd1N24/vsylmBjH85nnEzrpZnt2XOhBAiz1fWPibClq4DrjPpv3E4OJWSdd2C+Egb5v0nmGO/1i/7fyd1YPKsy7z8vwu6Y+XRRqxZGmSwv1K+v1Y5T81ryfjnoxj7XJTuPHXJnrlPtzM4TyWXP8H2P9Ov4OBYSmGBOZcvODBnajtOHDb9oSn/hnPsf//TnsmzrvDy/y5W1n5J85tqr9XV/qbvUqvmhjD+hSjGPh9dnt+OuVPb3lR7a5xdivnPjJtqP6VtvWs/65HmTF2QwMx3YyvPU/NvPk9V7K+GtV8x3bf8PJVUeZ4a06zqsXJiKgMfqRwh1nN4Jj3LR/SNu6elScdKJZ9jlZy9Ir9S91ml76+3+xzVrls2VmotQW3yWfmV4XznKVetmNCzQz3zK7N9IJQvIyODRo2qbgMuLi76vpPqJCbq7jR69NFHee6551i8eDHHjx9n3rx5xMfHG9x6a4xKq9WaeHe9+KfZtGkTEydOrPbnqamp/PDDD0ycOJHLly8bDAVdsGABCxcu5MbNITIykueff55ff/0Ve3t7nnjiCby9vXnllVfIzMzEyUn3xczf35/evXuzadMmgxx1+YzCwkIWL17M559/TnR0NHZ2dgQGBjJ06FDmzJmjf0rt9evXef311/nmm29ISEjA2dmZFi1aMGrUKF566aUaPxd0nZP79+8nJiYGgJiYGAICAvjoo4+YNGmSfrn9+/fTp08ffv31V3r37g3oJrWcMWMGX3zxBcXFxfTt25cpU6YwbNgwvvnmG6M98TdzsmhMV8fal/snKsvMaugI9WLeMqihI5is7OLlho5gMouAv+72ib9bWXxCQ0eol4iP2jV0BJOFPHux9oX+qTTKnvxaZW/6qIgGV1p18nLFML+9D3O43coyav6i8o8mX4EajLlz/S7uNCgF77PavFoeWPVP9xcMJmkIYQU/klVWdaDNv4V1cx/8l05p6Bi3TcG09TRuXDn//Y3z4gNYWVkxffp0Fi9ebLDenDlzWLx4MaU1tFEmT57MRx99xPPPP8+7776rf33JkiW88sorXLhwgZYtq7+jSDrzxC0ZNmwYFy9eJDIysqGjNKjly5cza9YsYmJi6vTIaenMazjSmdcwpDOv4UhnXgORzryGI515DUY684QppDOvYUhnXsOQzjxls//fdxw/frzan3t4eHD//fezZs0ag9efeeYZtm3bRmpqajVrwn//+18WL17Md999p39eAMDJkyfp2LEjW7du5Yknnqh2fbnNVlRr5cqV2NvbExQURE5ODtu2bePHH3/kww8/bOhof6sffviBc+fO0b59e8zMzPjtt99Yvnw5jzzySJ068oQQQgghhBBCiH+jO/nSSOvWrTl//nyV1y9cuECrVjXPZdm6dc3zAtc2pZcyu7fF30KtVrNq1SqGDRvGI488wpkzZ1i3bh1Tp05t6Gh/KwcHB7755hsee+wxhg4dypYtW3jhhRf0txULIYQQQgghhBDizjJixAjCwsKIiorSvxYTE8Pvv//OiBEjalx38ODBqNVqfv75Z4PXd+3aBdT+zAMZmSeq9eyzz/Lss882dIwG16tXL8LCwho6hhBCCCGEEEIIIf4hnnrqKd5//31GjhzJm2++iUqlYu7cuTRt2pQpUypvP46NjSUwMJB58+Yxb948AFxdXfnvf//LG2+8gaOjI3379uX48eO8/vrrjB8/vspzAG4mnXlCCCGEEEIIIYQQQtwCOzs7fvnlF6ZNm8bYsWPRarX069ePt99+G3v7yicia7VaysrK0Nw0x/K8efNwcHDggw8+YPny5Xh5eTFz5kzmzp1b62dLZ54QQgghhBBCCCGEuDVa0GpVDZ2iQfn6+vL111/XuIy/vz/Gnj2rUqmYPn0606dPv+XPlTnzhBBCCCGEEEIIIYRQCOnME0IIIYQQQgghhBBCIaQzTwghhBBCCCGEEEIIhZDOPCGEEEIIIYQQQgghFEIegCGEEEIIIYQQQgghbl3V5zqIXFuVfgABAABJREFUv4GMzBNCCCGEEEIIIYQQQiGkM08IIYQQQgghhBBCCIWQzjwhhBBCCCGEEEIIIRRC5swTQgghhBBCCCGEELdMq1U1dIQ7kozME0IIIYQQQgghhBBCIaQzTwghhBBCCCGEEEIIhZDbbIX4G2jLyijLzGroGHckzZXYho5gOjPzhk5gstJoBddd4VrOjGnoCCYL/zCkoSOYrOUriQ0doV401zMbOoLJNIWFDR1BiL+VqkPrho5QL5qzEQ0dwWTa0tKGjiAURqvVNHQE8S8lnXlCCCGEEEIIIYQQ4pZptQ2d4M4kt9kKIYQQQgghhBBCCKEQ0pknhBBCCCGEEEIIIYRCSGeeEEIIIYQQQgghhBAKIZ15QgghhBBCCCGEEEIohDwAQwghhBBCCCGEEELcEi2g1aoaOsYdSUbmCSGEEEIIIYQQQgihENKZJ4QQQgghhBBCCCGEQkhnnhBCCCGEEEIIIYQQCiFz5gkhhBBCCCGEEEKIW6MFZM68BiEj84QQQgghhBBCCCGEUAjpzBNCCCGEEEIIIYQQQiGkM08IIYQQQgghhBBCCIWQzjwhhBBCCCGEEEIIIRRCHoAhhBBCCCGEEEIIIW6ZVtvQCe5MMjJPCCGEEEIIIYQQQgiFkJF5QjSwxt7FTFmQSMeeOaCCk785sHq+N6kJVrWua6nWMH5WMn0fvI69YxmR521Yv8iLc0ftDZZTqbQ88uw1hoxNx6VxKVcj1Wxd5cGhnc53dH43ryKmzIunY/dsUGk59bsjqxf6kpqorlv2GQn0fSAdO8dSoi7Ysv6tppz7w0G/jE9AIcPHpdCuaw6evkUU5Jlz6bQdm1f4EH3Rtl7ZG3sVM2XBVTr2yNbV/ZADq+c3JTWxjnWfmUjfBzKwdyoj8rwt6//nzbmjDgbLPfhUCu265RDUNh9Xj1K2rPTkk5Xe9cqtz6/g7UbJ2d08Cpk86zIdQjNQqeBkmAtrlwaRmmxde3arMsY+F03focnYOZQSFWHPxrcDOfdnoyrLuroXMfbZKDr3SMfBsYT0VDUHf/Jg07uBJme3SC/G7dOr2J7PBi0UtHYgdXRTSl1rr3vQ+BNGX499PYRiP8N90TyjGNftSdidycIsr4wyZ0ty7mlE+iM+JmcHcPMo4KnpEXQITUeFllN/uLJ2RQipyTa1rmtpVcbYp6/QZ0gidvalRF1yYOO7wZw/6aJfpv/wBKYtOFfte4wZ2Jvr6bUf24xm9ypiypxYOnTPRoWWk4edWPOGX92OlVYaxk2/St/708qPlXZsWNKUc8cc9cvY2JXx0uIomrfOw8W9hNJSFQnR1ny7yZNfv3UzKXMFJe+vSs8v2RvoOO+Wx5SnTtCxQ7KubXPKk9VrO5GaalfruhPGnSIoKIOg5hk4OhazYlUoe/Y2q3Gdli1TWbF0D2ZmMGT4Y2g09Rsr4uZVzJT5FW0zOHXIkdULb6F9MyORvg+mY+dYRtR5W9a/5WPQNgN4cFIKbbvlENw2Dxf3Uj5Z5cUnq+rfvlHydqPk7P+G/EKYQqXVyqBIIW43R5UL96j6VXldbaPhwz0RlBSbsWmpJ2hh/Kxk1DYapvYLpqjAvMb3nf1+LF36ZbPuDW+S4qwYPiGdu/tk89KIIKLOV35BnDA7iVFTU9m8xJPLZ2zpNfI6g0dnMG9cAMd+cazhE2qmhPwqS+MncbV1GR/sOk9JsRmbl/ug1cL4lxNQ22h4+r7WtWaf9U4kXfpkse5/TUmOVzN8XAqde2cx7YFWRF3QdQ4MH5/CkMdT2fO1G1fO2WLvWMbDU5No1iqfGaNacuVczQ1rbVlZNdk1fLjnIiVFKjYt8y6veyJqaw1TB7Ssve7vRdOlbzbrFvmQFGvF8Amp5XVvoc8O8NGv58nPNefKWVuGjUu7tc48jfHsoIztRsnZzd1cjWe3LuP9bX9QUmLGlveaodXCuOejUFuX8cxD99SafeZb57m7RzrrVwWSfNWGYY8m0Ll7OjPGdiIqovKLkrt3Acs3/0lKgg3ffdqE6+lWePgU4t20gC3/V/OXwvAVfkZfVxVp8J17Ea2FivRR3qAC168TURVpiFvUEq265uxB40+Q3d2FrD6NDV4vamqDVl35xdMitYimb16ipLEVmQPcKXOywCKtGMuUIjJG1bztt3wlsdqfqa3LeO+zw5QUm7Hlw+agVTH2mcuorct49tFuFBXWfG315TfPcHf3VDa8E0zyVVuGPRJHp25pvDzxHqIu6bYHR+divJrkG6ynUsG8t0+QfNWG6eO71vgZmuuZ1Wb/v51nKSky4+OVTXTbzYyrWFtreHpIm9qPlauucHefTNa/5UtyvJphY1Po3CuT6aNaE3VRdwx0cC7h6QWxnDrsyLWraiyttPQcmk7/UWmsedOXbzZ41Zy9sNB4dgXsrzVRcn7JfpvbNh1aG8+uLuWD93ZSUmLO5i1t0aJi/NjTqNVlPP3sEIqKaj7WbN/2JVFRjUhKtmdA/+haO/PMzTW8/+5PODkW4eJSWPfOvLMRxvNba/jg5wuUFKvYvKy8bTazvG02sFUd2mbRdOmbxbr/+ZAcp2b4uFQ698li2v0hBu2btfvOk59rxpVztgwbm3ZLnXna0lLj2RWw3VRHydmVkP+odh/Z2gyTf79/OnUzH3wWPdvQMW4blxXbOX78eEPHMOpvHZm3adMmJk6caPRnTk5OZGZm3pbPnTBhAvv37ycmJua2vL9SZGZm8vbbbzNixAg6duxo0nv4+/vTu3dvNm3aVONyp06d4o033uDYsWOkpKTg4uJCSEgIDzzwAC+88EKdP69im4mOjsbf39+kzP9kg59Ix9OvmEk9QkiM0Y1wiLpgzcbfwxk6NoPtaxtXu26zVgX0fTCTFdOasvsL3eiMM0fsWbs/gnEzk1kwIQAAJ9cSRk1N5cv/c+er1e4AnD5sj7d/MU++mlSvk6eS8w96PBVP3yIm9WlDUqxuVFJ0uC0b9p9h6OhUtq/zrHbdgJb59L0/gxUv+7Nnm+53PBPmwNo95xg3PYEFk4IAOPCdC99vdgdU+nVPHXZg8+9nuP/JFJZPr7ljozqDR6fpsvdqRWKMLnvURRs2/naeoWPS2P6RR7XrNmuZT98HrrNiuh+7v3StzP7LBca9nMSCJytHTk3u2wqtVoWZuZZh49JMymo0v4K3GyVnHzQqEc8mBUweEUpSvO5LTfRle9Z9H8aQhxLYscW32nUDgnPoMzSFVXND2POt7gvP2ePOrN7xB2Oejeb1F9rql31ubgTp19S8MqkDZaW6L3Xn/jQpsp7TgTQsrxURu6QVJR66bb6oqQ3+s87j9GsamYOq3+YrlDayorB5zR3o7pvjKW1kydVXgsFCVeOyt+K+B67i6ZPPlAe7k3RVlyH6sj0f7TjE4FFX+Warf7XrBgRl02dwEqsW3MXe73WjA8+eaMSHX/7OmKlXeH267nyenWlFdqbhxYvW7a/j5FzC1tXNTc4+6LFUPJsW8VT/dgbHyvW/nGbIE9fYsb76jraAkDz6jExn5axm7Pmq/Fh51JE1P59h7LSrLJzcAoCcTEuWvmSY8dh+Z3wCChn4cGqtnXnVUfL+qvT8kr2BjvP3XcHTM49JU4aRlKS7yBId7cyGj75n6ODLbP+mZY3rj3rkYbRaFV5eOQzoH13r5z006iIq4Oc9gTz+6HmTMhvkf6K8bda79Q3HGxs2HDjH0NFpbF9X/bE+oGU+fR/IYMUMP/Zs043oPRPmwNq95xk3I5EF/6k8xkzpf0P7Zuxf075R8naj5Oz/hvz/CjI8rEE0yJx527Zt48iRIwb/9u7de9s+b+7cuezYseO2vb9SZGZmsnDhQk6cMH670V/l2LFjhIaGkpaWxtKlS/n5559ZtmwZLVq0uOW/w9ChQzly5AheXqY15P/pQgdmE37CVn/iAUiJV3P+mB1d78uqdd2SYhUHvnPWv6YpU3HgW2c69crB0koDQOfeOViptez72vBWuF+2N6JZq0I8mhbdkflDB2QSftJe31jUZz/uQOiAzBrX7Togk5JiFQe/r7zFTVOmYv/3LnTsmaXPnn3dkhs78gDycyxIiLLG1bPYpNy67FmEn7DTd+RVZrevQ92zyuteWU9Nme6/O/XK1mcH0Gr/us4MwwwK3m4UnP2e3mlEnHHSd+QBpCTYcOGUE6F9av4yE9o7jZISFQd/rvwipSkz48Audzp1S8fCUpfds0k+ne/N4PvPmug78v4KdiezKAy003fkAZQ2VlMQZI/diZrrXleWKUXYnc0mc0Djv7QjD+CenteIOOus78gDSEm05cJpZ0J7Xat53V6plJSo+G1P5QUGTZkZB3d70bFrmr72xvQbnqDb5n6u/uJEbUL7X696rLxqzYU/Heja/3ot65YfK38wPFYe+MGVTj2yDI43xmRnWqApNf1voeT9Ven5JXsDZb8ngfAIV31HHkBKij3nLzQmNDSh1vVv5bzv5ZnD44+e4/0P7qasHvvpjUIHZBF+0s5I28ye0IGZNa7bdUBWDW2z29++UfR2o+Ds/4b8QpiqQTrz2rdvT2hoqMG/zp0737bPCwwMpEOHDjUuU1JSgtxx/Nd47733cHZ2Zvfu3Tz22GP07t2bMWPGsHr1avbt23dL79W4cWNCQ0NRq02b5+efzq9FITHhVeeqio2wxjfY+G1DN66bHG9FUYHhbhwbYY2VWou3f7F+ueJCFYnRVlWWA/ALNv3ko+T8fkEFxEZUnasq9rI1vkEFNa7rG1RASryaokLDYfuxl2x02f2qz2TvVIp/iwLir9Q+T1Z1/IILiDGWPcIa36Ba6h5cXvfCm+tent3/9jdGFL3dKDi7b2AeMVeqjkyLjbTDt1lereumJNhU2ebjrthhaaXF21d3e2erDrpGc1GROYvWnOTb47/yxaGDzFh0AQenEpNyA1glFFDcpOo2X+xjjVVizXWv4PRLKoH/OUngUyfxWXwJ64hcg59bX9b9t9bKDJ+llwn8z0maPX0ajzUxmOUav62qrvya5RIbaV/l9bgoe3yb5RpZo5Jvs1yjtY+NstfVvmm+0fWs1GV075/CH781Jje79jmDqv38oAJiL1Wd4zP2sg2+zWs+VvoF5ZNy1fix0lKtxcvv5r+dFjNzLQ7OJQx+7BqdemSxY4PpHZFK3l+Vnl+yN1B2vyxiY52rZo9zwtf3r7nwUeH5547x2yFfzp13/8ves9q22SWbWts3vsEFpBhr31yy/lvaN4rebhSc/d+QXwhT/SOfZrtp0yZUKhVhYWGMHj0aR0dHvL29eeGFFygsnxelqKgIFxcXpk+fXmX9L7/8EpVKxcmTJwHdbbY33qIZExODSqXigw8+YNasWXh7e6NWq8nMzESr1bJq1SpatGiBlZUVXl5ePPfcc2RnZxt8hkqlYs6cObz77rsEBATg4OBAr169OH/ecIh579696d69O7t27aJ9+/bY2NjQoUMHjh49SmlpKa+++ipeXl64uLgwYcIE8vIMv1Dl5+cze/ZsAgICsLKyIiAggEWLFqHRVF5d2r9/PyqViu+++47nnnsONzc33NzcGDNmjP7W5ZiYGAICdMOEn3rqKVQqFSqVSn+77O7duxkyZAheXl78P3v3Hd9U9f9x/JXukS46aemkDBFkCIjI3lvFhQIFFAG3gAxltQ4EEXD/BGXJVL+AC1ARZVOG7FnoBDroHnSmze+PtCkh6SCllMjn+Xj0oST3Ju+enpxzc+6559rZ2dG8eXMWLlxIcQVrdlUmLS0NFxcXgwNwZma6Ve769etMnz6dhg0bYm1tjZeXF0888QRJSUlAeV24+RLppUuX0rJlS2xsbHBzc+OFF14gLU13LYLq/o0ANm/ezCOPPIJSqcTR0ZH27dvzyy+/aJ9XqVR8+OGHNG3aFGtra7y9vZk8ebK2PhrLwbmYnEz9dRyyM8xxcKq87B2cVeRkGN637Hnte2SZc/MMsZu3M4Yp53dwLibbQPacDAscnCp/TQdnVQX7ah5TVpLp5XdjQQGbl1V9WWDF719RuVcve0V/s7LXrm2mXm9MNrtTETlZ+qtr5GRaoHSsot5UsG92pmXp85r9Xd01B7MTw85xNdaO2S+3ZMXihrTrnML7Xx9HoTDupJl5TjHF9vplV2Jvgfn1qssjq2M9ro3y5erURlwb7Yd5TjEN5kdgey5bu41Fhmaw0ePbWAq9rImfHEzK0z7Yn8jEZ8ElKDH+hJ/SqYicbEu9x7MzLVE6VKPsDeybU1b2joYHSR/udg17pYodv9Xsxh0OTqrS+qgrO8MCpbHtTaaF9vkbDR6ZxJaLh/jh6FFeCo3h6/f82bG54sujqsxuwp9X7WubaH7Jrr/vjZlqLbuykOwc/cH7nGwrHJTGXxFwsx7do2kUnMa3yyufLHGrKj42M6/msZmBPi5D81hlx2a3g0nXGxPOrn1tE84vhLHq5G62xcXFqG5aPNTMzExvoGfkyJE8++yzbNq0iQMHDhAaGoqLiwthYWFYW1vz9NNPs379ehYsWIC5efmHcPXq1TRv3rzK2XgffPAB7dq1Y+nSpRQXF2NjY8OMGTP48MMPeeWVVxg8eDBnz55l1qxZnDhxgl27dulkXLNmDU2aNOHTTz+lsLCQKVOm8Oijj3L+/HksLMqL9tKlS0yZMoUZM2agVCqZOnUqQ4YMYciQIahUKlauXMm5c+eYMmUKHh4efPTRR4BmAKlv377aDC1atCA8PJz33nuPtLQ0Fi5cqPP7vPHGGwwaNIh169Zx4cIFpk6dirm5OatWraJ+/fps2rSJoUOH8vbbbzNkyBBAM2sRICoqip49e/Laa69hY2PDkSNHCA0NJTk5mXnz5lX3TwtA+/bt2bJlCxMmTOD555+nTZs2OuVRprCwkN69e3PixAmmT59Ohw4dyMzM5I8//iA9PR1PT8ODHdOnT2fhwoW8/vrrLFiwgKtXrzJz5kxOnz7N/v37depCdf5Gn3/+Oa+//jqPPfYYq1atQqlUcvToUZ0BxBEjRvDrr78ybdo0OnbsyLlz55g1axYxMTFs3LjxlspH3LueeTmeHo+lsWhKgM4lJEL8VyhKu8iTR1z4aq5mPbQThyA3x4LpC87w4CNpHNlr+AYdtSlpfID2//ObKMlp44z/jHO4boznykxNzrL1XvKaOpAcolk/MK+ZAyV2ZtT/Kga7U1nktnS6w8mN13PQVdJTrTi8r2Z3g72Tdm9x5fxxJY4uKjr0SuelOTGUFMO29caf/BBC3F5KZQHjxh5lxaqWZGbKsYwQQlFrS/OIytXJYF7Tpk31Hhs4cCC//fabzmPPPfccYWFhAPTq1YuDBw+yfv167WMjR45kyZIl/PXXX/Tt2xeA5ORkfv/9dz744IMqc3h6erJ582YUCk3lKxsgGzVqFF988QUAffv2xd3dnZEjR/Lbb79pB8EALC0t+e2337C0LD9j/tRTT3Ho0CE6duyofSw1NZX9+/cTFKRZ7L6kpIRHH32U6Oho7VqBffv2Zffu3fz444/awbz169ezd+9edu3aRZcuXQDo2VNzR9SwsDCmTZuGh0f51PYuXbrw+eefA9CnTx8uXLjAt99+y8qVK7G2ttYObgYFBdGhQwedspgwYYL2/9VqNZ07d6awsJCPP/6YuXPn6g20VmbKlCkcO3aMJUuWsGTJEmxtbenUqRNPPfUUL7zwgva11qxZw4EDB/j55591yvXJJ5+s8LVjYmJYsGABc+bMYfbs2drHGzduTKdOnfj111957LHHtI9X9TfKysrinXfe4fHHH2fTpk3abcrqE8CePXv4/vvvWbVqFSEhIYCmPtarV48RI0Zw/PhxWrVqVe3yuVFOpjlKA2eMKjozefO+Hg30Z2SUzazKLj0TmZNpjtKxGM03VUWF2xnDlPPnZBo+W6es4Mzuzft6+uif4VaWZsoxkGnA8GuMmXaVlQt8+PMH42ealL2/4XKvXnaPBvrZy8uz8r/b7WDq9cZks2cZnoGndFIZnHWnu68lHt76l5CUXTpbVu+yMzRt7bEDumvKHN2vWcMoqGm2UYN5xfbmmF/XL3ez6yqK7W+9PNS25lxv6Yjj7tTy91Bq/n65zR10ts1trlnU2jouz+jBvJwsS5QOBv72TkXkZFej7L30L2dVlpV9lv6sPRe3Alq1T+PX7/0oKa7ZRRg5WWX1UZdm1l3l2bMzLfAw0FaWzbC5uS5nplmSmab5ff7d7Yy1TQlj347jzx/djVqD0ZQ/r9rXNtH8kr2OsucYnoGndDA8Y88Yo0JOkpZmy+49ftjba96rbF0xe/siCgvNq7xrbkUqPjYrrsbxjQWePvrLDpTNyDN0bHY7mXS9MeHs2tc24fxCGKtOLrPdvHkzhw8f1vn55JNP9LYbOHCgzr9btGhBXFyc9t+PPPIIDRs2ZPXq1drHNmzYQElJCcOHD68yx2OPPaYdyAMIDw+nsLCQESNG6Gw3bNgwLCws2LVrl87jvXv31hkkatGiBYBORtAMNJUN5EH5YOaNA0Zlj1+5ckW7dt/vv/+Ov78/HTt2RKVSaX/69OlDUVER4eHhOvsbKq+CggLtJauVSUhIYPz48fj7+2NlZYWlpSUzZ84kIyODa9cqX5z7Zra2tmzevJkzZ86wYMEC+vfvz5EjRxg3bhz9+/fX/n5//vknXl5eOgN5Vdm+fbv273tjmTz00EM4ODiwe/dune2r+hvt37+fnJwcxo0bV+F7/v7771hZWfHkk0/q/R0Avfcss3TpUtq2bUvbtm0pwvA6CrEXbPBvon+prl/jfOIiKj/bGXvBBi/fQqxtdRcQ92ucT2GBgvgYK+12Vjblaz7cuB1AbITx6xGacv7Yi7b4N9b/guwfnE/cxcrXs4uNsMXTtwBrG90DB/9GeZrssbqZej6ewqvvx/K/pZ5s+MLbqLy6729jMLtf43ziLlZR7hG2mnK3ubncS7PH1P76lCZdb0w4e1ykPf4N9dfG8wu6TlxU5Xd5jY20x9MnT6/O+zW8TlGhgvg4O+12lVFXfr+DChX62GB1Vb/OW8XnU+hdg5khN5xILvSpYh3LGpx0jotS4tdQf20838Ac4qL019LT3beCsg/M0ZT9Zf317Lr3j8fcQs2O325He2OHf2P9L8h+wXnEVbH2Z9xFWzwb6LeVfo3yKCpQVDlD+eIpe+yUJbi4Gbfeoil/Xk09v2Svo+xxTvgbWBvP3zeTuLjbM7PY3zeToKAM/vf9Rjb+8D82/vA/nnnqLAA/btjItCn7jX7t2IgKjs0a5VXj+MYGTwPHN/6N8u/I8Y1J1xsTzv5fyC+EsepkMK958+baQY6yn+DgYL3t6tWrp/Nva2trCgp0B0VGjBjBTz/9pF1rbvXq1fTo0QMfn6rXiLn5Dqlla67d/LiFhQWurq56a7IZygforaPm4qI7Q8HKyqrCx1UqlXadumvXrhEbG4ulpaXOT/v27QHNjD9j8tyspKSEIUOG8NtvvzFz5kz+/vtvDh8+zIwZM6q1f0WaNWvGW2+9xcaNG4mPj2fEiBH8+eefbNmyRZu/On+nG5UNLAYHB+uVS3Z29i2XSdn2DRo0qPQ9CwsLsbe313m/slmRN79nmXHjxnHkyBGOHDmCJYYb+PA/HbmvTS5efuX12rNBIfe3u074n5Xf4jx8uyOWVmo6D8rQPmZmrqbrkAyO7nagqFDz8T78jwNFhQq6D9W962DPJ9KJPmdD0mXjOx9Tzh++3ZmmrXPw8i2v354NCmjWNofwv5wr3ffgDmdN9oHlmczM1XQZnMbRPY7a7AAd+6Yz6eNoft/gzrcf+BmVVS/7n87c1+b6TeVewP1tcwj/s/KD9fDtTqXlrpu96+B0nXKvTSZdb0w5+053mj6QhZdP+RclD+88mrXKJHxn5ZdiHtzlhqWlmk59yk/umJmX0LnvNY4eqIeqSJP9/ElH0pKteLCjbn/5YCdNOxlxpvIyqsj11s7YRF7H4lp5uVskF2B7MYfrrW/9C6pZXjH2xzMpCCwffMxvaI/KyQL7U7pr5Nqd1Pw7P1B/0Ky6Du5yp2nzTLxumDXiUT+PZq0yOLi78sXjD+720JR9r8Ty/OYldOmTyNFwN23Z36jnoHiiIpRERRhX3jrvv8OZpq1020oPnwKaPZhD+F8ulewJB3e4aOr8gPL6YGaupsvAVI7udaqyvWnxUDa5OWZkpOrPPqwOU/68mnp+yV5H2Q/60LRpCl5e5ScPPD1yaNYsmfCDNVs/s8zX3zzI1Ok9dX62/6VZl3v6Oz1YtfoBo187/C8nmrbWP75p1jaH8O3Ole578C9ng8c3XQal6x2b1QaTrjcmnP2/kF8IY5n8fNCRI0cSFhbGpk2beOihhzh8+DCrVq2q1r43zsqD8oGfxMRE7r//fu3jKpWK1NRUvYGh2ubq6kpgYCA//PCDwedvvKlHTURGRnLkyBFWr16tMyvx119/vS2vD2BjY8OUKVNYs2YNZ8+eZdCgQbi5uXH69Olbeh1XV83lWX/++afeYOiNz1eXm5vmC+zVq1dp3rx5he9pY2PDnj17DD7v7W38zIeta+sxZEwKoStiWPWRF2o1jJqSSHK8FVtWl/8uHj6FrDxwjrWLPVm7WHNnv8jTduz82ZkJYfFYWKpJjLNiUEgqXr6FzH+1fNAoM9WSTUvdGPbqNfJyzLl0ypauQzJo+UgOoaMDjc5u6vm3rXdnyKhrzPn2Eqs+9gE1hEy+SnKCFVvXll8G6+FTwIrdJ1n7qTfrPtMcCEeesWfnL/UYPydOk/2yNQNHXMOrQQEfvVE+C7d5+2ymfxZJ1Dk7tv/Plaatyw+uiwoVRJ6pfBZTRbauc2XImGRCl0ey6iPv0nJP0JT7mvJBGQ+fAlbuO8PaT+qz9pP6pdnt2PmzCxNCr9xQ7imacn9NtzwbPXAdT99CzEqbSv9G+XQqHcA8vMNJ745x1c5vwvXGlLP/vtGbwcOuMPuzk3z3eRBqYOQr0SQnWbPtx/J2zKN+Hsu2hLNuSQDrl2jeL+q8A7u2eTBu6kUsLNQkXrVh4NNX8fLJZ8Hb5f1lSbEZKz5tyOT3z/HqzPPs2+GOt18eIa9FceKQMycOVj74U5HMbq44/ZWM96eRpD6hyeq6KQFVPSsyu5fXeYuUAgKmnCHt0fqkPaap885bk7BKzCfvPgdUzpZYpBbisi0Ji0wViRNuKE9zBSlP++D1TSweK+PIedAZy2sFuP4vntymSvKa6V5+eyt+39yAQc/EMWvRMVZ/1Qi1Gka8dJGURBu2bSw/meTulceyn/ew/tsg1n+jOckZdcGRXX94MW7yecwt1CRdtWXAk5fx9M5jwUz9L80Nm2YREJzDN4uaGJ33Rts2eDB4ZBKzl0bw3cIGqNUKQiZd0bSV68sHIj28C1i+8zjrPvdh3eea3ynyrD27fq3HuFmxmuxXrBk4PAkv3wI+mlh+Erf/s0k0bZ3D8X1OpCRY4eCiosuAVDoPSGP5fF+DA5bVYcqfV1PPL9nr6Njm92CGDIpgzqxdrFrdUnNsM+IkySl2bN1W/pnzcL/OimW/sHZ9c9atb6F9vEXzJJycCnBx0Zz0aRScSl6e5uvi3n2a/FFR+u34Ay00VwGdPOVBSYnxg2bb1rkxZFSy5thsgeaYK2RyfOmxme7xzYo9p1n7aX3WfarpEyLP2LHzFxfGz7ms6acuWzFwZLKmvXnDwPFNg0IUZpqrhfwa5dNpQOnxzd/GHd+Ycr0x5ez/hfxCGMvkB/MaNmxIx44dWb16NREREdjb2zN06FCjXqtDhw5YWVmxYcMG7dp0AN9//z0qlYpu3brdptTV069fPzZu3IhSqTS4zuCtKpuVlpenO309N1czU+DGy1GLiopYu3atUe+TkJCgN7sR4Pz580D5zMc+ffqwYcMGfv31VwYPHlyt1+7duzdmZmbExcXRu3dvo/LdqGPHjiiVSpYuXap32XOZfv36MX/+fDIzM3Xqxe1QkGfO1KcbMiE0nimfxaFQwPG9Sr6e7UN+bvkaDwoFmFuULy5fZuFEX0ZPS2DU1ESUjsVEnbVlxvAgLp3SnUGycl598q6b89jYZFzcVVyJtOaD8f4c/KtmszZMOX9BnjnTnm3C+NmXmbI4SpN9nyNL3vUzmP3mZSMXvRXI6KlXCJl8RZP9nB0zRzXm0unyAbpWHbOwslHTqEUuized19k/6bIVozq1NDr71KcbMSH0ClM+jSktdwe+Dm1QQbnr3oVz4WR/Rk+NZ9SU+NLstswYGcyl07rlPmR0Mn2eLp9R02VwBl0GZwAQ0uF+kq4YdxbS1OuNKWd/e2xrxk29yFtzz4ICThx0YclHjcjPu+FwQAHmFmrMbqo3i2ffx6jXohj5ahRKBxXREUpmvdSSyHO6g1w7fqmPugSefD6O3o8lkJ1pyT+/ebHy0yCMvVZVbW3O1emNcF93Bc8lMSiA3GYOJD/XALXNDevhqEFRAqjLsxfVt0b5bwbKfzMwyyumxMacvEZKkp73p6Ch7oB6didXUIDLliQc9qRSYm9Odsd6pDzlrfmjGqkg34J3JrTjxUnnmfzuSU3ZH3Zl6cdNdcpeUVr2N7/VJ2HNCXn5IiEvXcTeQUX0RQdmv/Ygkef160PPQVdRqRTs3KbfDxuVPc+c6SPuY9zMWKYsjAQFHN/vxJL3/HXqPBXU+UVTGzLqrculbaVK01aObqpzMiPmgh0P905n7NtxODipyEy34HKkLbNfaMzhf4wbAC7LbqqfV1PPL9nrKHuBBdPe6cn4F48yZfJ+FMDxE14sWdqG/Pzy43yFQo25uRqzm+4wPnL4KR54oHwG9pDBFxky+CIA/QY+Z3SuaufPM2fasMaaY7NPokuPzRxYEuZbvWOzyQGMnnqVkLeuao9vZoY00j++GZVM76fKr6zpMiidLqUz+kZ1bG7U8Y1J1xsTzv5fyP+foK56E3H7KdRq9R0r+pUrVzJmzBh+/PFHg5c1tm3bFgsLC+12Fy9e1Ln8NjQ0lLCwMG6O/PXXX/PKK6/g4eFBr169dNbQAxg9ejQ7d+7U3p00JiaGwMBAvvnmG8aOHauz7TvvvMOHH37IG2+8wYABAzh37hwzZ86kVatWOnezVSgUzJgxg/fff1+7b9nrrlixgtGjRwPQrVs3VCoVe/fu1dvu5vcv+/2KioqwsLCgqKiIXr16cenSJSZPnkzLli0pLCwkMjKSX375hZ9++gk7Ozt27txJ9+7d2b59O7169dIr7+joaAICAigpKcHDw4MmTZowd+5c7O3tCQwMxMHBgcaNG2NhYcG8efOwtLRk8eLFXLlyhcjISO3+oJkN2K1bN1auXFnh33nw4MFkZWXxxBNP0Lx5c4qLizl8+DAfffQRbm5uHD9+HKVSSVFREV27duXkyZO8/fbbPPTQQ2RnZ/PHH3/w5ptv0rRpU73foexvtHjxYl577TW6du2KjY0Nly9fZvv27YwdO5bu3bvf0t/oiy++4LXXXmPo0KEMHz4cBwcHjh8/jo2NDa+99hqguRnLtm3bmDRpEu3bt8fMzIyYmBi2bt3K/Pnzady4cYXlAeCoqMdDits7ECiqR2F5exZ8rgvqYv3FfE1GiQlnN3Hmbnf+brG3y/mF/nUdwWj3TY+v6wg1UpKeUdcRjFZi5HIgQpgqRev7q97obnbqQl0nMJpapX8jKSEqc1C9gyx1WtUbmijroAZ4v/tKXceoNa6fbOTIkSN1HcOgOpmZ99RTTxl8PDk5WXvZ46145plneOONN0hMTGTkyJE1yvbBBx/g7u7O119/zVdffYWrqyshISF8+OGHt3RH19vB0tKSP/74g3nz5rF06VKio6Oxt7enYcOGDBw4ULv2XnWZmZnx7bff8s4779CrVy9UKpV2UOunn37i1VdfJSQkhHr16vH888/j5+fHiy++eMu5X331VdatW8eXX35JfHw8hYWFNGjQgBEjRjBr1iyUSqX29/vzzz8JCwtj6dKlhIWF4erqyiOPPFLpJc1z587lvvvu48svv+TLL79EoVDg6+tLz549adSokVF5vby8WLBgAcOHD8fS0pL77ruPWbNmabdZs2YNn3/+OcuXL+eDDz7A2tqagIAA+vbti6en5y2/pxBCCCGEEEIIIYQx7ujMPCHuVTIzr+7IzLw6IjPz6ozMzKsbMjOv7sjMPHGvkZl5dUdm5olbJTPzTJvMzBNCCCGEEEIIIYQQ/x1qUKuNX1dYGO/OXjcqhBBCCCGEEEIIIYQwmgzmCSGEEEIIIYQQQghhImQwTwghhBBCCCGEEEIIEyFr5gkhhBBCCCGEEEKIWye3VK0TMjNPCCGEEEIIIYQQQggTIYN5QgghhBBCCCGEEEKYCBnME0IIIYQQQgghhBDCRMhgnhBCCCGEEEIIIYQQJkJugCGEEEIIIYQQQgghjKCo6wD3JJmZJ4QQQgghhBBCCCGEiZDBPCGEEEIIIYQQQgghTIQM5gkhhBBCCCGEEEIIYSJkzTwhhBBCCCGEEEIIcevUdR3g3iQz84QQQgghhBBCCCGEMBEyM0+IO0BhZYWFj19dxzCKKu5qXUeoEYW56Z6zUBcV1nUE45mZ13UCo5nZ2tR1hBopycis6whGu29GUl1HMNrZ9xvUdYQaaTazrhMYT1FUVNcRjFacklrXEWpGYcJ3MFSb7lQS9bEzdR2hZky43lj4eNd1BKOpEky3jwUws7er6whGUeSY7ncRcXeTmiWEEEIIIYQQQgghhImQmXlCCCGEEEIIIYQQ4taZ7kRnkyYz84QQQgghhBBCCCGEMBEymCeEEEIIIYQQQgghhImQwTwhhBBCCCGEEEIIIUyEDOYJIYQQQgghhBBCCGEi5AYYQgghhBBCCCGEEOLWqAG1oq5T3JNkZp4QQgghhBBCCCGEECZCBvOEEEIIIYQQQgghhDARMpgnhBBCCCGEEEIIIYSJkDXzhBBCCCGEEEIIIcQtU6vrOsG9SWbmCSGEEEIIIYQQQghhImQwTwghhBBCCCGEEEIIEyGDeUIIIYQQQgghhBBCmAgZzBNCCCGEEEIIIYQQwkTIDTCEEEIIIYQQQgghxK2TG2DUCZmZJ4QQQgghhBBCCCGEiZCZeULUMTePPF584wyt2yWjUMDxw24s/fR+kpPsqtzX0qqYkS9eoHvfK9g7FBF10YkVX93HmeOuOts5OhUw5pVzPPRIEjZ2KmIuObLm2yYcPehR4/zu9QsZH3qFNp2zQAHH9jrw9RxfkuOtqs5vXcKoKfH0eDwNpVMxkWfsWDbXm9MHHXS2G/piEi07ZtPogVxcPVWsXuTFmkXeNc7uVr+A8TNjad0pCwVqju13Ysl7/iTHW1ed3aqEkElX6PFYCvaOKqLO2rN8vi+nDztqt/EJzGPQiCRaPpyFl28BedfNiThpz3eLGhB93r5G2d29CxkfGk+bLtmact/jwNdzvEm+Ws1yn5pIj6HpKB2LiTxjy7IP6nP6oFJnO4VCzdOvXGPAyFTquau4EmnN2sWe7N3qXKPsYOL1xquA8TOiaf1IJgoFmnrzfiDJCdWsNxPj6DEkGXvHYqLO2bF8gT+nDztpt7G1L+bNuZcIvv869dwLUakUXI225efv6vPPL+41y16/kPFzLtOmk6bcj+915OuwWyj3yfH0GJqqyX7GjmUf+nD60E3lPjaJBzpm0/iB69TzULFmcX3WLL4N5e6Rx4sTz9H6oRQUwPHDrixd1IzkJNuqs1sVM3J8BN37x2OvLCLqoiMrvmjKmWP1dLZzcCrk2Rcu8VDnJFxcC0hPs+bwXg/WfRtMVkbVf9/KWKQV4r7hMnZns0CtJreZI8nDfFG5Vv26jV84YvDx2DnNKPAz3Fc4HEyj/tIoilwsif64ZY2yu3nm8eKkC7TukIoCNccPubJ0YVOSE6tZ9i9dovuAeOyVKqIiHFjxWWOdsu81+CoTQ09X+Boj+nQjPdW48nfzzGfc1Iu07pCm+byG12PpR41ITrSpXvZXo+kxMBF7BxVRF5Ss+KQhp/910dvW1aOAka9E0bZzKg6ORaQmW7N7mycrP2toVO4yptzWa7JfpU3nG7P73EI7n1Ce/awtyz7wrjj7iBRN9ihr1i72uk3ZTbncTTN7ef7arTdDx12jZcec8uODhZ6sWVS/xtndPMv6qdK28rAbSxfeV/1+asLF8n4qwpEVXzQx3E+NvcRDna9p+qlUaw7vc2fdNzXrp0z5uAxKj83ejqL1Ixmlx2bOLJkbSHJCddr6EkLejKXH4Gulx2b2LP84gNNHnCrcp+uAZKYvvkBKohUju7a/Lb+DELdKZubdow4cOMCwYcNo0KABVlZWODo60q5dO2bNmkVCQkJdx7tjVq5ciUKh4NKlS3Xy/tbWKuZ+foAG/jkser8VC99tjbfvdT784gDWNqoq93/j7RP0HRLLmm+bEPZWe9JTrHlvcThBjTK121hYFjP38wM8+NA1ln91Hx+83Zbka7bMWXCIFq1TapbfpoT5P1zEt2E+CyYGsOCNAHwCC/johwisbYur3H/Sx7H0fzaV1Qu9mT2qIWnXLJi79hJBzXJ1tuv/XArObioO/OFco7y62YuZt/YcDYLyWfhWEAsmN8Q7IJ/5a89VK/vE+VH0G3aN1YsbEDq2CWnJlry/6jxB913XbtOmUyYtH87ir43uhL7YmC9nB+BUT8XiTWcIbn69klevIrttCfN/iMQ3uIAFb/qx4HU/Tbn/GFm9cl94mf7PpbJ6gRezRwWSds2SueuiCLo/T2e7UVMTGTE5iV9XuDFzRBDnjtoxY2ks7XpkGZ0d/gP1ZvUZGgTlsXBqMAveaoS3fz7z15yuXr358BL9nk5i9ad+hI5rSlqyFe8vP6dTbywsSyguVvD91z6ETWjKR5MacznSlqkLL/LY6PgaZC9h/oYIfBvm8/GkQBa8GYh3YD7zv79QvewfxdLv2RS+W+jNnDHBpF2z5IM1F/XKvd+zKTi7FrH/dpa7dTFzvzpIg4AcFoU9wMLQlpq28v8OVq+tnHmKvo9dZs2SRoRNbqtpKz89RFCjG+uymtkf/0u3vvFsXBPEnDfbsWl1EF36xDNn4b/U5BoSRUExDRZcwCohj8TnA0gcG4hVUgENFkSgKKi67AEyH3El7p2mOj+Fnoa/uJnlqnDfEIfKydLozGWsbYqZ+/URGgRcZ9Gc5iyc/QDefrl8uORw9cp+9hn6Pn6FNV8HE/ZmG03Zf/EvQY3Ly/7QHncmjXpI52fy6IfIzLDkwmlHowfyrG2K+fDbYzQIzGXRzGZ8/E4zfPxzmbfsaLXq/Jth5+k3NJ7VXwUS+toDpCVb897/nSCoSbbOdh7eeSxeexgf/1yWzGvEjPGtWPt/gRQXK4zKrc1vwm29pp2/hG/Dsuz+pdkvVbOdL83+cX1mjw4iLcmSuWsjCbpft70ZNTWREZMS+XWFOzNHBnHuqD0zlsTULLspl7sJZ4c7V2/6P5eKs6uKA39UPFhzy9mti5n71SFNWxn6AAvnlPZTX1ezn5p1Qz816UHSU61577PDOm0lqJm9sLSfWh3InDfasmlNIF36JDBnkfH9lCkfl2nyFzNv1SnNsdm0xiyY2hhv/zzmf1fNY7O5F+n3VCKrP/MndHwzzbHZsjMENc0xuL29g4px70SRdq3mfawQNSEz8+5BCxcuZMqUKXTv3p3333+foKAgcnJy2L9/P0uXLuXIkSNs27atrmPeE/o+GoeX93XGD+tBwlXNTK3oS4588/3f9H8slp82VHxGPzA4k+59r7L4g5b8tcUPgFPHXfm/NTsZMfYC707TnCXq3COBwOBspr/yMKeOuQHwb7gHX3y3izGvnGPS2M5G5+8/PAUvvwLGdm1GfIzmzFfUOVtW7DnDwBEpbPrGs8J9g+7Lpcfj6Syc5M+fP2hmEp4Md2Dp32cJeSuB0OfLf/dxPZqhViswM1czKKRmA5Bl+g1Lxsu3gBd7tSQhVpM9+rwdy/4+wYDnrrF5WcVnaAObXqf7o6ksmhrE9v9pZkqdPOjIkj9OMnLiFcLGNQFg12+u/LraEyj/Qnf8gCMrdx/n0dGJLHzLuBkb/Z9Lxcu/kLGdmxIfo/mSG3XWhhX7zjNwZBqbllY8eyuoWR49hmawcKIvf36vOdt78oCSpTsvEDIlkdDRgQA4uRbxxIRkfvjSg/99rZnBeWK/Eu+AQp5/J4HDfztW+B5V5jflevNMEl6++bzYpzUJcZoz7dEX7Fi2/SgDhiWxeUXFZ5gDm16n+5AUFk1vyPaNmt/x5CEnlmw9xsg34gibcB8A2RmWfDSpsc6+h3e54BOYR58nr/HTSuPOYvd7LllT7t3uv6HO27J812kGDk9h07cVl3vgfbn0eDyNhZP92f6jph05Ge7A0r/OEDI5ntAXgrXbju91Q7mPvD3l3vexOLx8chn/VFcSrpS1lQ58879d9B8ax0/rgirO3iiL7v3iWfxuC/76zReAU0fr8X8b9jBifATvvtUWAG+/6zRrmc7nc5vz+0+lbepRV0rU8Or0M/j4XedqnLLC96mM0+4ULJMLiPmgOUWemrIvaGBH4DuncNqZTEZfrypfQ+VsRX7D6r2/249XKPC1Q+Vkid25mn257vv4FU3ZD+1UXvYXlXyzeS/9n7jCT2sDKtw3sFEW3fsnsDi0OX/96gPAqaMu/N8P+xgx4RLvTmoDQFaGFVkZurM/7m+VjpNzEWu/DtZ73erq90Q8Xg3yGDekAwmX7bTZv/01nAFPXmXzar+KszfOpvvAJBbPasr2nzWfuVNHnPl68yFGvBLNu68/oN321VkXSL1mzfSxrSlWac6Tn/7X6NhaptzW9x+eipdfIWO73Fee/ZwNK/aeY+DIVDYtrfjKAE32dE32snb+gJKl/5wn5K1EQscElWcff02TfUlZdge8Awp4/u1447ObcrmbcHa4M/UGYFz3pjccH6QanfdGfR+/rGkrn+yi209t3E3/oZf5aV1ghftq+qkETT/1awOgtJ/6fi8jxl/k3ckPAuDtl0uzlhl8Pvd+ft98Qz9VouDVt8/g43+dq7G33k+Z8nEZQL+nEzXHZv0evOHYzJ5lfxxhwDOJbF7pU+G+gU1y6D44mUVvN2L7ptJjs8NOLNlyVHNs9lIzvX1emBJN9Hl70pKtaN0x47b9HiZNXbOTV8I4MjPvHvPPP/8wZcoU3njjDXbs2MHo0aPp0qULAwYM4P333ycqKopnnnmmrmPqKSgoqOsIteKhTklcOOOiHcgDSEqw4+wpFzp0Tqxy36IiBXv+Kv9iX1Jsxu6/fGjzUDIWlpozUU3uTyc/30w7kKeh4Nghd5o0y8DVLQ9jdeidyfmj9tqOHyDpsjVnjih5uG9mJXtChz6ZFBUq2PVL+eVKJcWafz/YNQtLqxLt4+pa6CA69Ern/DGldlADIOmKDWf/deDhXulV7JtBUaGC3b+VX/pQUqxg12+uPNg5U5s9K92SGwfyAHKzLbgabYObV6Hx2ftkcf6onfZAF0rL/bB9Nco9q7TcnXWz/+zMg12ztdnbdsvGylrNjo26l5P9vcmFoGb5ePoa/5k06XrTI53zxx20B4tQWm+OOvJwr7TK9+2Zpqk3W8o/iyXFCnZtcePBzhk62Q3JyrCkpAYzfTr0zuT8MXvdOl9a7h36ZFS678O9NeW++1fdOr/z13q06VL75f5Ql2tcOO2i/YIEkBRvx9mTLnTocq3yfTuXtpXbb2or/6xPmw4p2rbS0kIzoyH3uu55zuvZmjPvZjU4YlIezyC/ob12IA9A5W5NXrAS5fEM41/YAJuL2TiGp3FteMUDVbfioS7XuHDKWb/sTzjToWsVZd81ubTsywcrtWX/cAoWlhXX+Z6Dr2o+639UPdBZ4ft3S+HCSSftQB5A0lVbzh53okP3yr9IduiWQlGRgt1/lH+JLSk2Y9fvHjzYMVWb3atBLm0fSePX9Q20A3m3iym39R36lLXzBrL3MbKdryj7Jt3LEP/eWNPsplzupptdk6H26w3UZj9loK086UyHrklV7ltUpGDPn+Unksv7qfJjesvSdic35+Z+SvNvMyN/LVM+LgPo0CON8ycqODbrWflgrfbYbKuBY7NO6doyL9OsTRbdhyTz5bs1W0JBiNtBBvPuMfPnz8fNzY358+cbfN7e3p7Ro0dr/52bm8u0adMIDAzEysqKwMBAPvjgA0pKdBu2Cxcu8Pjjj+Ps7IytrS0dOnTg999/13v99evX07RpU2xsbGjRogW//PIL3bp1o1u3btptdu7ciUKhYNOmTbz44ou4u7vj6ak5mL506RIjR44kMDAQW1tbgoKCeOmll0hP1x18GT16NA0aNGD//v20a9cOGxsbAgIC+Pzzzw3+3ikpKQwfPhxHR0e8vb15/fXXyc/PBzQDie7u7kycOFFvv7LLdM+fP2/wdaviH5hNbJSD3uNx0Q74BRie2l3GLyibpHg7Cgp0O/TYaAcsrUrwbqCZ2l5SojD4BaOoSPOYf8Nsveeqy79xHjEX9NcBib1gg1+j/Cr2zSfxshUF+brZYi/YYmWtxjugdgdw/RrlERuhv9ZU7EVb/IIrH+D0b5RL0hVrCvLNdfeNsMXSWk19/4p/d6WTioDGecRdqnr9lArfv0k+Mef11wCJvWCDX+Mqyr1Jabnn3VzuNqXlXqjdrjBfQXy0ld52AP6Njf/7mHa9ySX2YkX1JtfAHuX8gyuoNxftsLRSU9/v5t9djZm5GgfnIvo/k8iDnTLYvML4NX38G+URa6jcI2yrLHe/xnkkGSr3CJs7Uu7+QdnERurPNoiLUuIXWFVbmVPaVt5U7mVtpa/m7xYbpeTU0XoMe+ESwfdlYGOronGzDJ594RKH97lzOca4WXkAVvF5FPjol32hty1W8ZWXfRnnndcIHv8vwS8dpcGCC9hGGGi7VSV4fhdLel9PnYHDmvAPyqm47IOqUfZXbfXrfJQSSyu1tuxvZmVdTKdeSRza405OVtXrNVX4/g2vE3NJf33S2Eh7/IIqX+rAr+F1g9njLtlrsvtpsjdrrfmiW1BgzgdLjvHzkX/4fu9uJn9wFgenIqOzg2m39f6N84m5YCB7RDWyV9TO39Te+DeuIHuEjfZ5o7KbcrmbcHbNvrVfb2qLpp8ycEwf5WB8P3VTWxkbqeTUUReGjY0k+L7M8n5qbM36KVM+LgPwC84lNsJAW3/JrnrHZldt9PupS6XHZv7l3wnMLUp4/d1LbFzmozNwKERdkcts7yEqlYpdu3YxdOhQrKyqPjhWqVT07duXs2fPMmvWLFq0aEF4eDjvvfceaWlpLFy4EID4+Hg6deqEg4MDX3zxBU5OTnz55ZcMHDiQ3377jf79+wOwfft2hg8fzpAhQ1i0aBHJycm8+eab5Ofn07hxY733f+211+jfvz+rV6/WDqzFx8fj6+vLJ598gouLC1FRUcydO5cBAwZw4MABnf2zsrJ45plnmDZtGsHBwWzYsIHXX38dBwcHnQFLgJEjR/Lss8+yadMmDhw4QGhoKC4uLoSFhWFtbc2YMWNYtmwZH374ITY25QcZS5YsoWvXrjRt2vSW/hZllI6F5GTr/y2ys6xQOlT+JcDBsZCcbP21GnKyLLXPA1yNU2KvVOHrn83l2PKDjKbN00u3M/7LhoNzMTmZ5nqPZ2dY4OBU+fogDs6qCvY11752bXJwUpGTZTi70tjsmRba5yvycmgMKOCnFcbPNqm43M1xcKq83BycVeRkVFbuqvL3yDLn5pmFN29nDJOvN5n6XWd2piVKx2pkzzK0r+F6M3hEIi/PiQagqFDB1+8HsOMn429a4+BcTLaBssvJMK9WuWcb+L1zMjSPKWtQH6pD6VhksL3LzrKsRltZpG0Xb5STaal9XkPBnDfb8lbYCT5dtV+73aG97nz4dhvjwwPm14spsdMvv2J7C8xzqy67rA71yGnpTLGzJRaphdT7PZEGH0dwZVIj8pqWX9JWb1siCpWatIE1X8i9jNKpgrLPtETpUEW9qWBf/bLX9XC3a9grVez4reJLo6rDwanI4GcuJ9Oi6s9rBftml2Uv/cy4umu+qE4MO8ffv3nxwzJ/6vvmMfqNSPyCrvPmc22Nno1iym29g3NxBe9vUY3sFfcRZc9rtzOYXXe7W2Xy5W6i2bWvXcv1prZU2E9Vp610LDTcVmUZ6KfeaMtb757k0+9u6Kf2uPPh262Nzm7Kx2VQdkxv5LFZRcd1GbptPcBTL17B0qqE75f41jCxELeHDObdQ1JTU8nPz8fPT//SG5VKt6GzsLBg/fr17N27l127dtGlSxcAevbsCUBYWBjTpk3Dw8ODRYsWkZ6ezoEDBwgO1qxtM2DAAJo1a8aMGTO0g3lz5syhWbNmbN68GYVCcwDQvHlz2rZta3Awr3379nz77bc6j3Xp0kWbBaBjx44EBwfTuXNnjh07RuvW5R1ZdnY2S5cuZdiwYQD069ePq1evMmfOHEaNGqXNAPDcc88RFhYGQK9evTh48CDr16/XPjZhwgQWLlzIjz/+yMiRIwE4efIk4eHhrF+/vvKCr2M7//Rh+AsXmDjrOJ/ObUl6qjX9Ho2jeUvNJYEllV/ZJ26jp1+6SvdHU1k8LVDnUkchDNm91Y3zxx1wdCmiQ880XpodTUmJgm0bjB8IFpV7fcYpmjTP4PMPm3M5RolvQA4jxkXwzodHCZts/KBMTSW+qLsmYE4rZwJmn8FtczyX39YM5lkm5VNvSwLxrwSjtjTtCy96DrpKeqoVh/e5Vb1xHVOUFvXJIy58NVezXuqJQ5rL4KYvOMODj6RxZK9rJa8ghBDV9/qM05p+au795f3U+Iu8M+8YYZMerLN+6r+uvl8ewyZc4b1X76Oo0LT72NqgMP4eYaIGpCYKEhMTsbS01PlRqVT8/vvv+Pv707FjR1QqlfanT58+FBUVER4eDsDu3bvp0KGDdiAPwNzcnGeffZbjx4+TlZVFcXExR44c4YknntAZRHvwwQcJDDS8IOzjjz+u91hhYSFz586ladOm2NraYmlpSefOmhs4XLhwQWdbc3NznnjiCZ3Hhg0bRlxcHFevXtV5fODAgTr/btGiBXFxcdp/BwUF0bdvX5YsWaJ9bMmSJbi7uzN06FCD+ZcuXUrbtm1p27YthcWGp3jnZFuidNBfO62iWXc6+1Ywe09ZevYuu/TSpOs5lnzwTlucnAr5as0u1m/7k96D4li7XDOAmpZq/KBSTqY5SgNnSiuaxVO9fTWPZRs4M3s75WSZo3Q0nN3QGbobZWdaGM5eevau7CzwjQY8l8SYKVdY9XED/vzR+NlVUHnZGZp5pbevgbOk5eVuUb6dYzE33xnt5u2MYdr1xvDMzYpm8dwou4LZQBXVm8w0Sy6eVvLvHhe+DG3I3z+7M3ZaDOYWxo3A52QanpmhdC6uRrkbPjtfNiMvpwb1oTpyKpiB51DBTAidfbMtte3ijZROZW2lZv92j1yjW98EFoa25PfNfpw5Vo/fN/vx8ZyWtOuUzEOdK18frjLF9uaYGZiBZ35dRbGBGXtVUduac/0BJ6xjyi8V9VgfR25TR/Ib2mOWq8IsV4WiWI1Crbm7raLQyHpTUdk7FZGTXUW9qWDfm8v+Ri5uBbRqn8au3+tTUlyzw9ScLMOfOWUFszh09zU8o6Ps0tmyz0zZ7I1jB3TXDzu6X7OOW1BT45eyMOW2vuL3V1UvewV9hCaTefl2BrPrbnerTL7cTTR75RluX72pLTVqK7MNtzflx/Q39FP9Elg45wHdfmp2zfopUz4ug4rb+modm1V0XOes29a/NDOKE+FOnD/ugL2DCnsHFRaWalBo7m5rZV37MxCFuJkM5t1DXF1dsbGx0RmkAnBzc+Pw4cMcPnyYF198Ufv4tWvXiI2N1Rvoa99ec5fU1FTNgqJpaWnUr69/SY+XlxdqtZr09HRSUlIoKirCw0N/EKNsPbybGXrNt99+m9DQUEaMGMGWLVs4dOgQmzZtAtBeilvGxcUFS0vdLwpl73XzYF69erqLJ1tbW+vddOPll19m3759nD59muvXr7NmzRrGjBlT4SXL48aN48iRIxw5cgQrc/01tqB0bbxA/QN934Ac4qpY9yIu2gFP71ysrXU7IL/AbIoKzYi/Uv6eZ0648sJTPXjx6e6Mf7Yb457pQbHKjPx8My6dd6r0fSoTG2GDf2P99eX8GucTd7HyQcLYCFu8fAuxttH9gunXOI/CAoXO4se1ITbCDv/G+oOsfsFVr2cXd9EWzwYFWNvodtx+jfIoKlDozbrr8Vgyr7wbw8ZvvNjwVc0uGwPNGib+TfTXMPFrnE9cRBXlfsFGU+62N5d7fmm5W2m3s7IpXyPnxu0AYiOM//uYdL25aIu/gfVXNPXG8Oe8TNwlO8P1JjiXokIFCXGV/+4XTymxU5bg4mbcpfGxEbYGy92/UV41yt0GTwPl7t8o/46Ue1y0g8H12XwDc4iLrqKtjFKWtpU3lXtZW1l6c4SA0vVDI87qtokRZ5w171XFOqaVKfS2xfqq/mfWKiGPQu/bM0vXKj4f5alMgl87rv1xPJiGRUYRwa8dx23jFaNeNy5KiV/DCso+qqqyt8fTJ0+/zgfmUFSo0Jb9jbr3j8fcQs2O34y7a7PO+0fa499Qf208v6DrxEXpr690o9jICrI3vK7JHmen3a4y6hrMfjfltl7TzhvI3ugWst/czt/U3sRGVJXduM+WSZe7CWfX7Fv79aa2VLSOaM36Kd22MiC4on7KSftexjDl4zLQrG/n38jAsVnD3Oodm/nkG2jrS4/NYm21/27fLZ3/HQnX/nQfnIybZyH/OxLOmMmxt+8XEqKaZDDvHmJhYUGXLl3Yvn07hYWFOo+XzSDz9i4/eHZ1dSUwMFA70Hfzz+DBgwHNQFhiov6dVxMTE1EoFLi4uODm5oalpSXXrumfMUpKMnyHpxtn8JXZsGEDISEhzJw5kx49etCuXTucnZ0N7p+enk5Rke6X3rL38vG59QGVAQMGEBAQwJIlS1i/fj3Z2dmMGzfull/nRgf3eNH0/gy8vG+YXeGVS7MH0ji4t/JL6Q7u88TSUk2nHgnax8zMS+jSM56jh9xRFd18JkxB/BUlV2IdsLYppu+QWP75vQEF+cafQQ3/05n72lzHy6984NOzQQH3t80h/M/KBwnDtzthaaWm86Dym5eYmavpOjido7sdan0K+8EdzjRtlYOXb/lBo4dPAc0ezCH8L5dK9oSDO1w02QeU373UzFxNl4GpHN3rpJO9Y580Jn0UxR/fu/Pth/63JXv4n47c1yb3pnIv5P521wn/07GSPSF8u2NpuWfoZO86JEOn3A//40BRoYLuQ3VvLtPziXSiz9mQdNn4gzOTrjd/16Npq+yb6k0+zdpkE76jinrzd2m96V9+Z7XyeuNcZfYW7bPIzTEjI7XymWgVCf/Liaat9cu9Wdscwrc7V579L2eD5d5lUDpH9zjWfrnv9qBp8wy8vMsP1j3q59KsZToHd1c+0/XgHg9NW9nrprayVwJHD7pp28r0VE2dbtJM9859TZpnAJCSXINZzK2csYnKwTK5vOwtUgqwvXSd662cb/n1zPKKsT+ZSX5g+UBSwvggLk9prPNzvbkjKqUFl6c0JqOHcTOCD+5yp2nzTLx8biz7PJq1yqi67HeXlX35MYKZeQld+iRyNNwNVZF+vek5KJ6oCCVREZW3ZdURvtOdpg9k4eVT/iXVwzuPZq0yCd9Z+SW8B3e5abL3KT9uMTMvoXPfaxw9UE+b/fxJR9KSrXiwo+7drB/spPmcR5wx/vcw5bZek91AO9/uOuHbq2rnS7MPrmb2x2/KPvR2ZDflcjfN7OX5a7fe1JaDe0r7KR9D/ZThiQvafXdX0E/1rqCfur+Cfuqacf2UKR+XQemxWcssvBoYODb7u14le2r2tbRS07lf+R3OzczVdBmQojk2K23r501qwtSRzXV+juxxJjPNgqkjm/PLmtu3Vq0Q1SVr5t1jpk6dSu/evZk2bRqLFy+udNt+/fqxceNGlEplpTd46Nq1K5988gkxMTEEBAQAUFxczPfff0/r1q1xdNQcPLRt25aNGzcSGhqqHaj7999/iY6ONriOnyG5ubl6s+1WrFhhcNvi4mI2btyoXTMPNIOBfn5+Rg3mmZmZMX78eObNm8eePXvo1asXDRvW7Lbkv//ix6Ano5k1/zCrlzZFrYYRL14gJcmWbT+VD/y4e+Wy7Ie/Wb+iMetXaC6PjYpwYtdf3ox74wzmFiUkxdsxYGgsnvVzWRCquwjuqAnnuHTBiawMK+o3uM4Tz0VSrDJj5f/dV6P8W9e5MmRMMqHLI1n1kTdqNYyakkByvBVb1pR/UfLwKWDlvjOs/aQ+az/RdHaRZ+zY+bMLE0KvYGGpJjHOikEhKXj5FjL/Nd1Lrxs9cB1P30LMSsd3/Rvl02mg5qDh8A4nvTtoVce2DR4MHpnE7KURfLewAWq1gpBJV0hOsGLr+vIvqB7eBSzfeZx1n/uw7vMGmuxn7dn1az3GzYrF3EJN0hVrBg5Pwsu3gI8mll9u3rxdFtM+vUTUOTu2b3SnaavyWZhFhWZEnq18RkdFtq6tx5AxKYSuiGHVR16l5Z6oKffV5WszefgUsvLAOdYu9mTtYs3gcORpO3b+7MyEsPgbyj1VU+6vln8OM1Mt2bTUjWGvXiMvx5xLp2zpOiSDlo/kEDra8KXx1c5vyvXme08Gj0hk9v+d57vFfqjVEPJmHMmJVmy9YS07D+98lu84yrovfVn3hWah5MizSnb95sq4GdHl9ea5RLwa5PPRpEbaffsPS6Rpq2yO73cmJdEKB2cVXfqn0Ll/KssX+BkcAKlW9nVuDBmVzJxvL7FqgaYNDJkcr6nza3XLfcWe06z9tD7rPtWc4Ik8Y8fOX1wYP+cyFhZqEi9bMXBksqbOv2Gg3BsUojDTXILl1yifTgNKy/1v48r99598GfRULLM+PsLqr5to2soJEaQk2bBtc3m9dffKY9mmnaxfFsz6ZZoyjYpwYtef9Rk38aym3ONtGTA0Dk/vPBbMbqXdd99OT0a+ZM2k0BNsWB7MlRglDQJyeG7sRa4l2nBgZ+VfxiqT2cUN57+v4f35JVIe9waFArfNVylysSSjq7t2O4uUAgLfPkXqYG/ShmjK3uX3RKwS88lt6oDK2RLL1EJc/kjCIrOIxBfLyz6/of7MD9W+VKwsFTo3ybhVv29uwKBn4pi16Birv2qkKfuXLpKSaMO2jQ2027l75bHs5z2s/zaI9d9o2sGoC47s+sOLcZPPa8r+qi0DnrysKfuZD+i9V8OmWQQE5/DNoiZG59XJvtGbwcOuMPuzk3z3eRBqYOQr0SQnWbPtx/KTlx7181i2JZx1SwJYv0RTplHnHdi1zYNxUy9q6vxVGwY+fRUvn3wWvH2/dt+SYjNWfNqQye+f49WZ59m3wx1vvzxCXovixCFnThysfJC/Mqbc1m9d68qQ0SmELo9m1Uf1NdmnJhjOvv8saxd7sfaT0uxnSrOHXtW2N9p2/tXyYyNNdneGvZpE3nUz3exjapLdlMvddLNr8td+vQFo9ECu5vigtJ/yb1xAp4EZABze4WhcP7XZl0FPxTHr439Z/X+NUQMjxl/U9FObym+Y4O6Vx7LNu1i/rCHrv72pn5p0rryfeqK0n5rVUrvvvn88GflSBJNCT7JhWcPyfurFSzXqp0z5uAxg2w9eDB6ewOyvzvLdp/6aY7M3YjXHZt+XD7J5eOezfPsR1n3lx7ovNXU68pySXVvcGPdOVOmxmQ0Dn03QHJu9Vd4XnT+h34/2fvwaRYVmnDrkbFRuIWpKBvPuMT179mTevHlMnz6dkydPEhISQmBgIPn5+URERLBhwwbs7e1RKBQMHz6cFStW0LNnTyZPnkzLli0pLCwkMjKSX375hZ9++gk7OzsmTpzIypUr6d27N2FhYTg6OvLVV18RERHBli1btO8dFhZGnz59ePzxxxk3bhwpKSmEhobi5eWFmVn1Gu9+/fqxatUqWrRoQXBwMJs2bWL//v0Gt3VwcGDq1KmkpKTQqFEj1q9fz19//cXKlSsNzvqrjhdeeIHQ0FBOnDjBxo0bjXqNGxXkW/DOaw/z4utnmDz7GKDmxL9uLP2kOfl55R9PBWBuodZ+OS7zyfutCJlwnpBxF7BXFhF9yZHZkx4iMsJZZzvnegWMe+MMTi4FZKZbc2CXF2u+bWLwTrq3lD/PnKlPN2JC6BWmfBqDQgHH9zrwdWgD8nPLZwYqFGBugV7+hZP9GT01nlFT4lE6FhN1zpYZI4O5dFp3SvyQ0cn0ebp81kOXwRl0KT3zGtLhfpKu3PpZ4II8c6aPuI9xM2OZsjASFHB8vxNL3vPXyY42u+7+i6Y2ZNRblwmZfAWlo4qoc3bMHN2UyDPlA3QtO2ZhZa2mUYtcFv3vrM7+SVesGN3FuDuPacq9IRNC45nyWVxpuSv5erZPBeWuu//Cib6MnpbAqKmJmnI/a8uM4UFcOqVb7ivn1SfvujmPjU3GxV3FlUhrPhjvz8G/ajZjxuTrzcj7GTcjmikfXwTUHD/gzJIPAgzXm5tWBF40PZhRk+IImRinqTfn7Zn5fDMiz5YPxMRcsOPhnmmMnRaDg7OKzDRLLkfaMvvFphzeWfkZ5qqyTxvWmPGzLzPlk2hNue9zYEmYr8Fyv7lZXjQ5gNFTrxLy1lVtuc8MaaRf7qOS6f1U+ezDLoPS6VJ6xn5Ux+bGlXu+Be+8/BAvTjzL5NAToFBz4ogbSxfdp9tWKtSG28r3HiDkpQuETLiAvVJF9EUHZr/RjsgL5TMO8q5bMvn5jgwfd5EnRkZRz7WAtFRrDu7xZN03jXTe51aprc258lZj3DdcxuvbaBRqyL3PkWvP+qK20Z1FrSgBhbo8f6GXDcpj6SiPZWCWV0yJjRl5wUqSRvuTH1T5pVu3Q0G+Be9MaMeLk84z+d2ToIATh11Z+nHTm8q+tJ+6qXv9JKw5IS9fJOSli9g7lJb9aw8SeV6/Hek56CoqlYKd227PDIeCPHPeHtuacVMv8tbcs5rsB11Y8tFNf8/S7GY31ZvFs+9j1GtRjHw1CqWDiugIJbNeaknkOQed7Xb8Uh91CTz5fBy9H0sgO9OSf37zYuWnQdx8x89bzW+qbb0mezATQq8y5bPY8uxzbs6uNtzOT/IrzZ5Qnn1EkF57s3J+ffJyzXjshRuyTwjg4F/GLyFi+uVumtnL89d+vRkyJpk+T5fPJNM5PnjoPuP7qZfa8+Kkc0wOO1HeVlbUT93cVr7bgpCXIgh5KaK8n3q9rYF+6mGGv3iJJ0ZGU8+tgLQUaw7u8WDdUuP7KVM+LivLP31Uc8a9Hc2UjyI0x/QHnFgyN6h6x2ZvN2LUxFhC3owtPzYbe7/OsZmohJqbl9AUd4hCrVZL0d+D9u3bx6effsq+fftITk7GxsaGJk2aMGDAACZMmKBdry4/P5958+axYcMGoqOjsbe3p2HDhgwcOJCZM2diYaHpNC5cuMC0adP4559/KCgooFWrVoSGhtKvXz+d9123bh1hYWHExMQQHBzM+++/z7vvvktAQACbN28GYOfOnXTv3p3t27fTq1cvnf1TUlJ49dVX+eOPPwDNpa9vvvkm7du3Z8WKFYwePRqA0aNH89dff/HDDz/wxhtvcOrUKTw9PZk8eTKvv/669vVWrlzJmDFjuHjxos4NPEJDQwkLC8PQx6Nv376cOnWKuLg47e9fFSdrLzr6DK/WtncbVdzVqje6i5lZGXdJ4t2gJF9/3RiTYVb7Cx7XFjNb077TsPqm9T5NibmX8bPf6trZMNO+xKbZTOPW1LsbqIuMW0fyblCcklr1RnczI0+O3hXkK1DdMeF6Y+Ftum29KsHw0kamwsy+8vXv7lbhOb+QWZxS9YYmytq/AfVnvFHXMWqN29LvOXLkSF3HMEgG80SdunLlCsHBwcyYMYNZs2bdttctG8y7cuX2fjlJT0/Hz8+PN998k/fee6/a+8lgXt2Rwbw6IoN5dUYG8+qGDObVHRnMq0MmPCgjg3l1yITrjQzm1R0ZzLs7yWBe3ZHLbMUdk5eXx6RJk+jVqxdubm5ERUXx0UcfYWdnx9ixY+s6XqWSk5O5cOECn376KSUlJbz88st1HUkIIYQQQgghhBD3IBnME3eMubk5iYmJvPrqq6SmpmJvb0/nzp358ccftZf13q22bNnCmDFj8PPzY9WqVXd9XiGEEEIIIYQQonYpQG26s21NmQzmiTvGyspKuy5ebVu5cuVtfb3Ro0dr1+MTQgghhBBCCCGEqCvG3f9ZCCGEEEIIIYQQQghxx1U4M8/MzAxFNRcnVSgUqFSq2xZKCCGEEEIIIYQQQgihr8LBvNmzZ1d7ME8IIYQQQgghhBBC3GPk5uB1osLBvNDQ0DsYQwghhBBCCCGEEEIIUZVbXjMvJyeH2NhYioqKaiOPEEIIIYQQQgghhBCiAtUezPvtt99o06YNTk5OBAUFcerUKQDGjh3LunXrai2gEEIIIYQQQgghhBBCo1qDeT/99BOPPvoobm5uzJ8/H7W6/KLowMBAVq1aVWsBhRBCCCGEEEIIIYQQGtUazAsLC2PMmDH8+eefvPnmmzrPNW/enNOnT9dGNiGEEEIIIYQQQghxt1L/h3/uYtUazDt37hzPPPMMgN4dbl1cXEhNTb39yYQQQgghhBBCCCGEEDqqNZjn6OhISkqKwediYmJwd3e/raGEEEIIIYQQQgghhBD6qjWY17t3bz788EMyMjK0jykUCgoKCvjiiy/o379/beUTQgghhBBCCCGEEEKUsqjORh988AHt27enSZMmDBgwAIVCwbx58zh58iSZmZn89NNPtRxTCCGEEEIIIYQQQtxV7vK15f6rqjUzLyAggKNHjzJo0CC2b9+Oubk5u3fvpkOHDhw8eBBvb+/azimEEEIIIYQQQgghxD2vWjPzABo0aMCyZctqM4sQ/1nqwkJUMXF1HeOeVJJfXNcR7k3qkrpOYLSS3Ny6jlAjZnZ2dR3BaOqCwrqOYLQm44/XdYQaCTxgXtcRjHbpYRNu581Mt9wBKDHhshd1xkyprOsIRlNdja/rCPeskuzsuo5gFLUJHxOLu1u1ZubdKD4+nsOHDxMfLw2ZEEIIIYQQQgghhBB3UrUH87777jsCAwPx9fWlQ4cO+Pr6EhgYyJo1a2oznxBCCCGEEEIIIYS426gBteK/+3MXq9Zg3hdffMHo0aNp1KgR33zzDb/88gvffPMNwcHBjBo1ii+//LK2cwohhBBCCCGEEEIIcc+r1pp5CxcuZPTo0Sxfvlzn8eeff57Ro0fz8ccf88orr9RKQCGEEEIIIYQQQgghhEa1ZuYlJiYybNgwg88999xzJCUl3dZQQgghhBBCCCGEEEIIfdUazGvRogWRkZEGn7t48SLNmze/raGEEEIIIYQQQgghhBD6qnWZ7aeffsqwYcNwc3Nj6NChmJubU1xczMaNG1mwYAEbNmyo7ZxCCCGEEEIIIYQQ4i6iUNd1gntThYN5vr6+KBTld+/IzMxk2LBhmJub4+LiQnp6OsXFxSiVSp555hliY2PvSGAhhBBCCCGEEEIIIe5VFQ7m9ezZU2cwTwghhBBCCCGEEEIIUbcqHMxbuXLlHYwhhBBCCCGEEEIIIYSoSrXWzBNCCCGEEEIIIYQQQoesmVcnbmkw78SJE1y4cIH8/Hy950JCQm5bKCGEEEIIIYQQQgghhL5qDeZlZGQwcOBAwsPDAVCrNUOvN66pJ4N5QgghhBBCCCGEEELULrPqbPTOO++QmprK7t27UavVbN68mb///pvhw4cTFBTEoUOHajunEEIIIYQQQgghhBD3vGoN5v3xxx+88847dOjQAYAGDRrQrVs3vvvuO3r16sWnn35aqyGFEEIIIYQQQgghhBDVHMxLSEggKCgIc3NzbGxsyM7O1j43dOhQtmzZUmsBhRBCCCGEEEIIIYQQGtVaM8/Ly4uMjAwA/P39OXDgAN26dQPg0qVLtZVNiHuCu3ch40PjadMlGxRwbI8DX8/xJvmqVZX7WlqXMGpqIj2GpqN0LCbyjC3LPqjP6YNKne0UCjVPv3KNASNTqeeu4kqkNWsXe7J3q/M9nV+y13W9uUqbzjfm9yE5vpr5pySU5z9ry7IPvPXyDx13jZYdc2j0QC6unipWL/RkzaL6JpFdW/YjUjRlH2XN2sVeNS57N68Cxs+IpvUjmSgUcGy/E0veDyQ5wbrq7FYlhEyMo8eQZOwdi4k6Z8fyBf6cPuyk3cbWvpg3514i+P7r1HMvRKVScDXalp+/q88/v7jXLLtnPuOmRNC6Q6om+8F6LP2oCcmJNtXIXszIV6LoMTABewcVURccWPFJMKePuuht6+qRz8hXImnbKRUHxyJSk63Z/bsXKz8Lrln++oWMn3OZNp2yQAHH9zrydZhv9evN5Hh6DE3VlP0ZO5Z96MPpQw462w0dm8QDHbNp/MB16nmoWLO4PmsWe9coN0BRopqUxSpyD5YAYNvODPfJFlh6KSrdL3WpirRvig0+p7CC4H2G6132n8UkzlBh4QGBW6qum5Ux5XIHcK9fyPjQK7TprMl/bK8DX8+5hfxT4unxeBpKp2Iiz9ixbK43pw/elP/FJFp2zC5vKxd5sWZRzfObcj8l2evu+MDNq4Dxb0fR+pGM0n7KmSVzA0lOqE5bX0LIm7H0GHyttJ+yZ/nHAZw+cmM/peLNDy4R3CynvJ+KseXn1d7884tHjbKbctmbcvb/Qn4hjFGtmXmdOnXS3vxi5MiRhIWFMX78eF555RWmTJlC3759azWkMB0HDhxg2LBhNGjQACsrKxwdHWnXrh2zZs0iISGhVt4zNDRU52YspsTatoT5P0TiG1zAgjf9WPC6Hz6BBXz0YyTWtoa/AN1o0sLL9H8uldULvJg9KpC0a5bMXRdF0P15OtuNmprIiMlJ/LrCjZkjgjh31I4ZS2Np1yPrns0v2euw3tiUMP+HS/g2LMvvX5r/UvXyf1ya/+P6zB4dRFqSJXPXRhJ0f67Odv2fS8XZVcWBP5wqeKW7N/uoqYmMmJTIryvcmTkyiHNH7ZmxJKZm9cammHmrz9AgKI+FU4NZ8FYjvP3zmb/mdLWyT/zwEv2eTmL1p36EjmtKWrIV7y8/R9B917XbWFiWUFys4PuvfQib0JSPJjXmcqQtUxde5LHR8TXK/uE3/9Ig8DqLZt3PxzPux8cvl3nf/lut7G+GnqPf0Kus/qohoa+1Ii3Fivf+7xhBTbJ1tvPwzmPx2sP4+OeyZH4TZkxow9r/C6K4uGZ9jLVNCfM3RODbMJ+PJwWy4M1AvAPzmf/9heqV/Uex9Hs2he8WejNnTDBp1yz5YM1Fgprp1pt+z6bg7FrE/j+ca5T3RiX5aq6+XERhjBrPUAs8wywouqzm6oRCSvLUle7r+Kg5DZZb6vz4fGkJ5mDfxfAhaHG2muSFKsxda57dlMtdm/+Hi/g2zGfBxAAWvBGgaW9+iKhmexNL/2dTWb3Qm9mjGpJ2zYK5ay/p5e//XArObioO3Mb8ptxPSfa6PD4oZt6qU5p+alpjFkxtjLd/HvO/q2Y/Nfci/Z5KZPVn/oSOb6bpp5adIahpjnYbC0s1xSoF3y9tQNhLzfhochMuR9oxdUEEj426anx2Ey57U87+X8gvhLGqNTNvzpw5xMdrDsKnTJlCamoq33//Pbm5uQwZMoTPP/+8VkMK07Bw4UKmTJlC9+7def/99wkKCiInJ4f9+/ezdOlSjhw5wrZt2+o65l2l/3OpePkXMrZzU+JjNLMPos7asGLfeQaOTGPT0opnsgQ1y6PH0AwWTvTlz+/rAXDygJKlOy8QMiWR0NGBADi5FvHEhGR++NKD/32tOeN4Yr8S74BCnn8ngcN/O96T+SV7Hdab4al4+RUytst95fnP2bBi7zkGjkxl09KKz4xr8qdr8v/gWp7/n/OEvJVI6Jgg7bbjujdFrVZgZq5mUEiq0XnvdHYn1yKeGH9NU/ZLysreAe+AAp5/O97osu/3TBJevvm82Kc1CXG2AERfsGPZ9qMMGJbE5hUVz8QJbHqd7kNSWDS9Ids3emqyH3JiydZjjHwjjrAJ9wGQnWHJR5Ma6+x7eJcLPoF59HnyGj+tNG62T7+hV/FqkMe4RzuScNlOk/2iA9/+sp8BT15h82r/irM3zqb7wEQWz27G9p8173/qX2e+3hTOiJcjefeNVtptX515ntRr1kwf+yDFKs1g0+l/9Wfv3XL+55Lx8itgbLf7SYjVzC6JPm/L8l2nGTg8hU3felac/75cejyexsLJ/mz/0Q2Ak+EOLP3rDCGT4wl9oXzG4Phezcrr/MiUGucGyNxcTNFVNf7/s8LKVzOoaR1sRswThWRuKsZleMWHkpaeCiw9dQdCs7YWQzE4DjQ8mJfymQrrxgrMXRXkHS6pUXZTLneA/sNTNPm7NiM+RpM/6pwtK/acYeCIFDZ9U3H+oPty6fF4Ogsn+Ze3N+EOLP37LCFvJRD6fEPttuN63JA/5PbkN+V+SrLX3fFBv6cTNf1Uvwdv6KfsWfbHEQY8k8jmlT4V7hvYJIfug5NZ9HYjtm8q7acOO7Fky1FNP/VSM6C0n3qric6+h3fXwycgjz5PJPHTqorfozKmXPamnP2/kF8IY1VrZl7Dhg3p3LkzAJaWlixcuJArV66QlpbGunXrcHW9DadPhUn7559/mDJlCm+88QY7duxg9OjRdOnShQEDBvD+++8TFRXFM888U9cx7zod+mRx/qidtuMBSLpszZnD9jzcN7PKfYsKFez6xVn7WEmxgl0/O/Ng12wsrTRfgtp2y8bKWs2OjbpfSP/e5EJQs3w8fQvuyfySvW6yazJkcv6oveH8farKn1mavzyXofwAavXtn7F7J7Jry35TPZ39/95Yw3rTI53zxx20X5AAkq7YcPaoIw/3Sqt8355pFBUq2L3FTTf7Fjce7JyhU+6GZGVYUlKD2W0PdUvmwkkn7UAeQNJVW84ed6JDt+TKs3dLpqhIwe4/ygc+SorN2PW7Jw92TMXCUpPdq0EubR9J5df1vtqBvNulQ+9Mzh+z1w4oQWm9OaKkQ5+MSvd9uLem3uz+tbw+lBQr2PlrPdp0yar1On99dwk2zRXagTwASx8Ftg8ouL7r1gfbsn4rxrwe2HXQL+O8EyVkbyvBfapljTKXMeVyh9L8R+21A3lQnr/qtr6C9uYXFx7sWvv5Tbmfkux1kx2gQ480zp+ooJ/qWflJOW0/tdVAP9UpHUvLqvopixr1U6Zc9qac/b+Q/79Aof7v/tzNbu/RqrhnzZ8/Hzc3N+bPn2/weXt7e0aPHq39d25uLtOmTSMwMBArKysCAwP54IMPKCnR7WgvXLjA448/jrOzM7a2tnTo0IHff/+9yjxZWVm8+uqreHt7Y21tTZMmTVi8eDFqte4n8ujRo3Tu3BlbW1t8fX2ZO3cuc+bM0blst0WLFjz++ON677Fz504UCkW18lTEv0k+Mef11wCJvWCDX+P8KvdNvGxFQZ7uxzj2gg1W1mq8Awq12xXmK4iPttLbDsC/sfGdjynnl+x1WG8a5xNzwUD+iGrkb1yaP/+m/BFl+Wv3YOpOZPdvXEHZR9honzeGX6NcYi/a6T0ee9EWv+BcA3vckD04l6Qr1hTkm9+0rx2WVmrq+92cSY2ZuRoH5yL6P5PIg50y2LzC+PUK/RpeJyZSqfd4bKQSv6DrBvbQ3Tfpqq1e9rhIJZZWarz9NL97s1YZABTkm/HB10f5+fAOvt+zk8nvn8bBqdDo7AD+jfKIvWCr93hshC1+jSr/e/o1ziOpDut8YZQaq4b6X3CtghQURt/aUW5Ropq8f9U49DNHYaH7mmqVmmsfqHAZaa4zcFgTplzuAP6N84gxlP+CTZX5K2xvLtjembbShPspyV53xwd+wbnERtjr579kV71+6qqNfj91qbSf8s+7aY8b+qmnS/spI2ePg2mXvSln/y/kF8JYFV4b8e6771b7RRQKBbNmzbotgYTpUalU7Nq1i6FDh2JlVfUioyqVir59+3L27FlmzZpFixYtCA8P57333iMtLY2FCxcCEB8fT6dOnXBwcOCLL77AycmJL7/8koEDB/Lbb7/Rv39/g69fUlLCwIEDOXr0KO+++y4tWrRgy5YtTJo0ieTkZObOnQtASkoKPXv2xNvbm1WrVmFlZcXixYuJiYnReb2XXnqJN954g/j4eLy9yzv5JUuWEBgYWKM1Ix2ci8nJNNd7PDvDHAenytd4cHBWkZNheN+y57XvkWUOKCrdzhimnF+y6+97Y6ZarzcGM1hUI39Fv7uF9vnadCeyV1z2NfsdHZxU5GTqd/vZmZYoHSv/ezo4q8jJMrSvhfb5Gw0ekcjLc6IBKCpU8PX7Aez4yfiFxR2cigy+f06mRdXZK9hXm92xCABXD80B+8Sws/z9W31+WB5Afd9cRr8eiV/QMd4c3t7oGUwOzsVkG/jb52SY4+BUddlnG/i75ZTWB2UNPovVUZwF5g76v7eZk4LibAM7VCJ7WzGUgOMg/XPJ6auKURepcRmtX07GMuVy12SouM2oTv6K+omy165NptxPSXb9fW/MVKvHB04V9TXV6Kcq6uMyLLXP32jw8ARenh0FlPZTc4PY8XPFl65XxZTL3pSza1/bhPMLYawKB/NCQ0Or/SIymHdvS01NJT8/Hz8/P73nVCrdhs3CwoL169ezd+9edu3aRZcuXQDo2bMnAGFhYUybNg0PDw8WLVpEeno6Bw4cIDhYszbNgAEDaNasGTNmzKhwMG/r1q3s3buXFStWaGcD9unTh+vXr7Nw4UImTZqEm5sbixYtIjc3lz/++IMGDRoA0LdvXwICAnReb+TIkUyfPp1ly5Zp63lycjKbNm0iLCzMZG++IYQQtWX3VjfOH3fA0aWIDj3TeGl2NCUlCrZt8KrraBVSlF5LcfKIC1992BSAE4fqkZtjwfSPTvNgx1SO7HOr7CVEFbK2lmDdRIF1I93BvMLLatJWFFP/I0vMrKVPFULUvt1b3Tl/wgFHFxUdeqTy0sxISoph2/c1v+u9EELcCRVeZltSUlLtn+Li2j27J0xTYmIilpaWOj8qlYrff/8df39/OnbsiEql0v706dOHoqIi7Z2Td+/eTYcOHbQDeQDm5uY8++yzHD9+nKwsw3cO2r17N2ZmZjz33HM6j48YMYLCwkIOHDgAQHh4OB06dNAO5AHY2toycOBAnf0cHBwYMWIE3377rfYy4JUrV6JWq3n++ecr/P2XLl1K27Ztadu2LUUYnnqdk2mO0sAZo4pmE+jta+DMetnZ9rJZPDmZ5igdiwF1pdsZw5TzS3b9fW/MVOv1xmAGVfXyG/zdVaW5bt+sngrfv5azV1z2Nfsdc7IsUBqYzVPRzLUbZVcwA65spsPN9SEzzZKLp5X8u8eFL0Mb8vfP7oydFoO5hXE3NMjJMjwrQ1nBLI7q7KvNnqWZtZGdqfnvsXDdtQqP7tesCxzU9Banod2YIdPw7AClc7HB2V+6+xqehVU2MyynBp/F6jB31Nxh9mYlmWrMHar/OvlnSiiKUeNg4MYXyR+rsG1rhk0LBcXZaoqz1ahVoFZr3rsk37hFa0y53DUZKm4zqs5fcT8Bd6itNNF+SrLr73tjplo9PsiqqK+pRj9VUR/nrJl9ffNnJjPdkounHTT9VFgwf//sUbN+yoTL3pSza1/bhPP/J6gV/92fu5ismSdqzNXVFRsbG+Li4nQed3Nz4/Dhwxw+fJgXX3xR+/i1a9eIjY3VG+hr3749oJnpB5CWlkb9+vpnx7y8vFCr1aSnpxvMk5aWRr169fQu+fXy8tI+D5CQkICHh/5lX56e+lPsX375ZeLi4ti6dStqtZqlS5fy+OOPG9y/zLhx4zhy5AhHjhzBEmuD28ResMG/if5aDn6N84mL0F/74eZ9vXwLsbbVPejwa5xPYYGC+Bgr7XZWNuVrPty4HUBshOFs1WHK+SV7HdabCBuD6775NbqF/DY35W9Ult/4XNVxJ7LHRlRV9pW/T4Xvf9EWfwNrDvkF5xF3SX8tvRvFXbLDs0EB1ja6B7x+wbkUFSpIiKs808VTSuyUJbi4Fd16cCAu0h7/hjl6j/sF5RAXpb++0o1iI+3x9MnTzx6UQ1Ghgvg4u9Lt9Nfku1FNbhIQG2GLf+Ob12vSrOkWd7GKehNhg6eBeuN/h+q8VZCCwij9wbTCaDVWgdUvk6zfisECHPrpf7EqjC4hd18JUT0KtT85f5RQnAxRPQpJ/dK4k8amXO5lGQzl92ucX438tobbm8Z5d6atNOF+SrLX4fHBJTv8GxnopxrmVq+f8snXb+sblvZTsfrrT97o4mkldvbFuLga10+Zctmbcvb/Qn4hjCWDeaLGLCws6NKlC9u3b6ewsFDn8bKZaTeuNefq6kpgYKB2oO/mn8GDBwNQr149EhMT9d4vMTERhUKBi4uL3nNl+6WlpelkKduv7HmA+vXrc+3aNb39k5KS9B5r3rw5nTt3ZsmSJezYsYNLly4xfvz4qoqmSuF/OnJfm1y8/Mpn7nk2KOT+dtcJ/7PyW5yHb3fE0kpN50EZ2sfMzNV0HZLB0d0OFBVqPt6H/3GgqFBB96G6g589n0gn+pwNSZeN73xMOb9kr5vs5fmv35S/QJN/u1P18g+uPH9tuRPZtWX/+E1lP7RmZX/w73o0bZWNl2/5Aa+HTz7N2mQTvsNwe1q+r4sme//yuwmamavpMjCVo3udqyz3Fu2zyM0xIyPVuLuUhu90p2mLLLx8yr/keXjn0axVJuG73CvPvssNS0s1nXqXt+1m5iV07pvE0QOuqIo02c+fdCQt2YoHO+re2ffBRzS/c8Tpyj9bleb/y4mmrfXrTbO2OYRvd648/1/OpZ/Z8vpgZq6my6B0ju5xrPU6b9/ZjPzTaoqulA/oFcWryTuhxr5L9d5bXaQme3sJ9h3NsHDRHwD0+sASn691f+w6KDB3Bp+vLXF62rhZZKZc7gDhfzobbm/a5hD+Z1XtjZPB/F0Hp9/BttI0+ynJXjfZobSfapmFVwMD/dTf9SrZU7OvpZWazv1SdPJ3GZCi6aeKquqnMsm9bk5GmpH9lAmXvSln/y/kF8JY9/h8UHG7TJ06ld69ezNt2jQWL15c6bb9+vVj48aNKJVKmjZtWuF2Xbt25ZNPPiEmJka7jl1xcTHff/89rVu3xtHRcOPctWtXFixYwI8//sjw4cO1j69duxYrKysefvhhADp06MDHH3/MlStXtJfa5uXlsWXLFoOv+/LLLzNixAjS09Np3LgxPXr0qPT3rI6ta+sxZEwKoStiWPWRF2o1jJqSSHK8FVtWu2q38/ApZOWBc6xd7MnaxZoZhpGn7dj5szMTwuKxsFSTGGfFoJBUvHwLmf9q+fqFmamWbFrqxrBXr5GXY86lU7Z0HZJBy0dyCB0deM/ml+x1WW9cGTI6hdDl0az6qL4m/9QEw/n3n2XtYi/WflKa/0xp/tCrWFioSbxsxaCQlNL8/jrv0+iBXDx9CzEz0wxC+DcuoNPADAAO73DUu8vj3ZJdU/buDHs1ibzrZrplP8b4st/2vSeDRyQy+//O891iP9RqCHkzjuREK7besJadh3c+y3ccZd2Xvqz7wleT/aySXb+5Mm5GNOYWapKuWDPwuUS8GuTz0aRG2n37D0ukaatsju93JiXRCgdnFV36p9C5fyrLF/hpB85u1e+bfBg87DKzPz3Bd180RK1WMPKVSJKTbNj2o0959vp5LPttP+uWBrJ+SRAAUecd2fW7J+OmRmjK/aotA5++gpdPPgvebq7dt6TYjBWfBjP5/bO8OvMc+3Z44O2bS8hrkZw47MKJQ5UPeFZm2zo3hoxKZs63l1i1QJM3ZHI8yQlWbF1bvg6fh08BK/acZu2n9Vn3qeYkWOQZO3b+4sL4OZe19WbgyGS8fAv46A3d+tDoget4NihEUVrn/Rrl02mA5ovH4b+djKrzTo+bk/ljMfFvFeH6kmZQLXVJMRae4DS0fJCtKEFNzOOF1HvBHNcXdQ8vr+8poSQTHA1cYgtg20L/8axfFSis1Ng9aPygkymXO8DWda4MGZNM6PJIVn3kXdrWl7Y3a3Tzr9x3hrWf1GftJ/XL8//swoTQKze09aXtzWsG8vsWYlY6zurfKJ9OA0vz7zAuvyn3U5K97o4Ptv3gxeDhCcz+6izffeqv6afeiNX0UzesZefhnc/y7UdY95Uf677UZIs8p2TXFjfGvRNV2k/ZMPDZBE0/9VYT7b79n0mgactsjh9wJiXRGgfnIk0/1S+V5R8HGN1PmXLZm3L2/0J+IYwlg3nitujZsyfz5s1j+vTpnDx5kpCQEAIDA8nPzyciIoINGzZgb2+PQqFg+PDhrFixgp49ezJ58mRatmxJYWEhkZGR/PLLL/z000/Y2dkxceJEVq5cSe/evQkLC8PR0ZGvvvqKiIiICgfcAPr370+nTp2YMGECycnJ3H///WzdupVvv/2Wt99+Gzc3zQHwpEmT+L//+z/69u3LnDlzsLa2ZtGiRVhbWxu8qcUTTzzBm2++yb59+7R33K2pgjxzpj7dkAmh8Uz5LA6FAo7vVfL1bB/yc8u/JCkUYG4BipuOLxZO9GX0tARGTU1E6VhM1FlbZgwP4tIp3UsRVs6rT951cx4bm4yLu4orkdZ8MN6fg38ZP9PE1PNL9rquN8FMCL3KlM9iy/PPuTm/ujS/7iV+Cyf5leZPKM8/IohLp3XzDxmTTJ+ny8+gdhmcQZfSWXEhD91H0pVbP4t6p7KvnF+fvFwzHnvhhrKfEMDBvyqfjVNV9ukj72fcjGimfHwRUHP8gDNLPgjQyU5ZvVHoZl80PZhRk+IImRiH0lFF1Hl7Zj7fjMiz5Zenxlyw4+GeaYydFoODs4rMNEsuR9oy+8WmHN5Z+ayKqrK//eKDjJtygbc+OAMKOHGwHksWNCY/74ZDGQWYW6gxuyn74tnNGPVaJCNfjUTpoCI6Qsmsl1sReV63Lu/41Ru1WsGTY2Lo/Wg82ZmW/LPFi5WfBnPzHexuNf+0YY0ZP/syUz6J1tSbfQ4sCfM1+Jk1u+kzu2hyAKOnXiXkrauaenPOlpkhjfTr/Khkej9VPnuyy6B0upTOzBrVsblRdd7MVoHP/1mRvEhF0hwVajXYtTPDfZIlZnY3lIka0F9OCICsLSWYOWlm+d1JplzuZfmnPt2ICaFXmPJpTGl748DXoQ0qaOtvam8m+zN6ajyjpsRr888YGayff3QyfZ4un5Gq01Z2uL8GbaVp9lOSvW6PD6aPas64t6OZ8lEEKOD4ASeWzA2qXj/1diNGTYwl5M3Y8n5q7P26/VSEvaafmhqt6afSS/upcc04vKtm/ZSplr0pZ/8v5BfCWAq1Wm3cqsJCGLBv3z4+/fRT9u3bR3JyMjY2NjRp0oQBAwYwYcIE7Rp4+fn5zJs3jw0bNhAdHY29vT0NGzZk4MCBzJw5EwsLzZezCxcuMG3aNP755x8KCgpo1aoVoaGh9OvXT/ueoaGhhIWFcWNVzsrK4p133mHjxo2kpqYSEBDASy+9xJtvvqkzUHf06FFef/11jhw5gqurKxMmTCAlJYXvvvvO4Jp848eP57vvvuPKlSu4urrqPV8RR0U9HlL0vOXyFMJkyV2e64yZXeXrCt3NFCacvaSCdVxNRfCB2r0hQm269LDp3ohNXWLih+Elplv2ou6YOdzC3XPuMiXZxt8MSdybDqp3kKVOq3pDE2Xt64vP5Il1HaPW1FuzjiNHjtR1DINkME+IGxQXF9OmTRvc3NzYsWOHznMqlYrg4GA6d+7M6tWrb+l1ZTBP3HNkMK/OyGBe3ZDBvLojg3l1SAbzhBFkME/cS2Qwz7TdzYN5t3SZ7cmTJ9m9ezepqamMHz8eLy8vLl26hKenJw4m3CiLe9esWbMIDg7G39+f1NRUvv32W06ePMnWrVu122RlZXH69GnWrVvH5cuXmTx5ch0mFkIIIYQQQgghxL2sWoN5BQUFjBgxgk2bNqFWq1EoFAwePBgvLy+mTp1K48aNmTdvXm1nFeK2UygUvPvuu8THx6NQKHjggQf46aef6N+/v3abo0eP0r17dzw8PPj0009p1apV3QUWQgghhBBCCCHEPa1aKxHPmDGDv/76i9WrV5OUlKSzNln//v35448/ai2gELXp3XffJTIykry8PHJzcwkPD+fRRx/V2aZbt26o1WqSkpJ49dVX6yipEEIIIYQQQghxl1H/h3/uYtWambd+/Xref/99nnvuOYqLddfGCAwMJCYmpjayCSGEEEIIIYQQQgghblCtmXmpqancd999Bp8rKSmhoKDgtoYSQgghhBBCCCGEEELoq9ZgXmBgIAcOHDD43KFDh2jSpMltDSWEEEIIIYQQQgghhNBXrcG8kJAQ5s2bx9q1aykqKgI0Nw74559/WLx4Mc8//3ythhRCCCGEEEIIIYQQdxeF+r/7czer1mDe1KlTGThwICNHjsTFxQWATp060atXL/r168drr71WqyGFEEIIIYQQQgghhBDVvAGGubk5GzZs4JVXXuGPP/7g2rVruLq60q9fP7p27VrbGYUQQgghhBBCCCGEEFRzMK9M586d6dy5c21lEUIIIYQQQgghhBBCVKJal9kKIYQQQgghhBBCCCHqXrVm5pmZmaFQKCrdpri4+LYEEkIIIYQQQgghhBAm4C6/UcR/VbUG82bPnq03mJeamsqff/5JQUEBo0ePro1sQgghhBBCCCGEEEKIG1RrMC80NNTg48XFxQwePBgnJ6fbmUkIIYQQQgghhBBCCGFAjdbMMzc35+WXX+aTTz65TXGEEEIIIYQQQgghhBAVuaW72RpSUFBAWlra7cgihBBCCCGEEEIIIUyFrJlXJ6o1mBcXF6f3WGFhIadPn2b69Om0bdv2tgcT4r9EYWmBhZtnXccwiioxqa4j1EwVN++5q6lNuGc05eymXGeAkuvX6zqC8Uw4u5mDQ11HqJGL7XPqOoLRkl57uK4jGM3zs/11HUGIO64kO7uuIxjNzN6+riMYrSQ3t64j1IjZA03rOoJRFBf21XUE8R9VrcG8gIAAg3ezVavVNGzYkC+//PK2BxNCCCGEEEIIIYQQQuiq1mDeihUr9B6zsbHB39+fdu3aYW5uftuDCSGEEEIIIYQQQgghdFU5mFdcXEyrVq3w9vbG3d39TmQSQgghhBBCCCGEEHcxhVrzI+68Ku9mq1AoaNu2LceOHbsTeYQQQgghhBBCCCGEEBWocjDPzMwMX19frpvwotRCCCGEEEIIIYQQQvwXVDmYBzB+/Hg++eQTCgsLazuPEEIIIYQQQgghhBCiAtW6AUZ2djaRkZEEBQXRr18/6tevr3N3W4VCQVhYWK2FFEIIIYQQQgghhBBCVDKYFxQUxObNm2nZsiVz587VPr58+XK9bWUwTwghhBBCCCGEEOIeo1ZUvY247SoczIuJiaGgoACAkpKSOxZICCGEEEIIIYQQQghhWLXWzBNCCCGEEEIIIYQQQtS9SgfzblwXTwghhBBCCCGEEEIIUbcqvQHGnDlzcHNzq/JFFAoFq1atum2hhBBCCCGEEEIIIcRdTl3XAe5NlQ7mHT9+HGtr6ypfRGbwCSGEEEIIIYQQQghR+yodzPvpp59o3779ncoihBBCCCGEEEIIIYSohNwAQwghhBBCCCGEEEIIE1HpzDwhhBBCCCGEEEIIIQxRyJp5dUIG84SoY26e+bw4+TytH0pDoVBz/JArSz9uQnKibZX7WloVM/LlS3Tvn4C9g4qoCAdWfNaIM0frabfpNfgqE8POVPgaI3p3JT216rUxK+LuXcj40HjadMkGBRzb48DXc7xJvmpVdX7rEkZNTaTH0HSUjsVEnrFl2Qf1OX1QqbOdQqHm6VeuMWBkKvXcVVyJtGbtYk/2bnU2Ond59qu06Xxjdh+S46uZfUpCefaztiz7wLvi7CNSNNmjrFm72Os2ZTfNcjf1/FJv6rLcTTM7gJtXAePfjqL1IxkoFHBsvzNL5gaSnGBTdX6rEkLejKXH4GvYOxYTdc6e5R8HcPqIU4X7dB2QzPTFF0hJtGJk15otmWLKdd7TIYe3eu6jQ8AVFAo1B2MasGDHIyRmOVS6X33HbKb23ksTjxTq2eWRV2RJZIoLK8NbszfKX2fb49P/z+BrPLP8KS5cq/pGcpUx5Xov2SX7vZbfzauA8TOiaf1IZmk778SS9wNJTqj6ONvSqoSQiXH0GJJc2s7bsXyBP6cPl7fztvbFvDn3EsH3X6eeeyEqlYKr0bb8/F19/vnFvUbZ70Q7P3TcNVp2zKHRA7m4eqpYvdCTNYvq1yh3GTe364wff4zWrZNQKNQcO+bFkiWtSU62r3LfUaNO0LhxGsHB6Tg6FrJwYXv++itIb7uJEw/StGkqbm65KBSQkKDkjz+C+O23YEpK5IJHcecp1Gq1jKMKUcucrDzo6Pa03uPWNsV8vuEARYUKVn/VCNQw8uVLWNsU88ozD1OQX/l4+1vvn6Rd5xSWf9KYxKu2DHr6Mg92TOGt0e2JinAEwNG5kPq+uTr7KRQwe/ExEq/aMimkQ6XvoUpMqvA5a9sS/m/7BYoKzVj5kReoYdTURKxtS5jQszEFeeaVvva0L2Jp3zOLb9/zJiHOisGjU2nXPYs3hzQi6kz5YOboaQk8MSGZVfO9uHjSjq6PptN/eBqzQwI5/Ldjpe9BBTfosbYp4f/+Ok9RQVl2BaOmJmiy92pSdfbPY2nfM5Nv3/fRZB+Vosn+aCOiztjpZh9/jVXz63PxlC1dH82g/3OpzB4VVHX2Cppnkyj3Stz1+Su5qZPUm7qpN6aQ3cyh4sEha5tivvz5GEWFZnz3iT9qIOSNWGxsS3hpSOsq80/9+ALtuqax7KNAEi/bMGh4Am27pDPpmQeIOq/U297eQcXSbf+CGkpKFNUazCvJyakg+91f55Nee9jg4zYWRfzw/I8UFpvx5e6HUAOvdD6EjaWKp5Y/TX6RZYWv2dAtjRHtTnAkzpukbCVK60KGtjxHl+BYJm3qy98R5V/0jk//P34+2YT/HW+m8xoXr7mSr6r4PQA8P9tf4XOmUO8lu2S/p44PADN7w4ND1jbFfPnrCYoKFXy32A+1WkHIxDhsbIt5aVCrqtv5hRG065bOsvkBJF62ZtCIRNp2yWDS0y2IOqd5TwfnIl6aHc3x/U5cu2qNpZWaLgNS6DU0mSUfBPDTSu9K36MkN9fg43eqnf9m5zlys825dNqWQSGptzyYZ/ZAU8P5rVV8+eXvFBWZ8913LVCrISTkFDY2Kl56qT8FBZV/n9q48X9ERTmTmKikV6+YCgfzpk/fz6lT7iQkaPrdNm0SefzxC/zyS2OWLGlT4euHX/iWzNz4av+epsamgS++r06q6xi1xul/azly5EhdxzBIZuaJO2blypWMGTOGixcvEhwcrPOcSqXC0tKSOXPmEBoaqt02OjqagICAar9+SUkJzz//fC2krx19H7+Cl08u44d2IuGyprOLvqjkm5/20f+JK/y0NqDCfQMbZdN9QCKLQ+/nr198ADj1rwv/9+N+RrwUybsTWwOQlWFFVobuWbX7W6fj5FLE2iUNa5S//3OpePkXMrZzU+JjNGcdo87asGLfeQaOTGPT0orPEgY1y6PH0AwWTvTlz+81MwlPHlCydOcFQqYkEjo6EAAn1yKemJDMD1968L+vPQA4sV+Jd0Ahz7+TYPRBY//hqXj5FTK2y33l2c/ZsGLvOQaOTGXTUo8qsqdrsv/gWp79n/OEvJVI6Jig8uzjr2myLynL7oB3QAHPvx1vfHYTLndTzy/1po7K3YSzA/R7OhEv33xe7PcgCXGaL5TRF+xZ9scRBjyTyOaVPhXuG9gkh+6Dk1n0diO2b/LU5D/sxJItRxn5RhxhLzXT2+eFKdFEn7cnLdmK1h0zjM4Npl3nh7Y6h49zFo8tfZbLGZrZLRHXXPll/DqebHWWNYdbVrhvZEo9wrZ113lszyV/try0hkcfOK8zmAdwLdueU/FeRuWsiCnXe8ku2e+1/P2eSdK0831a39DO27Fs+1EGDEti84qKB9oCm16n+5AUFk1vyPaNpe38ISeWbD2maecn3AdAdoYlH01qrLPv4V0u+ATm0efJa1UO5lXkTrTzAOO6N0WtVmBmrmZQSKpRWQ3p1y8SL6/rvPjiABISNCfWoqOdWbZsCwMGXGLzZsODgGWefPIJ1GoF9etn06tXTIXbzZvXUeffR4/Wx9U1jz59oiodzBOitsh8UHFXGjhwIAcOHKB+/eqfrVm5ciXLly+vxVS330Ndk7lwylk7kAeQFG/H2RPOdOiWXMW+1ygqUrDnz/IvDyXFZuz+04s2D6dgYVlS4b49B8VTVKhg1+81m9reoU8W54/aaTt+gKTL1pw5bM/DfTOr3LeoUMGuX5xvyK9g18/OPNg1G0srTf623bKxslazY6OLzv5/b3IhqFk+nr4FRmbP5PxRe8PZ+1SVPbM0e3mmSrNvqqez/98ba5rddMvd1PNLvXGuXvbbXu6mmx2gQ480zp9w0H7BA0i6YsPZo4483LPyLzQdeqZRVKhg99byyzVLihXs2uLGg53SsbyprW/WJovuQ5L58t2anazRvr8J1/muwTGcivfUDuQBxGc6cvyKF90aRd/y6xWrzcgpsKL4Dl1OZcr1XrJL9nstf4ce6Zw/XkE73yut8n3L2vktBtr5zhna7BXJyrCkpLjiqwqqzH4H2nkAtdr4jJVm6HCV8+ddtQN5AElJSs6edePhh69WuX9NcmVlWVNcg7IXoiZkME/cldzd3enQoQPW1sav5XY7FBQYf0BSHf5BOcRG6l8iFRdpj1+Q4Uueyvg1vE7SVVsK8nWnvsdGKrG0UuPta3gqvZV1MZ16JXFojzs5WZVf/lMV/yb5xJzXX+8p9oINfo3zq9w38bIVBXm6zVDsBRusrNV4BxRqtyvMVxAfbaW3HYB/Y+P+Rv6N84m5YCB7RDWyNy7Nnn9T9oiy7AXa7Qxmj7DRPm9UdhMud1PPL/WmjsrdhLMD+AXnEhuhf2lW7CU7/IINt9Xa/MG5JF210W/rL9lhaaWmvn+e9jFzixJef/cSG5f56HyhrAlTrvMN3dK4lFxP7/GolHoEuaVX6zUUqDFXlOBqn8u4R47gXy+TDf8219vuqTZnOPTWEg5M/oalz/5M6wY1v6TKlOu9ZJfs91p+v0a5xF6003s89qJt9dr5K9b67fzF0nbe7+bfXY2ZuRoH5yL6P5PIg50y2LzC+BP0d6Kdr01+flnExuqvIRsb64SfX9Ztfjc1ZmYl2NsX8sgjl+nVK5rNm5vc5vcwQer/8M9dTAbzxF1p5cqVKBQKYmJitI+tW7eO1q1bo1QqcXR0pEWLFixZsgSAbt26sWvXLvbt24dCoUChUNCtWzftvocOHaJXr14olUrs7e3p2bMnhw4d0nnP0aNH06BBAw4cOEDHjh2xtbVl6tSpDB48mNatW+tljI6OxszMjK+//tro31PpVEROlv7V7tlZligdVJXu6+BYRE62/mBcTqbmMQenIoP7PdztGvYOKnb8atxUfJ0MzsXkZOqvo5GdYY6DU3EV+6rIyTC8b9nz2vfIMgcUlW53qxyciyt4f4tqZK/o97bQPq/dzmB23e1ulSmXu/a1TTS/1Bv9fcue175HbZW7iWYHcHBSGW7rMy1ROlbR1jupyMk0sG+Gpfb5Mk+9eAVLqxK+X+JrdFa99zfhOu9kW0BWvv5Jwcw8axxtqvcF883uB/h32hJ2vLaKUe2PM+3n3hyKbaCzzW+nGzP3jy6M3zCY937vipNtAUuf/ZW2flXPCKmMKdd7ya6/742ZJHtFGUw3f4VtdXXaeeeK+ggL7fM3GjwikS3nD/DD4cO8NDuar98PYMdPFV8KW2X2O9DO1yYHh0JycvRv1JGdbYVSWXhb36t9+3i2bPmB//1vE++8s49ffmnE+vX6J3iEuBNkzTxxxxUXF6NSqfQeq8zevXsZMWIEr7/+OgsWLKCkpITz58+TkZEBwFdffcWIESMoLi7WDvA5OmrWvDh58iRdu3alWbNm2kHCefPm0bVrV8LDw2nZsnzNnMzMTIYNG8Zbb73F3LlzsbW1JTU1lYEDB3Lo0CHaty9fRHzp0qXY29szfPjw21Esd0zPwfGkp1pxeF/N7rAnhBDi7lHfL49hE67w3qv3UVQo52pvl7VHHuCPc8G42ucyuHkEHw75i7c292FPZIB2m5m/9dT+/7ErsPNiAP974Xte6XyIMWsfr4PUQoj/st1b3Th/3AFHlyI69EzjpdnRlJQo2Lbh9q7bKfSdPu3O66/3wd6+kJYtk3jiiQuAglWrHqjraOIeJIN54o5r2rTyRUgNCQ8Px9nZmU8++UT7WJ8+fbT/36xZMxwdHVGpVHTooHt31nfffRdra2t27NiBs7MzAL179yYgIICwsDA2bdqk3TYnJ4c1a9bw6KOPah8rKSkhKCiIJUuWaAfzioqKWLFiBcOHD8ehgjsYLl26lKVLlwJQWJJncJucLMNn6zSz7ir/eOZkW+BRX/91laUz8rIz9WftubgV0Kp9Gr9+70tJcc2/7OVkmqM0cMbOwbmYbANn6W7e16OB/uzBsjN4ZWf0cjLNUToWo5nnrKhwO6OyGzhb6OCsqmZ2/TN9ZWdOy87uVpxddzujsptouWtf20TzS73R31eT6Q6Uu4lmB8jJsjDc1lcwO/tG2VkWePjozyJzcC5r6zX7vzQzihPhTpw/7oB96cxuC0s1KDR3ty0qVFBYcOt1x5TrfFa+4Rl4Fc3YM+RatpJr2ZrlMPZEBvDtcz8zqccBncG8m+UWWrE30p/HHjhnVO4yplzvJbtkN4Yp58/JskDpZGQ7n2mBh7eBdt6prA3U3T8zzZLMNM1x/r97XLC2LWHstBj+/J8HxapbP76/E+18bcrJsTQ4A6+iGXs1kZtrxcWLmuUbjh/3QqUy49lnz/Lbb8GkpupfZi1EbZJTt+KO27x5M4cPH9b5CQ8Pr3Sfdu3akZ6ezogRI/jtt9+0M/KqY/fu3QwaNEg7kAeaWXtDhgxh165dOttaWloyaNAgncfMzMwYP348GzZsIDNTswjsTz/9RFJSEuPHj6/wfceNG8eRI0c4cuQIVmaG1y6KizK8Np5v0HXiovTX0tPZN1KJp08e1ja6na9fUA5FhQriL+t3KN0HxGNuob4tl9iCZn0R/yb6a2n4Nc4nLkJ/7Y2b9/XyLcTaVndRX7/G+RQWKIiPsdJuZ2VTvtbJjdsBxEYYt65ibISNwXWY/BrdQnabm7I3KsturX2PyrNX/j6Vvb+plrup55d6U0flbsLZQbO+nX8j/TWT/BrmEnep8oP/uEt2ePrk67f1DXMpKlSQEGur/Xf7bun870i49qf74GTcPAv535FwxkyONS67Cdf5yBQXGrrpLzwf5JZOVIqLgT2qdibBHV+XyheEL6O+6TK+W2XK9V6yS/Z7LX/sRVv8DayN5xecV712vkGBfjsfXNrOx1X+u188pcROWYKLm+EldqpyJ9r52hQb64S/v3677OeXSVyc8XdXro6LF+thbq7Gy+t6rb7PXU0Niv/wz91MBvPEHde8eXPatm2r8/Pggw9Wuk/Xrl358ccfuXz5Mo8//jju7u706tWLkydPVvl+aWlpBu+K6+XlRXp6us5j7u7umJvrn0F64YUXKC4uZvXq1QB8/fXXtG/f3uBaerfi4C4PmrbIxMunvPP3qJ9Hs5YZHNzlXvm+u92xtFTTqVei9jEz8xK69EniaLgrqiL9j3fPgQlERSiJirg9HVv4n47c1yYXL7/ys4meDQq5v911wv+s/D3CtztiaaWm86CMG/Kr6Tokg6O7HbSXiR3+x4GiQgXdh+r+rXo+kU70ORuSLht3kKDJfv2m7AWa7Nudqpd9cDWzP35T9qG3I7tplrup55d6U83stVLuppkd4ODf9WjaMguvBuVfljx88mnWJpvwv/Vv0HDzvpZWajr3S9HJ32VACkf3OlNU2tbPm9SEqSOb6/wc2eNMZpoFU0c255c1xi2Obsp1ftfFAFr4JOHjVL4AurdTFi19Etl1KeCWX0+BmtYNEriSXnmds7cqpHPDWE4nGL+GFZh2vZfskv1ey3/w73o0bZWNl6+Bdn5H5ScPDv7tosnev/zu5mbmaroMTNW081UsndCifRa5OWZkpBp3Y7s70c7XpoMHfWjaNBUvr/IJEh4eOTRrlkJ4uE+tvneLFsmUlEBCQuWTMISoDXKZrTAZTz75JE8++SQ5OTns3LmTadOm0a9fP65cuYKZWcUdRb169UhMTNR7PDExERcX3c5VoTB8Ft3V1ZWnn36aJUuW0LdvX/755x++/fbbmv1CwO+bfBj0TByzFh1n9VfBqNUw4uVLpCTZsG1j+QLb7vXzWPbzXtZ/E8T6bxoCEHXBkV1/eDHurQuYW6hJirdlwJOX8fTOY8GMFnrv1bBpFgGNcvhmYeMa5y6zdW09hoxJIXRFDKs+8kKthlFTEkmOt2LLalftdh4+haw8cI61iz1Zu1iznkfkaTt2/uzMhLB4LCzVJMZZMSgkFS/fQua/6qfdNzPVkk1L3Rj26jXycsy5dMqWrkMyaPlIDqGjA2uQ3ZUho1MIXR7Nqo/qa7JPTTCcff9Z1i72Yu0npdnPlGYPvYqFhZrEy1YMCkkpze5/U3Z3hr2aRN51M93sY2qS3XTL3dTzS72pq3I33ewA237wYvDwBGZ/dZbvPvVHrYaQN2JJTrRi6/flg2we3vks336EdV/5se5LTbbIc0p2bXFj3DtRmrb+ig0Dn03Aq0E+H71Vfge98yf0v+j2fvwaRYVmnDrkbHR2U67zG08045kHT/PJE9v4ck971Gp4ucthkrLt+d+x+7Xb1XfM5tcJa1m6ry1L97UFYEKnwzjaFHD8ihep1+1wtc/l8ZbnaO59jbd/6aXdN6T9cQLqZXA4zpvkHHvqO2YT0v4Ebspc3vm1p16mW2HK9V6yS/Z7Lf+27z0ZPCKR2f93nu8W+2na+TfjNO38DWvZeXjns3zHUdZ96cu6LzQ3K4o8q2TXb66MmxFd2s5bM/C5RE07P6mRdt/+wxJp2iqb4/udSUm0wsFZRZf+KXTun8ryBX4GT+RXx51o5wEaPZCLp28hZmaa6U7+jQvoNDADgMM7HPXuiFtd27Y1ZPDgi8yevYfvvmuBWq0gJOQUycl2bN3asDy/x3WWL/+NdevuZ9268ptWtGhxDSenAlxcNMsXNWqUTn7+ZQD27tX8jdq1i6dPnygOHvTh2jU7bG1VtGuXQL9+kWzbFkxa2u25g7wQt0IG84TJUSqVDBo0iKioKN544w1SU1Nxd3fH2tqa7Oxsve27du3K1q1byc7O1q5vl52dza+//qpzx9uqvPzyyzz88MOMHTsWJycnhg0bVuPfpSDfgnfGt+XFyReY/N4pUMCJQ/VY+nFT8vPKP54KwNxCjcJMd67vJ6H3E/LKJUJevoS9g4roCCWzX21D5Hn9L3U9B8WjKlKwc5vxt67Xy59nztSnGzIhNJ4pn8WhUMDxvUq+nu1Dfm75DEeFAswtQHFTH71woi+jpyUwamoiSsdios7aMmN4EJdO6V6OsHJeffKum/PY2GRc3FVcibTmg/H+HPzL+BmGmuzBTAi9ypTPYsuzz7k5u7o0u27ZL5zkV5o9oTz7iCAunb4p+/z65OWa8dgLN2SfEMDBvyo/01l1dtMsd1PPL/WmLsvdNLOX5Z8+qjnj3o5mykcRoIDjB5xYMjdIJz9l+W+6rmPR240YNTGWkDdjUTqqiDpvz8yx9xN5tvZnAphync8vsmTc+iG81XMf7w/agQI4FOvDgh2PkFdUPoNFoVBjYabG7IZyP5foxvB2J+l330WU1oWkXLcj4porz695jONXy/vRmDRnejSOpnvjaJTWhVwvtOT4FS/CtnXjdIKn0dnBtOu9ZJfs91r+gjxzpo+8n3Ezopny8UVAzfEDziz5IKB67fz0YEZNiiNkYlx5O/98M512PuaCHQ/3TGPstBgcnFVkpllyOdKW2S825fDOymd5V5X9TrTzQ8Yk0+fp8hmRXQZn0KV0Rl/IQ/eRdMW4WZEFBRZMn96dceOOMWWKZumm48c9WbKkNfn5N85WVGNurtYr+xEjTvHAA8nlOYdcZMiQiwD076/5vpeQoEShgJCQkzg7F5CTY0l8vAMLFz7Ezp26g5ZC3CkKtVp9l18JLP4rVq5cyZgxY7h48SLBwcE6z6lUKiwtLZkzZw6hoaHabaOjowkICGD27NkkJSXRvXt3vL29uXLlCrNnz8bBwYFjx44BMHHiRL766iu+++47GjZsiIODA02aNOHkyZM89NBDtGjRgmnTpqFQKJg/fz4nT57UuZvt6NGj+euvv7hy5UqFv0ObNm04duwYr732Gp999lm1f3cnKw86uj1tRKnVPVViUl1HqJkKZluaBGme64Yp1xmQelNHzCq4GZKpKMnRX7/VVCS99nBdRzCa52f76zqCEOIWmNnb13UEo5Xk6q/pZ0rMHrj1myjeDcIvfEtmbnxdx6g1Nj6++L0yqa5j1BrHTWs5cuRIXccwSNbMEybhoYceIiYmhokTJ9K7d2+mTZtG165d2bJli3abadOm0bNnT8aOHUu7du20N6d44IEH2LlzJ46OjowaNYqRI0eiVCrZtWuXdiCvup566imASm98IYQQQgghhBBC3BPU/+Gfu5jMzBPiFjzyyCOYmZmxZ8+eW9pPZubVIVOeZSXNc90w5ToDUm/qiMzMqzsyM08IcafIzLy6IzPz7k42Pr74vfwfnpm3+e6dmSdr5glRhYKCAo4ePcpff/3F/v37+fnnn+s6khBCCCGEEEIIIe5RMpgnRBUSEhLo2LEjzs7OvPPOOwwZMqSuIwkhhBBCCCGEEOIeJYN5QlQhICAAuRpdCCGEEEIIIYS4iXxVrhNyAwwhhBBCCCGEEEIIIUyEDOYJIYQQQgghhBBCCGEiZDBPCCGEEEIIIYQQQggTIWvmCSGEEEIIIYQQQohbppA18+qEzMwTQgghhBBCCCGEEMJEyGCeEEIIIYQQQgghhBAmQgbzhBBCCCGEEEIIIYQwETKYJ4QQQgghhBBCCCGEiZDBPCH+n737Dm+q+uM4/k73SvfehZatCIKA7CEbFFAcQAFluQUENxQ3G5yAg624QPTnYIhMAdm7pXTTvfdufn+kpISkg1Ss0e/refpo03tyPzmc3Jyce+65QgghhBBCCCGEEEZCBvOEEEIIIYQQQgghhDASMpgnhBBCCCGEEEIIIYSRkME8IYQQQgghhBBCCCGMhFlTBxDiv0BVXkFFWkZTx/hvUqmaOoHBTN3cmjqCwSozjLi9G3GbATD1cG/qCAarTM9s6ggGq8rPb+oIjaIwt2jqCAbzeO+Ppo5gMI/D9k0doVFSuxc2dQTDVVU2dYL/LNOQZk0dwWCVkdFNHeE/q+rMpaaOYBCVqqSpI9x6xt11NloyM08IIYQQQgghhBBCCCMhg3lCCCGEEEIIIYQQQhgJGcwTQgghhBBCCCGEEMJIyJp5QgghhBBCCCGEEOLmqEAha+Y1CZmZJ4QQQgghhBBCCCGEkZDBPCGEEEIIIYQQQgghjIQM5gkhhBBCCCGEEEIIYSRkME8IIYQQQgghhBBCCCMhN8AQQgghhBBCCCGEEDdPboDRJGRmnhBCCCGEEEIIIYQQRkIG84QQQgghhBBCCCGEMBIymCeEEEIIIYQQQgghhJGQNfOEEEIIIYQQQgghxM2TNfOahMzME0IIIYQQQgghhBDCSMhgnhBCCCGEEEIIIYQQRkIG84QQQgghhBBCCCGEMBKyZp4QTczNq4zpYVfp2DMPFHDqoJJV8/1IT7Kot6y5ZRUT5yTRb1QWdg6VRF2w4bO3vTl/VKm13eipqbS/O5+Q24tw8ahg4zJPNi3z/mvye5cxPSyJjr3y1fkPKFk135v0xAbmn5tCv9HZ2NlXEnXBms/e8uL8UTut7RQKFWOfTGPohEyc3Sq4GmXJ5uUeHPzZ8T+b3dWjhGlzLtOhayYKBZw66syaRS1JT7GqP7tFJROejKbfsGRslRVERyhZuyKY8yeddLZ1cS9hwpNRdOqRidK+nMx0S/b/6sm694IblV9d94l07Hl93fvcRLtPrqn7i9Z89pa3Tt2PnpZG+7sLatr9Ug82LfNqVO6a7Ebcbp6PoEOXLBQKFaeOurBmSQvSU6zrz25RyYQnoug3tLrdXFaydmWI/nbjVsKEJ6Lo1COjpt3s8GTd+yEGZ5djZRO2G69Sps9LoGOPPFCoOH3InlUL/ElPsmxY9tmJ9BuVia19BdEXbfjsHT/O/1lT9z5BJYwITaV9t3w8/UspLjTl8hlb1i/1IeaSTaOyG3O9A1SmVpG/soSyPytABRadzVA+Z4WpZ93n4ws+LaHwszL9f7QAj332AFTEV1L0XTnlJyqoTKpCYaPArLUpdtMsMQ8xbVR2Y37PGnO7MebsAK5uRUx76hwdOqWp+zcn3Fjz/u2kp9V/LJg49QIhLXMIbpGNvUM5y97pyO5fA/RuO2h4DKPHXsHTq4jUFBu+/yaYn38IalR2Y657Y87+b8hvzBSAQtbMaxIyM0+IJmRpVcXCryPxa17C4pmBLH42EJ+gUhZ9fRlL68p6y89aEseQhzPZuNSbeRObk5Vmxtubr9CsTZHWdkMeycDRtYLDOxz/2vzWVSz8Ogq/4FIWP+fP4mf81fm/iWpY/qUJDHkkk42LPZk3MYisNHPe/iKaZm2LtbabODeF8bNT+XGtK6+Ob8alkza8siaOzv3y/pvZrSp555MT+AYVsuy1tix5pS0+/kW8++mJBmV/LuwSg0cnsvGj5oQ9fQdZGRa88fEpmrXM19rO3buY5ZuP4RNQxOqFLXllRkc2f9yMykqFwdnV+atY+PUV/Jpfq/uA6rq/0sB2X133S7yYN6kZWanmvL05imZtb2z3mTi6VHB4h0Oj8mplN/Z2s+Y4voGFLJvXliWvtVO3mzUnsLRqQLuZf1Hdbj5uTtizd5CVbskbH56kWYsb2o1XMcs3/aluN4ta8soTHdm8unmj2o0cK5u23Sz8MgK/5iUsmR3E4pnN8A4sZeGWiAZln7kohsEPpbNhqQ/zH21BVpo5b22M0Kr7jr1yad8tn13fuTL/sRA+eDUAB5dyVnx/keB2hYZnN+J6B1CVqMh+qoiKuCrsX7PGfr41lQlVZD9ViKq47m9O1iMtcPrERuvH8T0bMAXLHjXn8suOVlJ+ogKroeY4LrZB+bwVqhwVWVMKKQ+vv45qY8zvWWNuN8acHcDSsoJ3VhzE1z+fZe/cyZK37sTHt5B3VxzE0qqi3vIjRkdjYVnJn4c969xu0PAYnp59mkP7vXlt7t0c3OvDEzNPM/TeaMOzG3HdG3P2f0N+IQwlM/PqsG7dOiZPngxAREQELVq00Pr7vn376NOnDwC7du1iwIABN/X8K1aswN/fn9GjR/8lea8XGBhInz59WLdu3U2VCwsLY8GCBahUjRter6qqYv369Xz88cdERkZSVlaGp6cnnTt3ZtasWdx1110Nfq5rdbx3795GZfonGjIuA0//Uqb0bkNSrHpGVfQla9YeuMCw8Rls/cSj1rLNWhfRb1Q2S2cFsPNrFwDOHlGyZs9FQp9PJuzR5pptp/Vrg0qlwMRUxfDQjL8u/yOZeAaUMaVnK5Ji1TM0oi9asfZQOMMmZLF1jVvt+dsU0290Dktn+rHzK2d1/sN2rNkbQeicFMImqc+OOriUM2ZGOl9/6M63q9wBOPOHHd6BZTz6cjLH9tj/57IPHp2Ip28x0+69m+QE9ZnqmEgln/7wB0Pvv8q2jfrPQgMEtcin77AUls9rw67t6tkL5044smrrEcY/EcXrz96h2fapV8PJTLPkxSl3UlmhPvdz/oTuLKybNWRcJp7+ZUzp1bqm7i9ZsfbgJYZNyGTrGvday6rrPltd99fa/WE71vweTujzKYRNbqbZdlrfVte1+8xG5wYjbzejEvH0KWbaqO417eaykk+3H1K3m031tJuhKSyf34ZdP/gAcO6EE6u+Pcz4J67w+nMdNNs+9coldbuZdn27MSiyhhwrm7DdPJyurvu+t5Ecp677mHAbPt97lmHj0tn6ae1fmoNaF9HvviyWPh/Irm/Ur/HsESVrdp0ndFYiYVPUMzX3/eDMj+vdUZ/fVzv9h5L1h85y36OpLJnVTN/T18uY6x2geHsZlUlVuGyxw8xP/V4yDzYlY2wBRd+XYftw7TMjTd1NMHXXPmdf/EsZVIL1UHPNY1b3mGF9vzkKRU3dW3QyI2N0PkVfleEwv/5Zu/oY83vWmNuNMWcHGDw8Fk+vQqZNuIfkRPWsqJgoBz7dvIuhI2PY9nXds7sfGDoclUqBl08BAwYn6N3GxLSKiVMusmenHxs+bat+nafccHYtZsKjl9jxv0AqK29+vosx170xZ/835BfGLyEhgZkzZ7Jr1y5UKhUDBgzQjPXcjHfffZeXXnqJ7t27c/DgwXq3l5l5DaBUKtm4caPO4+vXr0epVOop0TArVqxg69atjYlWq23btvHaa6/dkuduiOeff56pU6fSq1cvNm/ezPfff8+sWbPIyMjg6NGjN/VcH330ER999NEtStq0ut6TS/hJW01HFyA1wZILx+3oNii37rIDcykvU7Dvh5rBlapK9e939s7D3KJK87hK1biZVLVnyCP8pI3mgxOq8x+zbUD+vOr8jprHqioV7NvuyJ298zX5O/XJx8JSxW/faQ8i7dnqRLM2JXj4lf7nsnfpk07EWQfNgAxAaqI1F0870LVPet3Z+6RTXq5g/46aL1JVlSbs+9WDO+/OxMxcnd3Tt4hO3TP58Us/zYDMX6XrwGvtXk/dDzSw3d9Q93Br2r1Rt5ve6UScu6HdJFlz8YwDXfuk1Z29d3W72VkzcFNVacK+HZ7c2U1Pu9ny17YbOVY24bHynhzCT9lpBvI02Y8r6XpPTp1lu92TQ3mZgv0/Omtl3/ujMx175Wqy52Wbc/1AHkBRvhmJ0Va4eNZyqWhDshtxvQOUHqjAvK2pZiAPwNTbBPPbTCndX/8spRuV/FyOibMCiy415/JNHE20BvIATOwUmPqZUJVedeNTNJgxv2eNud0Yc3aALt1TiLjorBnIA0hNseXieWe6dk+ut3xD2kPrtlk4OpXx+y7tL9l7dvrj4FhG29sNO/lnzHVvzNn/DfmFcSsqKqJfv36Eh4ezfv16Nm7cSGRkJH379qWwsOFXF0RHR/Pmm2/i7l77pIYbyWBeA4wePZpNmzZpzVYrLi7m22+/ZcyYMU2YTFdpqfpA0qFDB5o3b17P1rdGcXExH374IU8//TRLlixh6NCh3HPPPTz55JPs3r2bJ5988qaer02bNrRp0+YWpW1aAS2KiY3QPesdF2GFf0hJPWVLSEmwoLRE+20cF2GNhaUK78Bb/6ES0LKE2HDdNdriIqzwb1FP/pbV+YtvzG9Vnb9Ms11ZiYKkGAud7QACWhj2Oo05u3/zQmKj7HQej4uyw79Z3R8a/s0LSU20prREey2k+Cg7zC1UePurL2Fqc0cOAKUlJry16iTbj/3GVwf2MvvN8ygdDP9yDeq2Gxuhp+4vN6Dua2v3l63+lnZv3O2mgNgrhrabglraja263fjd0G5KTXnr4xNsP7qbr/b9zuw3Gtdu5FjZhMfKkGLi9NV9pBX+IcV6StTwDykmNcFSp93EXa6u+4DaM9k5VBDYspiEK4bNDAPjrneAipgqzJrpdtXNmplQEXtzA22VqVWUnazEapA5CrO6BzyqclVURFdhGmj41wRjfs8ac7sx5uwA/oF5xMboznCKi7XHPzBfT4mbF1D9PLHR2vuJq96vf4Bh+zHmujfm7P+G/MK4ffLJJ0RHR/P9999z3333ce+99/LDDz8QFxfH6tWrG/w8jz/+OOPGjaN169YNLiODeQ0wYcIE4uLitKY6btu2jaqqKr2DeceOHeP+++/H19cXa2trWrZsycsvv0xxcU2nNzAwkLi4ODZv3oxCoUChUDBp0iTN38+cOcPIkSNxcnLC2tqa7t27c+DAAa39TJo0CV9fXw4fPszdd9+NtbU1c+fO1Tz/9c+Xnp7O9OnTadGiBTY2Nvj5+fHII4+QmJhY7+tfuXIlrVu3xtraGicnJzp16sS2bdtq3b6wsFBzWa0+Jibaze7MmTOMGjUKFxcXTX298847mr/36dNHc6nt9a9nxowZ+Pj4YGlpSatWrVizZo3WNuvWrUOhUHDkyBHGjRuHvb093t7ePPPMM5SUaB/YCwsLefHFF2nevDmWlpZ4enoyZswYUlNTNdvExMQwbtw43NzcsLS05I477qizHhpC6VhJQa7uAtP5OWYoHeo+6650rKilrKnmuW+12vObonSoe/9KxwoKcurKX1GzjzxTbpy1ceN2N8uoszuUU5Cnu0pCQa4Zdvb1tJtayubnqh9T2pcD4OKu7rzMXHCRxDgb5j3ZgbUrguncM5M3Pz6FohEr3SodK2upP7MG1H3t75lrf7+VjL7d5JvrPF6Qa46dsp52Y19OQZ5u2fzqx5QO1e3GTd2ZnTn/grrdPNWRtStD6Nwjgzc/Omlwu5FjZdMeK/P1ZC9oYN3rL6t+zK6OTE+8HgcK2PZZ7Zdj1seY6x2gKk+Fwl534M3EXoEq/+beSyW/lkMVWA3VfR/fKH9ZMajA5sH6b3BSG2N+zxpzuzHm7ABK+zL9n1N5FtjZlRv8vNezs1f3bwoKtPeTX71fpb1hJ56Mue6NObvmuY04/7+C6l/8U48ffviBrl27Ehxcc3PAoKAgunfvzvbt2xtUfV988QUnT57UGgNpCFkzrwECAgLo1asXGzdupGfPngBs2LCBUaNGYWenO8shPj6eO+64g0mTJqFUKrlw4QKvv/460dHRbNmyBVAPBg4dOpT27dsTFhYGgJub+nr+kydP0rNnTzp06MAnn3yCjY0Nq1atYsCAAfzxxx/ceeedmn3l5uby0EMP8fzzz/P2229jba3/DHZWVhZWVla88847uLm5kZSUxNKlS+nevTvh4eFYWem/A+bmzZuZPXs28+bNo2fPnhQXF3P27FmysrJqrS9XV1eCgoJYsmQJDg4ODB06tNbrxf/880/69OlDcHAwy5cvx9fXl8jISM6ePVvr8+fl5dGjRw+Ki4sJCwsjKCiIHTt28Pjjj1NaWsrTTz+ttf2ECRN4+OGH2bp1K4cPHyYsLAwnJycWLFgAQFlZGffccw9nzpzhxRdfpGvXruTm5rJjxw6ys7Px8PAgISGBLl264O7uzvLly3Fzc+Orr75izJgxfP/994wcObLWvEIYo2uDLmePO/HRO60AOPOnM0UFZry46Dx33p3J8UOuTRlR/ANdu1rv7AknPnpXfWbxzLHqdrPwnLQb0SAPPpFEv/uyWDYnUOvyXmG44l/KMWthgnlw3XeoLVxfSsnOCuxfttK6vFcIIYQQui5cuMC9996r83jbtm355ptv6i2fnZ3NzJkzWbRoEc7OzvVufz0ZzGug0NBQZs+ezXvvvUd2dja7d+/ml19+0bvt9bP1VCoV3bt3x97entDQUD788ENcXFzo0KEDlpaWuLq60rVrV63yc+bMwd/fnz179mBhoZ7KO2jQINq1a8cbb7zB999/r9m2oKCATZs26W1A12vZsiUrV67U/F5ZWUn37t3x9/fnl19+YdSoUXrLHT58mNtvv5158+ZpHhs6dGid+wL16PJDDz3E448/DoC3tzeDBw9m+vTpWje/eP7553FxceHIkSPY2KjXcerXr1+dz71y5Uri4uI4d+4cISHqhXAHDBhATk4OCxYs4PHHH8fMrKZpP/LII5qBuwEDBnD06FG+/PJLzWObNm3i8OHDbN++XWtQ7v7779f8f1hYGCqVin379uHiol6MedCgQSQkJDBv3jyDB/MKck2x03PGSD2boe63Z0GuKe6+umcPr52xztdzlumvVnt+/TM5bizr7qt7lrUmv1nNPuwrUZ8aUdS63X8qe5653hl4dg4Vemfd3VjW3Uv3koNrMyWuzbTKz1X/99QR7Q+Vk3+o23+zVvkGD8oU5Jpip2dmRW2zeG4sq7/dV+e/xe3e6NuNUnf/dg7lFOQb2G6qZ3Jeay817cZFa7uTh6vbTUvD2o0cK5v2WKlvZoNdA+vew0e37q+9/wv0ZBo6Lo3JLySybrEPO7+ufdHyhjDmegcwUSpQ5elOC6jKU6FQNnytuPILlVTGVaF8ru6ZdkVbyyhYVYrtdEusR1jUuW19jPk9a8ztxpizAxTkW+j/nLIv05lJZ/g+1M9jZ1dOdlZNnSir95ufZ1jbN+a6N+bsmuc24vzCuGVlZeHkpHuDQGdnZ7Kzs+stP2fOHFq0aKF1VWVDySm3BnrggQcoLS3lxx9/ZPPmzXh6etK/f3+92+bl5fHCCy9oLtk0NzdnwoQJqFQqIiMj69xPcXEx+/bt44EHHsDExISKigoqKio0d0XZv3+/1vbm5uYMHz68Qa/h448/pn379tjZ2WFmZqaZLRcREVFrmc6dO3P69Gmefvppdu/eTVFRUYP21bVrVyIiIvjll1+YPXs2gYGBrF+/nm7durFhwwZAvVjkoUOHGDdunGYgryF+/fVXunTpQlBQkKZ+KioqGDRoEJmZmVy8eFFr+2HDhmn9fttttxEfH6/5fefOnXh6etY5IPfrr78ydOhQHBwcdPZ55swZ8vJ0b0m+Zs0aOnXqRKdOnShH/zoKcZetCGihu+aQf4sS4iPrno0Qd9kaT78yLK20183xb1FMWalCaxHYWyUuwoqAlrpf8P1blBB/uZ78EVbq/NY35i+pzm+h2c7CqmbNiuu3A4i7bNjrNObs8VG2BDQv0M3erID4aNu6s0fZ4uFTjKWVdqfHv1kB5WUKkuJtqrfTnXV8vcYsOq5u93rqPuQm6v7Gdh9S8re0e+NvN7pr4/k3K6y/3UTX1m4K1e0m4Vq7qft5DL1Ruhwrm/BYGWmtt+4DgkuIj6x7Pbu4y9Z4+JXqtJuAkOq6j9PO1H9UBk+9Gce3azzY8oG3QXm19m/E9Q5g2syEihjdtfEqYqowu4n17Ip/LgMzsBpY+2BI8S9l5C8pweZhC+wmNf49YczvWWNuN8acHSA+VklAoG6f2j8gn/hYw286qLWP6rXxAoK09+Nfvd/4OMP2Y8x1b8zZ/w35xT9benq65jt9p06ddJb2aowDBw6wYcMGPv74Y52bUTWEDOY1kFKp5L777mPjxo1s2LCBcePG6az9ds3kyZNZtWoVzzzzDLt27eLYsWN8+OGHADprtd0oKyuLyspK3njjDczNzbV+PvjgA7Kzs6mqqjnYuLm5YWpa/xnK999/nyeeeIIBAwawdetW/vzzT44cOVJvptDQUD7++GOOHj3KoEGDcHZ2ZvTo0cTGxta7T0tLSwYPHsySJUs4dOgQFy9exNPTk1mzZgFoXouvr2+9z3W9tLQ09u/fr1M/DzzwAACZmdp3obpxuqqlpaXmRiHXtvfx8al3nxs2bNDZ55w5c/TuE2DatGkcP36c48ePY47+A/yRnY607liIp39NHg/fUtp2KuDIToc6Mx3Z5YC5hYqew2tG/E1MVfQekc3J/UrKy2792/vITntadyy6IX8ZbTsXcmRn3bdoP7LLvjp/juYxE1MVvUfmaOU/9ruS8jIFfUdrn9noPyabmEtWpCYY9uFp1Nn3utHqtjw8fWoG1929i2lzRy5H9tU9k+XoPlfMzVX0uKdmPUgT0yp6Dkrl5GEXKsrV2cPP2pOVbsGdd2tfUn9nd3Vbv3y+7jqqM/9Oe/3tvnMhR3bV1+6r635EznX5dev+VjHqdrPPjVa35Wq3G69i2rTPaUC7cdPfbgbe0G7OOajbTTftY+Kd3TMAuHzBsHYjx8ombDe7HGnVoQBPv5q+godvKW06FXBkt2OdZY/+5qjOPky77nuNyOLkAXutur97UDazlsTw6xY3Pn1L/9IcN53diOsdwLKHGeUXKqlIrOn3VSZXUX62EsueDZsFoipXUbK7AstuZpg46W/rJXvLyXurBOuR5iif+Wsuazbm96wxtxtjzg5w5JAXrdpk4+lVc+LJ3bOQNrdlcuSQl8HPe71LF5zJzbGg7z0JWo/3uyeBvFxzLp5zqaVk3Yy57o05+78hv9FTgeJf/OPm5qb5Tn/8+HGmTZum9fKdnJz0zsCrbcbe9aZPn85jjz2Gr68vOTk55OTkUFFRQWVlJTk5OVpjFvrIfNCbEBoayrBhw6iqquLLL7/Uu01JSQnbt28nLCyMZ599VvP4uXPnGrQPR0dHTExMePLJJwkNDdW7zfWDiA0dwd2yZQv9+/dn6dKlmsdiYmLqLadQKJg+fTrTp08nOzubnTt3Mnv2bB588EGOHj3aoH1f06JFCx588EGWL19OWloaTk5OmJiYNOgmHNdzcXHB3d1d67Lh67Vs2fKmns/V1ZXz58/Xu8+ePXvywgsv6P27t7dhMwh+/sKFkZPTCfs8ivWLvFGpYOKcZNKTLPhpU82laO4+paw7dIHNK7zYvELdmYm6YMPe7U7MCLuKmbmKlHgLhodm4OlXxsKng7T2E3J7IR5+ZZhUN5eAkBJ6VH+5Ovabg84d4xqcf7MzIydnELY2lvWLPKvzp6jzb6zpDLn7lLHu8CU2L/dg83L1jVGiztuwd7sjMxYkXZc/U53/qZovcrmZ5mxd48pDT6VRXGDKlXPW9B6ZQ/vuBYRNCtLJ9F/I/utWH0Y8lMC8lWfY8EFzVCoFE56MIj3Vil++qRmYdvcq5rP//cEXa4L4cnUzAKLD7dn3qwfT5l7GzExFSqI1w8ZexdOnhMUvtdOUrao0Ye3KYGa/eZGnXr3Eod/c8fYrIvTpKM4cc+LMn3V/ONXl580ujJyUQdjnMaxf5KWu+7nJ+uv+j4tsXu7J5hXVdX+huu7DEtX5E65r908FaO0n5PYidbs3UU8HC2hRSo9hOQAc+83eoHZv3O3GlxEPJjBv+Rk2fNQclQomPFHdbr6tOani7lXMZz8c4otPgvhyjfqu6NER9uzb4cG05yMwM6tSt5sHruLpU8ziV25oN++HMPv1Czz1ykUO/eahbjdPXaluNze3Fsg1cqxsunbzy5dujJyYxvxPr7B+iQ+oIHR2IunJFvy8uWYQ2N2nlLX7z7J5pTdfvKc+DkVdsGXvD85Mnx+vzp5gybDxaXj6lrLo2Waasu3uyufF96KIvmTDrm9daNWhZuZxeZmCqAt1z/isjTHXO4DNvRYUf1tG7twibKdbggIK15Ri6qHA+r6aSwErk6vIeKAA28mW2D2m/YWy9FAFqjxVrTe+KDtVQe78YsyCTbAaak7Z+ZolHBTmCsxbGnZJqzG/Z4253RhzdoBf/xfIiFHRzHv7CBs+ba3u3zx2kfQ0a375sea53T2K+OyLnXyxoRVfrm+lebxd+wwcHEtxclaffAhpmUNxsfrr7qF96uNSZaUJGz9rwxMzT5OZbs2pE26075jOPUPjWLWyPRUV/73jvDFn/zfkF8atbdu2XLhwQefxixcv0qZNmzrLXrp0iUuXLrFq1Sqdvzk5ObF8+XKee+65WsvLYN5NuOeeexg7diyOjo60bdtW7zalpaVUVlZibq7daVq3bp3OtpaWllp3uAWwtbWlZ8+enDlzho4dO9Y6++9mFRUVYW+vfWZi7dq1N/UcTk5OmkG8um6zXF5eTl5enmZtueuFh4djbW2Ng4MDlpaW9OjRg02bNjFv3rxab95xo8GDB/P+++/j7++Pu7v7Tb0GfQYOHMiWLVv48ccfGTFiRK37PHz4MG3btm1wzoYoLTZl7tgQZoRdZc7KWBQKOH1QyaowX0qKajrQCgWYmoHCRPsataWzA5g0N4mJc5Kws68k+pI1r0wI5sp57cuWR05KZ+DYmhlWvUbk0Kt6ZlNo17akXjXsbJI6f3NmhCUx57346vx2rJrnU0t+7fJLZ/ox6YVkJs5NUee/aM0r45px5Zx2/nXvelFcaMp9U9JxcqvgapQlb00P4Ohuw2eHGXv2l6beybQ5ETz/1gVQwJmjzqxe3IKS4usO6wowNVNhcsMdRJfPa8PEp6OY8FQUdsoKYi7b8doTdxAVrp3ptx+9UakU3D85lnvuTSI/15zff/Jk3cpgbryb183mnzs2mBlhicx5L66m7uffWPcq/e1+ln913SfX1P34ZrrtfnI6A8fWnCnTavddWhvU7o263ZSY8tL0O5n2/GWef+O8ut386czqxS212w3X2o12+eXz2zLxqStMeOK6dvNkB/3tpgrunxTLPSOr283PXqx7z/B2I8fKpj3evPBwS6bPS2DO8mh19kP2rH7dX2/2G7sty54PYtLcq4TOvlpd9za8OrEFV87XDNDdcXceFlYqQm4rYvnWcK3yqQkWTOzR3uDsxlrvAAprBU4f2JK/soS8Ber+okUnM5TPWWFic8N7qRK917GX/FyOwl6BZXf9Xf6yExVQBhURVWRP115KxcRTgds2wy45NOb3rDG3G2PODlBaYsZLM3sw7alzPP/KCfXn1Ak3Vn9w2w39G5Xe/s34yZe4vUOG5vcRo6MZMToagKG9a9YH//mHIFQqGP1gJGMeiiQtzZqPV7bnp++bYShjrntjzv5vyC+M28iRI3n++eeJjo6mWTP1MSQ2NpZDhw7x7rvv1ln2999/13nsueeeo7Kykvfff1/rDrn6KFQqQ1ew+fdbt24dkydPJjIystaK3Lt3L3379mXXrl0MGDAAgG7duhEVFcWSJUtwdXXl888/5/Tp00RFRfH777/Tp08fAEaNGsWhQ4f4/PPP8fT0xNXVlcDAQE6ePEmvXr3o1q0bjz32GF5eXmRkZHDy5EkqKys1jWLSpEns3r2bq1ev6uQKDAykT58+mkHEl156iYULF/Lmm29y1113sWfPHr799lsiIyOZP3++5o66YWFhLFiwgGvNYtq0aSiVSrp164a7uzuXL1/mpZdeokePHmzbtk1vnWRkZBAYGMiDDz7IgAED8PX1JTMzky1btvDVV18xd+5cFi5cCMCxY8fo3bs3LVq0YPbs2fj6+hIdHc3p06d5//33ATT1tXfvXkB9B9+uXbtSVVXFzJkzadmyJYWFhYSHh3PgwAHNLaBr+/e78TWWl5fTu3dvzp49y0svvUSXLl3Iz89nx44dPPfcc7Rq1Yr4+Hjuuusu/Pz8eOqppwgMDCQ7O5vz588THR3N559/Xmdbslc408V0YJ3b/GNV1X1Ld3HrmLo1bvH3plSZkVH/Rv9URv6xaOrR+JMcTaUyXXfJAqNh5MdKhXnjbnjQlFTlujdLMBYeh437S2Bqd911OI2Gkb9njZlpiOGDZk2tMjK6qSMII3NU9Rt5qqz6NzRS1l5+BD02q6lj3DI2v27m+PHjtf69sLCQ9u3bY21tzZtvvolCoeC1114jPz+fs2fPYmenXoc8Li6O5s2bM2/ePK2bi96oT58+VFRUcPDgwXqzycy8W+DLL7/k8ccf58knn8Ta2pqxY8eycuVKnRtVvPPOO0ydOpWxY8dSXFzMxIkTWbduHR07duTYsWMsWLCAZ555htzcXNzc3OjYsSMzZswwKNO8efPIyclh+fLllJSU0Lt3b3bs2KEZPa5N9+7dWbt2LRs3biQ3Nxdvb2/Gjx+vuROsPvb29syfP59du3YxZ84c0tLSsLKyom3btqxevZqpU6dqtu3cuTOHDh1i3rx5PP3005SWlhIQEMDkyZNrfX4HBwf++OMPXn/9dRYuXEhiYiKOjo60bNlS607CDWVubs7OnTtZsGABa9asYcGCBbi4uNC9e3fNenv+/v4cP36csLAwXn75ZdLT03FxcaFdu3ZMnDjxpvcphBBCCCGEEEIYPeM+D94otra27Nmzh5kzZ2puetq/f39WrFihGcgDUKlUVFZWat3/oLFkZp4QfwOZmScMITPzmoiRfyzKzLwmYuTHSpmZ1zRkZl4TMvL3rDGTmXniv+Q/MTPv0X/xzLwddc/Ma0pyN1shhBBCCCGEEEIIIYyEDOYJIYQQQgghhBBCCGEkZDBPCCGEEEIIIYQQQggjITfAEEIIIYQQQgghhBA3z7iXmzZaMjNPCCGEEEIIIYQQQggjIYN5QgghhBBCCCGEEEIYCRnME0IIIYQQQgghhBDCSMiaeUIIIYQQQgghhBDipilkzbwmITPzhBBCCCGEEEIIIYQwEjKYJ4QQQgghhBBCCCGEkZDBPCGEEEIIIYQQQgghjIQM5gkhhBBCCCGEEEIIYSTkBhhCCCGEEEIIIYQQ4ubJDTCahMzME0IIIYQQQgghhBDCSMhgnhBCCCGEEEIIIYQQRkIG84QQQgghhBBCCCGEMBKyZp4QfwOFiQkm1lZNHcMgVYWFTR2hcRSKpk5gsMqMjKaOYDBTZ6emjmCwqty8po7QKFVZOU0dwWAKU9OmjmA4E+M91gCoysuaOoLBFGbG251N7W7cn7FdT5U0dQSDHWlv3tQR/rNUSalNHeG/ycSIP2MBqiqbOoHQR4WsmddEZGaeEEIIIYQQQgghhBBGQgbzhBBCCCGEEEIIIYQwEjKYJ4QQQgghhBBCCCGEkTDeRUaEEEIIIYQQQgghRJNRyJp5TUJm5gkhhBBCCCGEEEIIYSRkME8IIYQQQgghhBBCCCMhg3lCCCGEEEIIIYQQQhgJGcwTQgghhBBCCCGEEMJIyA0whBBCCCGEEEIIIcTNkxtgNAmZmSeEEEIIIYQQQgghhJGQwTwhhBBCCCGEEEIIIYyEDOYJIYQQQgghhBBCCGEkZM08IYQQQgghhBBCCHHTFLJmXpOQmXlCCCGEEEIIIYQQQhgJGcwTQgghhBBCCCGEEMJIyGCeEEIIIYQQQgghhBBGQtbME+IfwNWzlOmvxNChey4KBZz6w4HVbwaRnmxZb1lziypCZ8bTb2Q6tvaVRF+y4fPFAZw/5qDZxtq2kufevkJw20Kc3cqoqFCQGGPN9g1e/P6DW6Oyu3mXMT0siY698kEBpw4oWTXfm/REi/qzW1YxcW4K/UZnY2dfSdQFaz57y4vzR+20tlMoVIx9Mo2hEzJxdqvgapQlm5d7cPBnx78geyIde16f3Yf0pAZmn5Nck/2iNZ+95a2TffS0NNrfXUDI7UW4eFSwcakHm5Z5NSq3sWcHcPUoYdrcK3TolqVu80ecWLMwhPQUq/rzW1Qy4akY+g1PxVZZQXSEHWuXN+f8CUet7db+ehgPnxKd8m88247Dewxv965eZUyfn0DHHnmggNMH7Vm1wK/hdT87iX6jM9Xv1ws2fPaOD+f/VGptN3pKKrffnU+L2wtxdq9g03IvNi33NjhzTfZSps+7ll3F6UP2rFrgT3pSA441llVMnJ1Iv1GZ2NpXEH3Rhs/e8dPK7hNUwojQVNp3y8fTv5TiQlMun7Fl/VIfYi7Z/Gezq/Mbb7sx5uO8Mdc7gJtXGdPDrtKxpzr/qYNKVs2/ifxzkug3Kgs7h0qiLtjw2dvenD96Q/6pqbS/O7/mWL/Mk03LGp+/NAXiFpuSe0QBKrDvoiJwbiWW9XyMJHxsQuIqU71/U1io6HKsAoC07Qqi59X+Vabjb+VYuBqW3ZjbvDFnB+kTN1m7MeJjDRh33f8ryJp5TUJm5hmhdevWoVAoUCgUXL58Wefv+/bt0/x99+7dN/XcK1asYOvWrTqPh4WFoVAoqKioMDh3UwgLC2PPnj06j0+aNInAwMC/P5AellaVvLvxAr7Nilk6N5jFz4fgHVDCwk3nsbSurLf8zHeuMHhsKhtX+hM2rRVZ6Ra8+fklmrUu1GxjZl5FZaWCr1b5sGBGKxbNakFClDVzl0Zy36Qkw7NbV7Hw6yj8gktZ/Jw/i5/xxyeolEXfRDUo+6ylCQx5JJONiz2ZNzGIrDRz3v4immZti7W2mzg3hfGzU/lxrSuvjm/GpZM2vLImjs798gzPblXFwq+v4Nf8WvaA6uxXGpZ9SXX2JV7Mm9SMrFRz3t4cRbO2RVrbDXkkE0eXCg7vcKjlmf5b2dX5K3nns9P4BhWx7NXWLHm5NT4Bxbz7+akG5X/u9QgGj0lm44dBhD11G1npFryx6gzNWubrbHv8oDMzx3XU+jl33LER2atYuOUyfs1LWDIriMXPBeEdVMLCryIa9n5dFMfghzPYsNSb+ZODyUoz561NkTRro133gx/OwNGlnD92GJ5VN3slC7+MUGefHcTimc3wDixl4ZaGZo9h8EPpbFjqw/xHW6izb4zQyt6xVy7tu+Wz6ztX5j8WwgevBuDgUs6K7y8S3K6wjmf/92ZX5zfidmPsx3kjrXdN/q8j8WtewuKZgSx+NlBd919fbuCxPo4hD2eycak38yY2JyvNjLc3X9HJP+SRDBxdKzj8F+avLIZLU80ojlHQ/I1Kmr9VSUm8gotTzKgsqrus++gq2m6s0PppvaYChZkKpz413xideqp0tmu7oQIzRxW2basMHsgz6jZvxNlB+sRN2yc2zmMNGHfdC9EYMjPPiCmVSjZu3Mgbb7yh9fj69etRKpXk5+t+sa3PihUr6NGjB6NHj/6rYjapBQsW8Morr9CvXz+tx1977TWeffbZJkqlbfCDqXj6lTB1YAeS460BiImw4bNdJxn6UCrb1tZ+xiqoVSF9R2aw7MXm7PrOA4Czfzqw+udTTHg2ngUzWgOQn2POolkttMoe2+eET1AxA+9P4/t1hp0VG/JIJp4BZUzp2YqkWPUZ0+iLVqw9FM6wCVlsXVP7Gc5mbYrpNzqHpTP92PmVszr7YTvW7I0gdE4KYZOCAHBwKWfMjHS+/tCdb1e5A3DmDzu8A8t49OVkju2xNyz7uEw8/cuY0qt1TfZLVqw9eIlhEzLZusa9nuzZ6uxfu9Rk/z2c0OdTCJvcTLPttL6tUKkUmJiqGB6aaVDWf1N2gMFjkvD0LWbaiC4kJ6hnPMVctuPT/x1l6AOJbNvgX2vZoBYF9B2WyvLXWrHre/X0jnPHHVm17U/GPxnD68/crrV9Xo45EWf/usHIwY+k4+lfypQ+bUmOU88ijAm35vN95xk2LoOtn3rUnr11Ef1GZbF0dgC7vlF/yzx7RMma3RcInZ1E2GPBmm2nD2hTU/cTMv6a7A9XZ+9723XZbfh871mGjUtn66eedWe/L4ulzwey6xu3muy7zhM6K5GwKSEA7PvBmR/XuwMKTdnTfyhZf+gs9z2aypJZzfQ9/b86Oxh3uzHm47wx1zvAkHEZ6vy925AUq84ffcmatQcuMGx8Bls/qT1/s9ZF9BuVzdJZATXH+iNK1uy5SOjzyYQ92lyz7bR+1+UP/Wvyp201oeQq3LG9AqvqQ7pNSAWnR5qR9q0JXqFVtZa19ABLD+1pHuk/KlBVKHAbUfPF3NwZzJ21t8s7qaAiR4Hv47U/f32Muc0bc3aQPnHT9YmN91gDxl33QjSGzMwzYqNHj2bTpk2oVDUdmeLiYr799lvGjBnThMn++Zo3b06HDh2aOgYAXftlE35aqem0AKReteLiSXu6Dciqu2z/LMrLFOz/qeb0c1Wlgn0/uXJnzxzMLeruzOblmFNVqahzmzr3PzCP8JM2mg9OgNQESy4cs6XboNx6y5aXKdj3g6N29u2O3Nk7X5O9U598LCxV/Padk1b5PVudaNamBA+/UgOz5xJ+0lZ/9oH1Zc+tzl6TSV92AJXK8Pr9N2YH6NIng4iz9pqBPIDURGsunrana9+6O3dd+2ZQXq5g/681A5ZVlSbs+9WDO7tnYWZu+Be4huh6Ty7hp2w1AwNQXffH7eg6MKfOst3uUdf9/h+dNY9VVSrY+6MzHXvl3fp2c08O4afs9GRX0vWe+rLn1JE9V5M9L9uc6wfDAIryzUiMtsLFs+w/mV2d34jbjTEf54243qE6/0lbzZdrqMlff93Xcqz/wYk7e9/6/Nl7FdjdrtIM5AFY+YLyDhVZe29+f+k/mmDuosLx7rqv5Ur/wQSFuQrXIYZ/Fhh1mzfi7CB94iY9VhrpsUadwXjrXojGkME8IzZhwgTi4uI4ePCg5rFt27ZRVVWlM5h37Ngx7r//fnx9fbG2tqZly5a8/PLLFBfXTB8ODAwkLi6OzZs3ay7TnTRpktbzxMTEMGzYMOzs7AgICOD111+nqkr7wzE9PZ0ZM2bg4+ODpaUlrVq1Ys2aNVrbXLtU+I8//mDs2LEolUo8PDx45513APj111/p0KEDtra2dO7cmRMnTmiV37lzJ0OHDsXLywsbGxvatWvH0qVLqaysOWOrUKg/MN566y3N6wkLCwP0X2ZbWFjIiy++SPPmzbG0tMTT05MxY8aQmpoKQEpKChMnTsTb2xtLS0u8vLwYPnw4aWlpdf0z1cs/pIi4SN31mOIirfEPrvtalIDgIlKvWlJaor22TFykDeYWKrz8b1wvTIWJqQqlYzlDHkzhzh45bFtr+BpoAS1LiA3XXeMsLsIK/xa6a5XdWDYlwYLSYu3DUFyEFRaWKrwDyzTblZUoSIqx0NkOIKCFYR+eAS1KiI3Qk/1yA7K3qM5eckP2y9ey39oPdGPODuAfXETsFTudx+Ou2OLfrO4279+8kNSrVjptPj7KFnMLFd7+2pdEdOmdwdY/97H9xF6WbTpBt37pjcoeEFJMXIS1zuNxl63xD6m77v1bFJPalO2mtuyRVviHFOspUcM/pJjUBD3HmsvW6uwBtWe3c6ggsGUxCVd0991QxpwdjLzdGPNx3ojrHSCgRTGx+vJHWNWbv9ZjfYT135K/OEqBTXPdgTeb5iqKo2/uC31pCuQdU+A6tApFHdcUVZVA1i4FTr1UmDViQrZRt3kjzg7SJ266PrHxHmvAuOteiMaQy2yNWEBAAL169WLjxo307NkTgA0bNjBq1Cjs7LS/KMfHx3PHHXcwadIklEolFy5c4PXXXyc6OpotW7YA6oHAoUOH0r59e82gl5ub9rTkUaNGMXnyZGbOnMmPP/7I/Pnz8fPzY/LkyQDk5eXRo0cPiouLCQsLIygoiB07dvD4449TWlrK008/rfV8EydOJDQ0lGnTpvHNN9/w8ssvk5OTw88//8wrr7yCnZ0dc+fO5b777iMqKgoLC/UBNDo6mv79+/P0009jZWXF8ePHCQsLIz09nXfffReAw4cP061bNyZNmsT06dMB8PX11VuXZWVl3HPPPZw5c4YXX3yRrl27kpuby44dO8jOzsbDw0MzeLp48WL8/PxITU3lt99+o6ionsVf6qF0qKAgV/etmJ9rjp193WsUKh0rKMjTV9ZM8/frjRifwhPzYwAoL1Ow6s1Afvu+9ksy66N0rKQgV3eR6vwcU5QOda9RoXSsoCBHf9lrf9fsI8+UG2fM3LjdzVI6Vtayf7MGZK/tdZtp/n4rGXN2AKVDud52W5DXgDbvUE5BnrnO45o271CueezoPhcun7cnNdEKR5cyRjycyGsrz7P4pdb8/r/aL8usc/+OleTrqb+CHFOUDvW/X/P1vNcLquvezsC23FC1ZzdrYHb9rxvqzv7E63GggG2f1X6ZTn2MObs6g3G3G2M+zhtrvasz1H68bkj+2v7drj33rVSRC2Z6rjozc4CKm1xeKuMnE6hS4Dqy7plVWb8rqCxQ4Dqyca/N2Nu8sWYH6RPrK3vt75p9/K3t5p9/rLm2D2Ot+38FFXIDjCYig3lGLjQ0lNmzZ/Pee++RnZ3N7t27+eWXX3S2u36mnkqlonv37tjb2xMaGsqHH36Ii4sLHTp0wNLSEldXV7p27ap3f7Nnz9YM3A0YMIA9e/bw5Zdfah5buXIlcXFxnDt3jpCQEM12OTk5LFiwgMcffxwzs5pmN2HCBF577TUA+vTpw7Zt21i2bBmXL18mKEi9RkFVVRX33nsvhw8fpnfv3gDMmDFD6/X07NmTsrIylixZwttvv42JiYnmNfj4+NT6eq7ZtGkThw8fZvv27YwcOVLz+P3336/5/8OHD/P2228zbtw4zWMPPPBAnc/7T7P/Z1fCTyuxdyqna/8sHp8XQ1WVgl+2GDawIcQ/2ap3tNfEOfybG8s2n2DSs9EGD+aJm/PgE0n0uy+LZXMCtS51NAbGnF2If5P0H02waaXCtkU92/1ggrmzCqce8q1S1E/6xEIIYyeX2Rq5Bx54gNLSUn788Uc2b96Mp6cn/fv319kuLy+PF154QXMJqbm5ORMmTEClUhEZGdng/Q0bNkzr93bt2hEfH6/5/ddff6VLly4EBQVRUVGh+Rk0aBCZmZlcvHhRq/yQIUM0/29mZkZwcDAtWrTQDOQBtGrVCoCEhATNY8nJyUyfPp2AgAAsLCwwNzfn1VdfJScnx6DLXnfu3Imnp6fWQN6NOnfuzOLFi1m5ciXnzp3TWqtQnzVr1tCpUyc6depEmar2Kd4FeWbY6TnrVdvspevl55rpPVN57SzatdlW1+RmmRN53o4TB5z4MKw5e7a7MeWFWEzNDFtbpiDXFDs9Z7xqmw2hU1bP2bprZ/CuZS/INcXOvpIbT/ncuN3Nqn3/+mfx6JTV+7qv1Xvd5RvLmLNDdZvX027t7Otv8+rZe+U6j2vafK7urL1rqqoUHNzphptnKU6uhl0OUZCr/yyvnWOl3lk82mX1n+G+NsOnwMC23FC1Z9c/A6lhZdWP6cs+dFwak19IZN1iH3Z+Xfvi0w1hzNnry2AM7caYj/PGWu/qDLUfrxvS7mv7d4Nbf6w3s9c/A6+2GXu1KTinoCRGgVs9s/LK0iH3qAKXei7FbdA+jbzNG2t2kD6xvrLXZ//7280//1hTX4Z/et0L0RgymGfklEol9913Hxs3bmTDhg2MGzcOExPdf9bJkyezatUqnnnmGXbt2sWxY8f48MMPASgpqXstges5Oztr/W5paalVPi0tjf3792Nubq71c20GW2am9h0xnZy0FxG1sLDQ+9j1Oauqqhg5ciT/+9//ePXVV9mzZw/Hjh3jlVdeuenXc01mZiY+Pj51bvPVV18xcuRIFi1axO23346Pj4/eNQOvmTZtGsePH+f48eNYKGqf1REXaU2AnnVA/IOLib+iu27I9eKv2ODhW4qllfaHkH9wEeVlCpLj655NEnnODhu7KpxcdQdHGiIuwoqAlrr17d+ihPjLde87LsIKT78yLK2168+/RQllpQqSYi0021lY1axZcf12AHGXLTFE3GUrAvSso+EfchPZrW7IHnItu2GZGsqYswPEX7EloHmhzuP+zYuIj667zcdF2eDhW6Lb5psVUl6mICm+gWubGThxI+6yNQEtdNdoCwgpJj6ynrq/bIWHnroP+LvaTWQt2YNLiI+su97iLlvj4ad7rAkIKVZnj9PO3n9UBk+9Gce3azzY8oFhdwb8t2S/lsFo241RH+eNt96vZdCX379FSQPyW+s/1rco/lvyWzdXURyluzZeUbQC62YNPwCn/6hAYVb/DS0yfjKBSgVuIxp/EySjbvNGnB2kT9y0fWLjPNaAcde9EI0hg3n/AqGhofz000+cO3eO0NBQnb+XlJSwfft25syZw7PPPkvv3r3p1KkT1taNW9BbHxcXF+6++26OHTum96dTp06N3kdUVBTHjx9n4cKFTJ06lZ49e9KpUydMTQ0/8+Pq6kpiYmKd27i7u/Phhx+SmJhIeHg4kyZNYv78+axevdrg/QIc3eNMqzvy8fSr+RBy9ymhTcd8jvzmVEdJOLrHCXMLFT2H1AySmpiq6DUsk5MHHSkvq/stfttdeRQVmJCTWftsproc2WlP645FePrXzHLy8C2jbedCjuys+9T7kV326uzDc7Sy9x6Zw8n9Sk32Y78rKS9T0Hd0tlb5/mOyiblkRWqCYR+e6uyFN2QvVWffVffK2ZrsI+rOfqsYc3aAI3tdaXV7Hp6+NR1Hd+9i2tyRy5HfXesoCUf3umJurqLHwJoZuCamVfQcnMbJP5ypKK89/7Xt0pIsyc40sN3sdqBVB926b9OpgCO7HOvOvtuxus3XtGUTUxW9hmdz8oD9rW83uxxp1aFA61ijyb7bsc6yR3+rzj7shuwjsnSy3z0om1lLYvh1ixufvuWv7+n+U9nByNuNMR/njbjeAY7sdNR/rO9UwJGd9R3rHfTm7z0i+2851jv1UZF/TkHJ1ZrHShKh4LQCp94NG8yrKofMX01w7KHC3LnubdN/NMGmhQrbVo0IXc2o27wRZwfpEzdduzHeYw0Yd93/Gyj+5T//ZDIf9F/gnnvuYezYsTg6OtK2bVudv5eWllJZWYm5ufaH07p163S2tbS01LrD7c0aPHgw77//Pv7+/ri7G76IbF2u3XDi+tdTXl7O5s2bdba1sLBo0OsZOHAgW7Zs4ccff2TEiBH1bt+yZUvefvttVq1axfnz528iva5fvvJgxPgU5n0czobl/qhUEPpcPOkpFvx83bod7t4lfP7bSb740I8vPvADIOqiHfv+58K0V2IwNVORetWSYY+k4OlbwqJZIZqyQx5KodUd+Zz+w5GMFAuUjhX0GpJBzyGZfL7Yv84BkLr8vNmZkZMzCFsby/pFnqhUMHFOCulJFvy00aUmu08Z6w5fYvNyDzYvV7+mqPM27N3uyIwFSZiZq0iJt2B4aCaefmUsfKrmS3Rupjlb17jy0FNpFBeYcuWcNb1H5tC+ewFhk4J0MjU8uwsjJ2UQ9nkM6xd5qbPPTdaf/Y+LbF7uyeYV1dkvVGcPS8TMTEVKggXDQzOqswdo7Sfk9iI8/MowMVF/eQloUUqPYTkAHPvNXufuX//27AC/fufNiIcTmffeOTa8H4RKpWDCU9Gkp1ryyzc1M6HcvUr47OcjfLE6gC9Xqf+to8OV7PvFnWkvXFHnT7Ri2NgkPH1KWPxiG03Z3kNS6do3g2MHXMhIscTRpYzhDyUS0qaAd+e00cnUUL984crIienM//QK6xerZ/OGzk4iPdmCnzfXDES6+5Sy9sB5Nq/04ouV6tcUdcGGvT84MX1+gqbuh01Ix9OvlEXParflkNsL8fAtQ1Fd9/4hJfQYqu5AHtvjYFDd//KlGyMnpqmzL/EBFYTOTqzOXnMpqbtPKWv3n2XzSm++eM+nOrste39wZvr8ePX7NcGSYePT8PQtZdGzzTRl292Vz4vvRRF9yYZd37rQqkOB5m/lZQqiLtjedG5jzw7G3W6M+ThvzPUO8PMXLoycnE7Y51GsX+RdXffVx/pN2vnXHbrA5hVebF7hVZN/uxMzwq5eV/fVx/qn9eT3K8Ok+ltLQEgJPaoHv4/9Zlh+99FVpGwxIeJZM/yeqgQFXP3QFAsP8HigZgZMaRKcGm6G77QqfGdoz4zJ2aegIleB24i6F7AvvATFVxQEzP5rFto35jZvzNlB+sRN1m6M+FgDxl33QjSGDOb9C5iamvLll1/W+ncHBwe6du3K0qVL8fLywtXVlc8//1zvTLQ2bdpw4MAB/ve//+Hp6YmrqyuBgYENzjJz5ky++uorevbsycyZM2nZsiWFhYWEh4dz4MABtm/fbshL1NK6dWsCAgJ45ZVXMDU1xdzcnOXLl+vdtk2bNvz0008MHjwYJycnvL298fbWvWxq/PjxfPLJJzz88MO89NJLdOnShfz8fHbs2MFzzz2Hl5cXAwYMYNy4cbRq1Qpzc3O2b99OdnY2AwcObNTrKS025cUJbZn2SgxzlkQCKk4fdmT1W4GUFF0321ABpmagUGif0V72YjATZ8UTOjMeO/sKosNtefXRNkRdrLmjcWyEDd36ZzHlhViUjhXkZpmTEGXNvKmtOLa3ntPd9WSfO7Y5M8KSmPNePAoFnD5ox6p5PlrZFdey3/AZvXSmH5NeSGbi3BTs7CuJvmjNK+OaceWc9qUU6971orjQlPumpOPkVsHVKEvemh7A0d03sfCO3uzBzAhLZM57cTXZ59+YXVWdXbvel87yr86eXJN9fDOunNfOPnJyOgPH1pzF6zUih17Vs+JCu7Qm9erNn8kz5uzX8r/02B1Mm3uF59++BAo4c9SJ1QuDKSm+7mNJocLUTKXp9F2z/LVWTHwmmglPx2CnrCAmwpbXZtxO1CWlZpuURCscnct4bPYVlPYVlBSbEnlRyavTb+fkHy4YqrTYlBceasH0eQnMWRGjrvtDSlYv8NPb5m9c9WDZ7EAmzU0k9PlEdd1fsubV0BDdup+Yzj0P1Mwu6DU8m17VZ70n3t3O4HbzwsMt1dmXR1dnt2f16/4Ny/58EJPmXiV09tXq7Da8OrEFV87XDHLdcXceFlYqQm4rYvnWcK3yqQkWTOzR/qZzG3t2TX4jbjfGfJw31nq/ln/u2BBmhF1lzsrY6rpXsirMt5a6v+FYPzuASXOTmDgnSZP/lQnBuvknpTNwbFZN/uuP9V3bGpTf1AbafFJB3GJTol4xRaUChy4qAuZUYnrd7lUqoFKBvmWI0380wcxBhWM9M/nSfzBBYabCZVjjL7EF42/zxpr9Wn7pEzdVuzHOY01NfuOseyEaQ6GqbxV/8Y+zbt06Jk+eTGRkJMHBwXq32bt3L3379mXXrl0MGDCA2NhYHn/8cQ4ePIi1tTVjx45lyJAhDB8+nN9//50+ffoAEB4eztSpUzlx4gTFxcVMnDiRdevWERYWxoIFCygvL9e6G+2kSZPYu3cvsbGxmseys7N5/fXX+f7770lMTMTR0ZGWLVsyZswYnnvuuTpfQ58+faioqODgwYOax2JjYwkKCuKTTz5hypQpAJw+fZqnnnqKkydP4uzszKOPPoq/vz9Tp04lJiZGMwB56NAhnnnmGS5cuEBpaSnz588nLCxMb+6CggIWLFjA119/TXJyMi4uLnTv3p2PPvoIBwcHnnnmGQ4ePEhcXBwmJia0bNmSmTNn8sgjj9T7b+Zg6kpXm+H1bvdPVFWou7aZUVH80ydI/zuZOtd9Ocw/WVWunlXbjcmNvVTx91D9NQMJTUVVobtwvLFQmBnvuWlVlXF3w7ueuvl1iv8pjrQ37HJK0XgmtobPdG5qRt0vNrn1N6O4par+mtm3f7ejqt/IU2XVv6GRsvHwI3jcrKaOcctY7N/M8ePHmzqGXjKYJ8TfQAbzmpAM5jUJGcxrQjKY1zRkMK/JyGBe05HBPGEIGcxrIjKY1yT+E4N5j/yLB/MO/HMH86THL4QQQgghhBBCCCGEkZDBPCGEEEIIIYQQQgghjIQM5gkhhBBCCCGEEEIIYSRkME8IIYQQQgghhBBCCCNhvCsGCyGEEEIIIYQQQogmozDuezkZLZmZJ4QQQgghhBBCCCGEkZDBPCGEEEIIIYQQQgghjIQM5gkhhBBCCCGEEEIIYSRkzTwhhBBCCCGEEEIIcfNkzbwmITPzhBBCCCGEEEIIIYQwEjKYJ4QQQgghhBBCCCGEkZDBPCGEEEIIIYQQQgghjIQM5gkhhBBCCCGEEEIIYSTkBhhCCCGEEEIIIYQQ4ubJDTCahMzME0IIIYQQQgghhBDCSMhgnhBCCCGEEEIIIYQQRkIusxXi72BqgonSrqlTGETh69XUERpFUVLa1BEMpsoraOoIBqvKzWvqCAZTWFg0dYTGUSiaOsF/ksLUtKkjNEpVUVFTRzCYolVwU0cwXPiVpk7QKEc6WDV1BIPtSDrR1BEMNsj7jqaO0CiqsvKmjmAwMx/vpo5gsJzu/k0doVEcdkU0dQSDKHKNu38g/rlkME8IIYQQQgghhBBC3BwVKGTNvCYhl9kKIYQQQgghhBBCCGEkZDBPCCGEEEIIIYQQQggjIYN5QgghhBBCCCGEEEIYCVkzTwghhBBCCCGEEELcPFkzr0nIzDwhhBBCCCGEEEIIIYyEDOYJIYQQQgghhBBCCGEkZDBPCCGEEEIIIYQQQggjIYN5QgghhBBCCCGEEEIYCbkBhhBCCCGEEEIIIYS4aQq5AUaTkJl5QgghhBBCCCGEEEIYCRnME0IIIYQQQgghhBDCSMhgnhBCCCGEEEIIIYQQRkLWzBNCCCGEEEIIIYQQN0/WzGsSMjNPCCGEEEIIIYQQQggjIYN5QgghhBBCCCGEEEIYCbnMVogm5upRwtTZ4XTokoVCoeL0ny6sWdKS9BTresuaW1Qy4Ykr9B2SjK2ygujLSta+F8KFk86abQaMSGTmggu1Psf4e3qTnWlpeH63IqY9eZYOd6aiUMCpE+6s+bA96Wk29ZadOOU8IS2yCW6Rg71DGcvevZPdOwJ1tus/KI6udycR0iIHd88idv0awPKFnQzOrMnuXszUZy/Q4a4MFAo4fcyVNSvakp7awLqfFkHfQYnYKsuJvmzP2o9ac+G0i9Z2SvsyHn70Ml16pOHkWkJ2piXH/nDni89akJfTiHr3LGHaC1fo0C1bXe+HnVizMJj0ZKuGZX86ln4jUtXtJtyOtcuacf6Eo9Z2a3cexsOnVKf8G0+35fAeN4OzA7h6lTF9fgIde+SBAk4ftGfVAj/Skyzqz29ZxcTZSfQbnYmtfSXRF2z47B0fzv+p1Npu9JRUbr87nxa3F+LsXsGm5V5sWu7dqNzq7KVMfyWWDt1z1XV/yIHVbwaSnlz/v6e5RRWhM+Ppd28GtvYVRF+y5fNFAZw/Zq/Zxtq2kufeiSK4bQHObuVUVChIjLFi+wYvft/eyHr3LGX6KzE12f9wYPWbQTeXfWS6ut4v2fD54gDOH3PQzv72FYLbFuLsVlad3Vqd/YfGZTf2/K6epUx7KYoOd+dUZ3dkzTvNGvierWLCs7H0G5Gmzh5uy9olQZw/7lBrmV5D03hxWQQZKRaE9unSuOzG/H51K2L6jFN06JiKAhWnTnmw+uMOpKfb1lt24uSztGiRRXBINvb2ZSxdfBe7dwXpbDdz9lFatc7E1aUYhQkkJ9my49dm/O/HYKqqGnfe/FbXvU9QCSMmptO+Wz6e/qUUF5pw+Ywt65d4E3Op/s/xurh5lTE97Code6qznzqoZNX8m8g+J4l+o7Kwc6gk6oINn73tzfmjN7Sbqam0vzufkNuLcPGoYOMyTzYta3y7SUs0Z3WYDyf3K0EFHXrmM2NBIu6+5fWWTYm34JM3vDl1QElFObTsUMTU15Jo0b5YZ9uMZHPWL/Lk2B57CnJNcfYop8+9OTz6crLB2d28y5gelkTHXvnqej+gZNV8b9ITG1jvc1PoNzobO/tKoi5Y89lbXpw/aqe1nUKhYuyTaQydkImzWwVXoyzZvNyDgz87Gpz7GlevUqbPu9bmVZw+ZM+qBf6kJzXgOG9ZxcTZifQblan+jL1ow2fv+Om2+dDU69q8qbrNL/VpdJt39Shm6sxLdOiSiQKVul+5tHXD+5UzIuk7JAlbu+p+5QctuXDKWWs7pUMZD0+5QpeeaTi5lKr7lYfc+OKT4Eb1K90dC3jmvj/o3DIRhULF8QgfVm67m9QcZZ3lWvmlM7LbRe5onoKHUwE5hVacjfJkzc+dSc6y19ne1aGQqUOP0a11PEqbUjJybfntVHNW/a+Rn1NG3i8WwhAyM0/clHXr1qFQKFAoFFy+fFnn7/v27dP8fffu3X/JPhUKBWFhYZrfw8LCUCgUN/Uce/fuRaFQsHfv3r8k01/F0qqSt1cfxzewkGXz27H0tdvw9ivindXHsbSqqLf8s/MuMGhUIptWBbPguQ5kZ1jyxgcnadYiT7PNnwfcmDXxLq2f2ZPuIjfbnIjz9o0ayLO0rOCdZfvx9c9n2budWPJOZ3x8C3h32f4G5R8xKgoLy0r+POJZ53b9BsTj6V3IqRPuFBb8NecgLC0refuDw/gGFLLsjTtYuuAOvP0KeeeDww2r+5fPMGhkPJs+acGC5+8iO9OKN1YcpVlI7nVbqZi3+Bh9Bibx3eZmzJ95F1s3N6fXgCTmLz6GoQtMWFpV8s7nZ/ANKmLZy61Y8mJrfAKKeffz01haV9Zb/rk3Ihh8fxIbPwgk7InbyEq34I01Z2nWKl9n2+MHnZj5cAetn3PHHQ3KXZO/ioVbLuPXvIQls4JY/FwQ3kElLPwqokH5Zy6KY/DDGWxY6s38ycFkpZnz1qZImrUp0tpu8MMZOLqU88eOxuXVzl7Juxsv4tusmKVzgln8fDDegcUs3HyhYdnfiWLwg2lsXOlH2NTWZKVZ8ObaizRrXajZxsy8isoK+GqVDwumt2LRzBASomyYu/QK901OamT2C+rsc4NZ/HwI3gElLNx0voHZrzB4bCobV/oTNq0VWekWvPn5Jd3slQp19hmtWDSrBQlR1sxdGsl9kwzPbuz5La0qeWfdWXyDiln2YguWzG2JT2Ax764/17D37FuXGfxAChvfDyBsRhuy0ix449PzNGtVoHd7W2UF016KJivN3ODMNdmN+P1qWcG7i37H1y+PpYvvYvGirnj7FLBw8e8NOs6PvDcSC4tK/jxa9+CQpWUlP2wP4a037+bN17tz6pQH0x8/xdTppxuX/2+o+4698mjfLZ9d37ow/9FgPnjFHwfnClZsDyf4tsI6nr0B2b+OxK95CYtnBrL42UB8gkpZ9PXlBmWftSSOIQ9nsnGpN/MmNicrzYy3N1/RaTdDHsnA0bWCw39huykpUvDC2GASrlgyZ0U8c96LIzHGkrkPBFNSVPdXp7wsU2bdF0xsuBXPLEzg5Y/jAJh7fzDxkdr9rZQEC54ZFkJitCWPv5HI219GMWF2CqZmhi8+ZWldxcKvo/ALLmXxc/4sfsZfXe/fRDWs3pcmMOSRTDYu9mTexCCy0sx5+4tomrXVHoicODeF8bNT+XGtK6+Ob8alkza8siaOzv3yannmBua3qmThlxHqNj87iMUzm+EdWMrCLQ1t8zEMfiidDUt9mP9oC3Wb3xhxQ5vPVbf571yZ/1gIH7wagINLOSu+v0hwu0a0ectK3v7oT3WfPux2ls5vr+5XrjrasH7la+cYdF8Cm1aHsGDWnWRnWvLGe8e0+vSgYt7SE/QZlMR3G4OY/2wntm4KotfAZOYvO4HB/Urzct578kcCPHJ484s+vL6pH75uebz/1P+wsqh7ALt/hysEeWbzzf52zF49hFU/3kULvww+m70Vd0ftzyhP53w+nbkVP7dcVmztzsyPh/H5r3dSWdm4IQlj7xf/GyhU/96ffzKZmScMolQq2bhxI2+88YbW4+vXr0epVJKfr3vw+6tMmTKFwYMH31SZjh07cvjwYdq0aXOLUhlm0KirePoUMX10D5IT1GcDYyLt+OT7QwwZc5XvNwfWWjYoJJ++Q1NYHtaW3T/4AHDuhBMff/MH4x+P4vWZHQDIy7EgL0f7bGzbDtk4OJWzeXXzRuUfPDwGT69CpoUOIjlJfdY2JsqBTzftYOiIaLZ906LO8g8MH4lKpcDLu4ABg+Jr3e7VuT1QqdQDuHfeldqozNcMujcOT+8ipj/Ul+Sr6hkaMVfs+eTr3xlyXzzfb2lWa9mg4Dz6Dkpi+Zvt2f2THwDnTjnz8eZ9jJ96mdfndgbA26+QNrdn8/67t/Hr9oDq7VypUil4au45fPwLSYy3q3U/tRl8fzKevsVMG34XyfHV7eayLZ/+fJShY5PYtt6v9uwtC+g7PI3lr7Rk1/de6kzHHVi1/Rjjn4rl9adu09o+L9uciLO1z/4xxOBH0vH0L2VKn7Ykx6nPmMaEW/P5vvMMG5fB1k89as/fuoh+o7JYOjuAXd+4AnD2iJI1uy8QOjuJsMeCNdtOH9AGlUqBiamK4RMy/prsD6bh6VfC1IF3kBxnXZ3dhs92n2Low6ls+7z2L/1BrQrpe28Gy15ozq7v3NXZ/7Rn9S+nmfBcAgumtwIgP8ecRbO03zvH9jnhE1TMwPvT+H6tYbNOBj+YWp29A8nx1dkjbPhs10mGPpTKtjqeN6hVIX1HZrDsxebs+s6jOrsDq38+xYRn41kwo3XDsq8zfMaMMecf/EAKnn4lTBvS6brstny64xhDH0xm2zrf2rO3LKDviHSWvxzCrq3qEx/njjmy6n8nGP9MHK8/0VanzKNzYoiJsCUr3YIO3XIMyqzJbszv1yHReHoWMvWxISQnqWeXxMQ48Nnanxk6LIpt37Wss/z9o0ZXf0blM+Ce2Fq3e/ftu7V+P3nCExeXEgYOimH1xx0Nz/831P2+H5z5cb0bUHOS9PQf9qz/4xz3PZrGkpm6MxEbYsi4DHX23m1IilVnj75kzdoDFxg2PoOtn9SevVnrIvqNymbprAB2fu1Sk33PRUKfTybs0Zq+y7R+17Wb0L+m3fzyhQspcRZ8euASPkFl6kxtSpjcvTU/bXRhzPT0Wsv+b4Mr2enmLNl6Ce9Addk7ehQwsWtrNizx5NXVcZpt33vBFxfPchZ9ewWza+Pu3QwfTAIY8kgmngFlTOnZiqRY9eBh9EUr1h4KZ9iELLauqX32ULM2xfQbncPSmX7s/Eo9G+zsYTvW7I0gdE4KYZPUbcHBpZwxM9L5+kN3vl2l/iw784cd3oFlPPpyMsf26M7GaqjBD1e3+b63Xdfmbfh871mGjUtn66e1n/wNal1Ev/uyWPp8ILu+Ub/Os0eUrNl1ntBZiYRNCQGutXl3tNu8kvWHznLfo6ksmVV7/68ug0YlqPv09/e6rl+p5JPv9jNkdALff1H7eykoJI++g5NZ/vpt7P5R/Xlw7qQzH391kPHTI3l99p0AePsX0aZ9Du+/3ZZft/lXb+dCVZWCp166gE9AIYlxN9+vHNktHG+XfB5++0ESM9R9vqgkZ7a8soV7777EV3tvr7Xs5t/uIKdQe+bh2RhPvn3tC0Z2u8Snv3TWPD7ngf2k59ry9AfDqawyBeB01E3H1WHs/WIhDCUz84RBRo8ezaZNm1Cpaoari4uL+fbbbxkzZswt3bevry9du3a9qTL29vZ07doVe3vDOxi3Qpfe6UScc9QM5AGkJtlw8YwjXfvU3llUl02jvFzBgZ01HZuqShP27/SkY7cMzMyrai3bf3gS5WUK9v3q1bj8dycTcclFM5AHkJpiy8XzLnTtXv8lItcG6P6q7W5Gl56pRFxw0nS4AFKTbbh4zomuvVLqKZuirvvdNV/sqypN2L/bm45d0jEzV58FNK/+Nygq1D5vUpiv/t3EwNM9XfpmEHHWXtNhAUhNtObiKQe69q37y0zXvhmUlyvY/6u7VvZ9v7hzZ/esOtvNX6XrPbmEn7LVdNQBUhMsuXDcjq4Dc+os2+2eXMrLFOz/seayk6pKBXt/dKZjrzzMLWry34p207V/FuGnlZqBPIDUq1ZcPKmk24Csespmq7P/VHMpdlWlgn0/uXJnzxyt7PrkZZtRVWn4a+raL1udPf7G7PYNyJ5Vnd3VsOw55o3Kbuz5u/TLJOKMvXb2RCsunrKna//MurP3q87+c82X8KpKBft+duPOHtk679k2HXLpOyKNj14PvvGpDGLU79duiYSHO2sG8gBSU+y4eMGVbt0S6y3fmEx5eRZUNrbN/w11n5dtxvWDGgBF+aYkRlvi4ln/JaV1Zj9pqxnIuz57t0G5dZSErgPV2ff94KSVfd8PTtzZ+9a3myM7HWjVsVAzkAfg6V9G286FHN5R95f4Sydt8Akq1QzkAVjZVNGuSyF/7nKgsnqCVlKsBSf22nPvoxk1A3l/ga4D8wg/aaMZyIPqej9m24B6z6uud0fNY1WVCvZtd+TO3vmaeu/UJx8LSxW/feekVX7PVieatSnBw0/3MsQG578nh/BTdnravJKu9+TUWbbbPTl1tPnc69q8Obpt3ozEaCtcPMswVJdeaUScd9TuVybZcPGsI117130iukuva336mn65uk/vRceuevqVBbX1Kw3L3qNdLBdi3TUDeQDJWfaci/GkZ7vYOsveOJAHkJqtJKfQGleHmsFpH5dcura+yrcH2mkG8v4qxt4vFsJQMpgnDDJhwgTi4uI4ePCg5rFt27ZRVVWldzBv37599O/fH6VSia2tLYMGDeL8+fNa21RWVvLqq6/i5eWFjY0Nffr04cIF3bXe9F1mW1FRwcKFC2nTpg1WVla4ubkxePBgwsPDAf2X2fbp04cePXqwe/duOnbsiI2NDe3atWPbtm06+zxz5gwjR47EyckJa2trunfvzoEDB26qzvQJaFZAXJTuGbT4KFv8m+m/fOoa/+aFpCZaU1qi/YEYF2WHuYUKb78iveUsLCvpMSCVPw+4UZDXuB6kf2AesTG6A6Rxsfb4BzTuUotbLSCogLho3XVA4qOV+AfWU/dBBaQm2VBaekPdxygxt6jC21dd93HRSs6dcuahyZEEt8rByrqCFm2yefjRSI794UZCXN3rkNS6/+BCYiN113uKi7LFv7n+f3dN2eaFpF610mk38Vds1e3GX/tSmi59Mtl6fD/bT+1j2Rcn6Nav7kHmhggIKSYuQrfzF3fZGv+QkrrztygmNcGC0hLtj6+4y1ZYWKrwDjT8S0RD+IcUE3dZT/ZIG/yDdddDul5ASBGpVy1137OR1phbqPAKuPG1qzAxVaF0LGfIg6nc2TO3zpl/9WcvIi5Sdz2guEhr/IPrbjcBwbVlt1Fn968rewp39shh29rGnTww5vz+wUXE6s3egPdscCGpiXres9XZvQNq2p2pWRVPv36F7z731Ro4bAyjfr8G5BEXqzv4Ehdnj7//X/0ZpcLEpApb2zK690hgwD2xbNta98y/+jRV3ds5VBDYsoSEyPrXmqpNQItiYvVlj7CqN3tAixJS9GWPsP5b2k1chBWBrXQzBrQsIf5y3XViYgJmFron6swtqigtMdEMsl04pv4Mt7Sq4sUHmzM88HbGtG7Homf8ycsyfKAjoGUJseG6GeMirPBvUU+9t6yu9+Ib6/1amynTbFdWoiApxkJnO4CAFob/+9Ta5iOt8A+p+zPWP6SY1AQ9x/nL1e0moL42X0zCFcOPmwHN8omLqqVfGVRPv7JZLf3KaO0+fVyUHedOOvHQlCiCW+dW9ytzeHjKFY4dciMh9uZn5QEEeWYTneKs83hMihOBntk3/XwBHtk4K4uJS60Z8L2tmXpAs7TcjBWP/4/fl3zCL2+v5dVxe7C3qbtt1sfY+8VCGEousxUGCQgIoFevXmzcuJGePXsCsGHDBkaNGoWdnfYHyU8//cS9997LsGHD2LRpEwALFy6kZ8+enD17Fj8/9dTnsLAw3n77bWbNmsXAgQM5fvw4I0eObFCehx56iO+//57nnnuOAQMGUFJSwv79+0lOTqZVq1a1louKiuLZZ5/lpZdewtXVlaVLl/LAAw8QHh5OcLB6VsPJkyfp2bMnHTp04JNPPsHGxoZVq1YxYMAA/vjjD+68886brr9r7BzKKcjTfRvm55ljp6x7fQ2lfTkF+bqDcQW56seUDvrPqHfrk4atsoLffmz8AtFKZZn+DHkW2CkNP6P/d7CzL9M7mKmu+7qzK+1re93mmr+rKZg/6y6en3+alWtrBr7/POTOO68Y3m6UDhV6201Brhl29vVkr6Vsfq5Z9d9ryh/d68rl80pSr1rh6FrGiIcTee39Cyx+oRW//6/udQ7rzOBYSX6u7peVghxTlA71tHvHCk1W7bLqx+wc61+XpjFqrb8cM+zs689eW9lrz329ERNSeGJ+LADlZQpWvRnIb98bvsCy0qGCAj11l59rbnj2a+3mhnofMT6FJ+bHANdnd9cpfzOMOX9t2dXv2QZk1/u6ddvNA1OuYm5Rxdera7+k6GYZ9ftVWUZBvu6i//n5ltgpDZ+Bo89dXZJZ8Ib6JF9VFXz9VWu+3Kx7CfTNaKq6f+L1BFCo2PZZI9q8YyUFerLn55g1KLv+sqaa576V8nNMsXPQ3Ye6TuseaPNrXsKp/Uryskyxd1Y/R1UVRJy21Tw3QFaKur+wbJY//cdk8dDTqSTFWvL5O17EX7bivZ8vY2LAlIva690UpZ7XpF22goKcuuq9omYfeabcOLvtxu0MUXubb1i7qe39AvW1+ThQwLbPar/8uz52tfTL83Mb0qcv09+v0/Qrr/XNFMx/thPPv36WlRv+0Gz35wE33nmpg8HZ7W1KyS/SXUM7r8gSpfXNDc6amlQx54EDZOdb8b8jNd/BXO3Vs/Refngvvx4LYcPuDvi65jJj+J8EeWQzZflog2faGnu/WAhDyWCeMFhoaCizZ8/mvffeIzs7m927d/PLL7/obPfss8/Su3dvtm/frnmsb9++NGvWjKVLl7JixQqys7NZvnw506ZNY8mSJQAMHDgQU1NTXnzxxTpz7Nmzh++++46VK1fyzDPPaB6/77776n0NGRkZ7N+/n5AQ9ToaHTt2xMvLi6+//pqXX34ZgDlz5uDv78+ePXuwsFB/KRg0aBDt2rXjjTfe4Pvvv693P/8k/UckkZ1pwbFDrvVvLBrtmZfO0rJtNu8vvI2EWDv8AgsYP+UyL791ggVzOt+SS4T+KqveDtH6/fBuN5Z9eZJJz8VIp+VvsP8nV8JPKbF3Lqdr/2wenxdDVaWCX7YY/mXj77L/Z1fCTyuxdyqna/8sdfYqBb9sMY52Y4z5vfyLeXBGAm8+1ZryMrnw4u92/pwrzzx5D7a25bTvkMqY+yNABevX1b7W1D/Rg08m029UFsueD9C61FE0zLDQTL7/3I3Fz/rz+BuJWFpX8eVKD1Li1f3HawN0VdWT927vVsBT76gv+b6jRwE2ykreeTyQE3uVdO5369afFjUefCKJfvdlsWxOoFG0+WdeOU/Ldup18zT9yumRvPzuKRbMurPJ+5WzxhzktqBU5qwZTH5xzQDhtaVlTl3xZtl36okgJyN9KCyx4PWJv9GlVQJHLvk3SeaGkn5xLVQYeu8V0UjS2xMGe+CBBygtLeXHH39k8+bNeHp60r9/f61tIiMjiYqKYty4cVRUVGh+bGxs6NatG/v37wfg3LlzFBYWMnbsWK3yDz30UL05du7ciUKhYOrUqTf9GkJCQjQDeQDu7u64u7sTH6++GUNxcTH79u3jgQcewMTERJNfpVIxYMAATX591qxZQ6dOnejUqRNlVfovDSjI0z+jRD3rru6x9oJ8M70zyOyqzyDl5+qeHXRyLeWOu7LY96snVY28c5Q6g/4ZeHa1zFz7JynIN9d7tq62GY86ZfW+7uq6z1N32jvfnUqfgUksfb0Dv34fwIXTLvz6fQBLFtxB5+5pdOlh2M08apvNY+dQUe+l0wV5+steO+Otr91cU1Wl4OAON9y8SnFyNfwymoJc/TME7Bwr9c4k0S6r/+z8tTPu12ad3Cq11l8tM7+ul1/Lv9u1WQw3vvbcLHMiz9txYr8TH85vxp7v3ZjyYiymZoat31KQZ4adnrpT1jJDuEHZr7WbnFqyH3Diw7Dm7NnuxpQXDM9u7Plry25Xy4wArbK5tb1u7XYz45UozhxxIPyMPbbKCmyVFZibq0ChvruthaVhs5mM+v1aYK53Bp5SWap3xl5jFBVZEBnpzOnTHqxfeztfbWnNAw+G4+JS9yVedfm7637o+HQmv9G1r6oAAQAASURBVJDEukXe7Py6cSf8CnLrmt1WX/bayqofy9cze+yvZOdQ16zCut9HXgFlvPBBHJFnbZh8dxse6dCOSydsGT1VfSmes7u6n2DvpH6ejr20B+zu7K3+/cp5wy73rKvu6ptVWJBrip2eWY819W5Ws519JTd+e79xO0PU3uYb1m5qe79ALW1+XBqTX0hk3WIfdn5t+Mx3qO7T6+kbKh0a0qfX/32gpl+p7pt17p5Gn8HJLJ1/O79u8+fCKWd+3ebPknnt6dwjnS490wzKnl9sidJGt19nb1OqNSBXnxnDjzKy2yXe/rI3f0ZozxDPLVIPlB6L0L7h05/h6u1a+Bh+Axtj7xcLYSgZzBMGUyqV3HfffWzcuJENGzYwbtw4TG64JiAtTf2h8thjj2Fubq7187///Y/MTPXC38nJ6psleHhozzi58Xd9MjMzcXZ2xtr65js+zs6660NYWlpSUqJeuyErK4vKykreeOMNnfwffPAB2dnZVFXp/3I3bdo0jh8/zvHjx7Ew0Z8tPlr/2nh+zQqJj6573Yv4KDs8fIqxtNLuuPg3K6C8TEFSgu76TH2HJmFqpvpLLrEFiI+1JyBQd90h/4A84uP+WTcbuZF6DRPds95+QfnE17PmSHyMEg/vIixv+HLsH5hPeZkJSVfVdR/YXP38ly9qr9l0+aKjel/1rM1X6/6jbAkI1r3jnX+zQuKjdP/drxcXZYuHb4luu2leqG43f9E6W3VmuGxNQAvdAe6AkGLi61mjKe6yFR5+ZVhaab/vAkJKKCtVaC36fSvERVoToGfdHv/gYuLrWWsnPtIaD99S3boPLqa8TFHvjIDI87bY2FXh5GrYJexxkdYE6FlbTp297nYTf8WmluxF6uzx9WQ/Z9eo7GDc+eOv2NSSvaj+9+wVGzx89Lxnq7MnVd+MxT+4iLv6ZPPNscOanz7D03H1KOObY4eZNCvWoOxG/X6NcyBAz/qt/v55xMff2s+oyMvOmJqq8PQ0/O6kf2fd9x+dyVNvxvPtag+2fNC49S2v7V9fdv8WJQ3Ibo2nnuz+LYr/lnYT0LJEs/7b9eIv17/uHEDPYblsPnmBT/ZdYu0fF/lwx2WKi0xw8y7D3Vd9DAmo53kMvZFBXIQVAS11n9u/Rf3r/cVFWKnr3frGer/WZiw021lYqbRu8nFtO4C4y4b/+8RF1tLmg0uIj6z7MzbusjUefrrH+YCQ6nYTd0ObH5XBU2/G8e0aD7Z80Ph+cXy0nf4+fVAB8TH19Cuj7fT3K4O0+/SBwbX0Ky84aPZliJhkJ4L0rI0X6JlNbIqTnhK6Qu85yYQBp1mxtTs7jrfQ+XtMct3PU9WIGYXG3i8WwlAymCcaJTQ0lJ9++olz584RGhqq83cXF/VdG9955x2OHTum8/Pjjz8C4OWl7jimpmrPVLrxd31cXV3JysqiuLjuhXEN4ejoiImJCU8//bTe/MeOHdMZwLwZR/e50+q2XDx9ar7kuXsV06Z9Dkf31X2G8Oh+N8zNVfQYUHPnVRPTKnoNTOXkERcqynVz9R+WTPRlO6Iv/zVfYo784UWrNll4etV0Htw9CmnTLpMjhxr/ZeBWOnrQg1Ztc/D0rvnwd/csos3t2Rw9UPcg8tGDHuq675+keczEtIpeA5I5+acrFeXqs9/ZmeqOY8u2OVrlr/2ekW7Y5RxHfneh1e15ePrWtHl372LadMjjyO91z6Y4+ruLOvugmgV7TUyr6Dk4nZN/OOttN9rbpZGWZEl2huGd9SO7HWjVoRBP/5qzmB6+pbTpVMCRXY5159/tiLmFip7DazqdJqYqeg3P5uQB+1t+eeHR35xpdUc+nn41X5bcfUpo0zGfI7/pnhzQKrvHWZ19SM3dS01MVfQamsnJg471Zr/trjyKCkzIyTRs1uvRPXVlr7uTfXSPk/7sw/6e7Mae/8geF1q1v+E961Oifs/ucamjZPV71kJFj8E1sxZMTFX0HJLOyUNOmvfsu7Na8ULobVo/xw84kZtlxguht/HjZsO+rBr1+/WwN61aZ+LpecNnVNsMjhz+a05q1ea229OoqoLkZMMWpIe/r+7vHpTNrCWx/LrFlU/f8tX3dDeffacjrTvqZm/bqYAjO+u+I+yRXQ56s/cekc3J/cpb3m66Dszj0klbkuNqZm+mJFhw4ZgtXQfWfUfYa0xNwT9EfVfbzBQz9v3gyPCJNe/h1ncW4uxezvF92jdMOP67+vcWdxg2o/PITntadyy6od7Vd+I9srPuvt+RXfbV9Z6jeczEVEXvkTla9X7sdyXlZQr6jtYe/Ok/JpuYS1akJjSif7DLkVYdCrSO85o2v9uxzrJHf6tu88NuaPMjsmpp8zH8usWNT9/6ay7tPHrAnVbtcm7o0xfRpn02R/fX06/c717dp0++LnsVve5J5uRRff1K7XbYsl0OABlphvUrD14IoG1AKt4uNSc/PJ3zuT0olYPnA+otf3+vc0wfdozV/+vMdwfb6d3mQpwHGbk23NUqQevxLq3Vv1+KN3xmpLH3i4UwlKyZJxrlnnvuYezYsTg6OtK2re5Czy1btiQwMJALFy7Uufbd7bffjq2tLV9//TX9+vXTPL5ly5Z6MwwcOJB3332XTz/9lKefftqwF1ILW1tbevbsyZkzZ+jYsWOjBu70+XWrD8MfjOe1ZafZ+FEwKhWMf+IKGalW/PJdTYfazauYz7Yf5MtPmvHlJ80BiI6wZ98OT6Y9H4GpmYrUJGuG3p+Ah3cxi1+5TWdfzVvlERhSwCdLdc+WGZz/pyBGjIpi3puH2fB5W1QqmPDoRdLTrPnlx2aa7dw9Cvls8w6+2NCaLze01jzern06Dg6lODmrO20hLbMpLlYflg7tr3n9fgF5mrvjWlhU4u5RRPdeVwE4d8aNvNyb/wD9dbs/w++P5bVFx9m4uqW67qdFkJFqzS/f13Rc3DyL+Oyb3/lybQhffq6uu+jLDuzb5c20Zy9iaqoiNdmGoaNi8fAqYvH8mgWID+31ZMKMcGa9dpota0O4GmeHb0ABjzwWSVqKFYf3Gba+xq/fejPikUTmvX+eDe8FoQImPB1Deoolv3xTM4jq7lXCZ78e4YtVgXz5caA6e7iSfT+7Me2FK5iZVZFy1ZphDyXi6VvM4hdq/m16D02la98Mjh1wISPFEkeXMoY/nERI2wLefb41jfHLF66MnJjO/E+vsH6xDwChs5NIT7bg5801nS53n1LWHjjP5pVefLFS/cU76oINe39wYvr8BMzMVKQkWDBsQjqefqUsejZIaz8htxfi4VuGwkR9KZB/SAk9hqo7+cf2OOjcKbFB2b9yZ8SEZOatCmfDcn9UKgh9LkGd/cuazrq7dymf7znJFx/48sUH6ktIoi7asu9/Lkx7NRZTcxWpCVYMG5eCp18Ji2YHa8oOeSiVVnfkc/oPBzJSLFA6VtBraCY9h2Tx+SL/OjuWdWf3YMT4FOZ9fH32eNJTLPj5urXg3L1L+Py3k3zxod912e3U2V+JUR9vrloy7JEUPH1LWDSrZqmCIQ+lVGd3rMk+JIOeQzL5fLHh2Y09/6/feDJiXBLzPrrIhhWB6mPls3Hq9+xX171nvUv4bOcxvvjIny8/Uh+Hoi/Zse8nV6a9FK1u81ctGfZwMp6+JSyeU7O4eMQZ3S/qA0alUl5mwrk/HQ3KDUb+fv2lOSNGXmHegoNsWHebus1MPEd6ug0//9S8Jrt7IZ+v/4kvNrXli+tuWnHbbWk4OJbi5FT9GdUii5IS9WfUwQPqttX5riQGDorh6BFv0tJssLauoHPnZAYPjeaXn5qTlWX4rI6/o+7b3ZXPi+/HEH3Jhl3fuNCqQ83AZ3mZCVEX6p7VUpufv3Bh5OR0wj6PYv0ib1QqmDgnmfQkC37apJ193aELbF7hxeYVXjXZtzsxI+wqZuYqUuItGB6agadfGQuf1tNu/Mo0M9kCQkroUT2Yc+w3w9rN0HGZ/LDWlbDJQUycm4xCAesXe+HmXcawCTUnBFKvmjOpWxvGzUxh/Cz1yeeKcvj0TW9u71qIjbKSuAgrtnzgQUCLEsZMrxksMDWDR19OYslzAax8wZceQ3JJirVg3UIvbr87nzt6GDbD6ufNzoycnEHY2ljWL/KsrvcUdb1vrDlx4O5TxrrDl9i83IPNy9XHz6jzNuzd7siMBUnX1Xumut6fqhnwys00Z+saVx56Ko3iAlOunLOm98gc2ncvIGxSkE6mm/HLl26MnJimbvNLfEAFobMTq9t8zWCPu08pa/efZfNKb754T/3eiLpgy94fnJk+P16dP8GSYePT8PQtZdGzNX3Sdnfl8+J7Ueo2/+2NbV5B1AXdu6I2xK/b/Bj+QDyvLTnBxo9boALGT49U9+m31lxy6uZZzGfb9vHlZ8358lP150/0ZQf27fRi2qxLNX36MfHqPv1r7TVlD/3uwYTHLzMr7CxbPmvO1Vg7fAMLeGTqFXW/cq9ha+r+cLg1Y3pc4N3HdrDm586ggilDj5Gabcv2P9potvNwyufrV79k3c47WbtDfSO3/h2u8Ox9f3D4kh8nIn1oG1AzEaOwxILY6jvaVlaZsOp/d/HquL3MeWA/+84G4eOax7Rhf3Iy0psTkT4GZQfj7xf/K8iaeU1CBvNEo5iamvLll1/W+neFQsGHH37IvffeS1lZGWPHjsXV1ZXU1FT++OMP/P39mTVrFo6OjsycOZO33noLpVLJwIEDOXbsGJ999lm9Gfr27cuYMWOYNWsWCQkJ9OvXj/Lycvbv38+wYcPo06dPo17jsmXL6NWrF4MGDeKxxx7Dy8uLjIwMTp48SWVlJe+++67Bz11aYsbL0zsxdXYEs984Bwo486cza5a0oqS45u2pAEzNVJovOdesCGtL6JNXCH3iCrbKCmIu2zHvqY5Ehet+qes/PImKcgV7f/nrZsyVlpjx0qxeTHvyDM+/dEyd/6Qbqz9or/nCc42pqUqz+O014ydd5PY7as5UjxgVzYhR0QAM7VszmNerz1XGTbqk+b19h3Tad1B3il94rhfnztz82bzSEjNefqobU5+9wOz5pwEVZ467smZFW/11f0P2FW+1J3R6OKHTI7C1Kyfmij3zZt5F1OWaGQfFRebMntKDcVMuM2Z8FM4upWRlWnL0oDtffNZCaz83lb3YlJcevYNpL1zh+Xcvqev9iCOr3w2mpOi651SoMDVDp96Xv9qKic/GMOGZGOyUFcRE2PHa9NuJulQzQyDlqhWOLuU8NjsKpUMFJcUmRF5Q8uq02zl5qO4ZaA3J/8JDLZg+L4E5K2JQKOD0ISWrF/hRUlSzpo9Cof7Cc+MY+rLZgUyam0jo84nY2VcSfcmaV0NDuHJe+0vnyInp3PNAzRevXsOz6VU902Pi3e1IvXrzg8Clxaa8OL4t016JZc6SK4CK04cdWP1moFb2a3WvuDH7C82ZODuB0JkJ2NlXEH3JllcfbU3UhZrZO7ERNnQbkMWUF+NQOlaQm2VGQpQN86a04tjehl3uUmv2CW2Z9koMc5ZEVmd3ZPVbN2ZX1/uNbX7Zi8FMnBVP6Mx4dfZwW159tA1RF2/I3j+LKS/EVmc3JyHKmnlTW3Fsb+PbjbHmLy025aVJtzHtpWieXxShfs8edmT1O830Zr+xzS9/uQUTZ8Yx4dlY7OwriAm347Wp7bSy3ypG/X4tMePFuX2YNuM0c+YeAQWcPu3B6o87UFJy3SxLhfoz6sbP2PGh57m9fc0AzMh7rzDy3isADBn4IKCeeadQqAiddA5Hh1IKCs1JSlSydPFd7P29/hktdeb/G+r+ju75WFipCLmtiOXbIrTKpyZYMLG77snBhmafOzaEGWFXmbMyVp39oJJVYb56s99Y90tnBzBpbhIT5yRpsr8yIVi33UxKZ+DYLM3vvUbk0GtEDgChXdsa1G6sbKpY9PUVVoX5sPiZAFQq9c0pZryeiLVtzSWoKpWCqkoFqqqaywMVCkiMseT3bU4U5pni6lXOoIcyeejpVMwttF/jPWOzUZjA1x+6s+srZ5SOlfQbnc2jL6sHEA2hrvfmzAhLYs578dX1bseqeT611Lt2+aUz/Zj0QjIT56ao6/2iNa+Ma8aVc9r1vu5dL4oLTblvSjpObhVcjbLkrekBHN3duCs/SotNeeHhluo2vzy6us3bs/p1/4a1+eeDmDT3KqGzr1a3GxtendiCK+drBujuuDuvps1vDdcqn5pgwcQe7TFEaYkZLz9+F1NnXWL2gjPq4/wxF9Ysa63dr1SoqvuV2uVXvH4boY9fJvTxy9jaVRATqWTeM52IiriuX1lozuxHuzFu6hXGTIjB2bWUrAxLjh5w54s1IQb3K0vKzHnmw+E8M+ow88bvQQEcj/Rh5ba7KS6rOVYqFGBmqt0n7to6ARMT6NY6gW6ttWfdnbzixdMfjNT8/suxllSpFIzvf5qhXSLIK7Ri5/EQVv2vCzfeHflmGHu/WAhDKVQqlYyjigZbt24dkydPJjIykuDgYL3b7N27l759+7Jr1y4GDBgAwOHDh3nrrbc4dOgQxcXFeHp60rVrV5599lm6desGQGVlJfPnz+fTTz8lNzeXLl268NFHH9G2bVvmz59PWFgYAGFhYSxYsIDrm25FRQULFy5k/fr1xMbG4uDgQOfOnVm+fDktW7bUZPr99981g3t9+vShoqKCgwcPauUPDAykT58+rFu3TvPYpUuXWLBgAXv27CE3Nxc3Nzc6duzIjBkzGDp0aL315mDhzt2uY+vd7p9I5aCsf6N/MEWJ8S5Iq8oz7Mz8P0FVvvHehU9h8dcujP+3M/RboGgUhemtXZT/VqsqMvxGDU1N0Up/f8QYqMKvNHWERlFVGe/XiB1XTzR1BIMN8r6jqSM0isLceD9nTd0bd3OYppTT/Z99t9j6OOyKqH+jf6DDudvIrUivf0MjZePmR6vRs5o6xi1jcmIzx48fb+oYeslgnhB/AxnMazoymNc0ZDCvCclgXpOQwbymI4N5TUcG85qGDOY1HRnMazoymPfPJIN5TUcusxVCCCGEEEIIIYQQN0UBKIz3vI5Rk7vZCiGEEEIIIYQQQghhJGQwTwghhBBCCCGEEEIIIyGDeUIIIYQQQgghhBBCGAkZzBNCCCGEEEIIIYQQwkjIDTCEEEIIIYQQQgghxM2TG2A0CZmZJ4QQQgghhBBCCCGEkZDBPCGEEEIIIYQQQgghjIQM5gkhhBBCCCGEEEIIYSRkzTwhhBBCCCGEEEIIcdMUKlk0rynIzDwhhBBCCCGEEEIIIYyEDOYJIYQQQgghhBBCCGEkZDBPCCGEEEIIIYQQQggjIWvmCSGEEEIIIYQQQoibo6r+EX87mZknhBBCCCGEEEIIIYSRkME8IYQQQgghhBBCCCGMhFxmK8TfobKKqvyCpk5hkKqU1KaOIMTfSlVR0dQRhBA3weRqclNHMFiVHG+azCDvO5o6gsGiNndo6giN0nzcqaaOYLCKJOM93th9Y7zZARQBfk0dwTAFpk2dQPxLycw8IYQQQgghhBBCCCGMhMzME0IIIYQQQgghhBA3TfEvvgHGP/mlycw8IYQQQgghhBBCCCGMhAzmCSGEEEIIIYQQQghhJGQwTwghhBBCCCGEEEIIIyFr5gkhhBBCCCGEEEKIm/dPXljuX0xm5gkhhBBCCCGEEEIIYSRkME8IIYQQQgghhBBCCCMhg3lCCCGEEEIIIYQQQhgJGcwTQgghhBBCCCGEEMJIyA0whBBCCCGEEEIIIcRNU/yLb4DxT35pMjNPCCGEEEIIIYQQQggjIYN5QgghhBBCCCGEEEIYCRnME0IIIYQQQgghhBDCSMiaeUIIIYQQQgghhBDi5v2TF5b7F5OZeUIIIYQQQgghhBBCGAmZmSfEP4CrZynTX4mhQ/dcFAo49YcDq98MIj3Zst6y5hZVhM6Mp9/IdGztK4m+ZMPniwM4f8xBs421bSXPvX2F4LaFOLuVUVGhIDHGmu0bvPj9B7dGZXfzLmN6WBIde+WDAk4dULJqvjfpiRb1Z7esYuLcFPqNzsbOvpKoC9Z89pYX54/aaW2nUKgY+2QaQydk4uxWwdUoSzYv9+Dgz46S3QizG3t+yS7Z/2v5jTm7q2cJ016IpsPd2erP18OOrHm3OenJVvVnt6hiwjOx9BuRhq2yguhwW9YuDeL8idoz9RqSxotLw8lIsSC0X9dGZQfjrnvJ3jTZTTPLcN2YiPX5PBQqKGqnJHOCLxWu9WdvPu6U3scT3mpJWaANAMp9mbivia/1OWI/bEelo7lh4THuuldnT6Rjz+uz+5Ce1MDsc5Jrsl+05rO3vHWyj56WRvu7Cwi5vQgXjwo2LvVg0zKvRuX+u7Jr6n18hrreoy3ZvNzzL/mMdXUvZuqzF+jQOR2FAk4fc2XNyrakp9rUn9+ikglTI+g76Cq2ynKiIx1Y+1FrLpx20drO3qGUyU9eokv3VKxsKoi9Ys+mT1ty8qh7o/MLYQiFSqWSSZFC3GIOpq50tRmu92+WVpV8+OMZyssUbFjuj0qlIHRmPFbWlTw+/A5Ki03rfO65Sy/TuU82ny0MJCXBkuHjU+jUK4dZY28j+pItAErHch6fF8PpPxxIS7TE3EJFr6EZDBidzuq3Avl+nXetz19VWFjr3yytq/h4VwTlZSasW+QJKpg4NwVL6ypm9G9Rb/YXPojjrv55fPqGN8nxFoyYlEnnvnk8NzKE6AvWmu0mvZDMmBnprF/oSeRZG3rfm82QcVnMCw3i2B77Ovch2f9Z2Y09v2SX7P+1/MaQ3dTRQe/jllaVfLDtBOVlJmx8LxCVCkKficXSqoonRt1Zb/Y5iy7RuVcWny1pRspVK4Y/nESnntnMfuQOosPtdLa3VVaw+qdjoFJQVUmDBvMqc3Jr/Zsx1L1kb5rsUZs76H1cUVqF70vhYK4g8wH1AI/zN8mYlFWR8E4rVFZ1Z28+7hR5vZzJ6+eq9XiZvzUqS/UFXSZ55ZinlumU9VoSRbm7JYlvtKxzH9f2o48x1D0Khf7sVlV8vDuc8tJr2RVMnJuszj6gZf3Z34/jrv65fPqmjzr7xAx19ntDiL5QMyD1yd5LFOWbcuW8NcNDM/+Swby/K/ukF5IZMz2N9Qu9iDxnTe97cxjySCbzJjZr0PvVLMBPf37LCt7fsJ/ychM2rmkJKgUTpoVjaVXJkxN6U1pS9/yl5+efpPPdqXz+YRtSEm0YPiaWO7ul8fy0HkRHqj9fzMwrWfHZAewdytiwphXZmZYMHJFA154pvPpsV86dcq31+f9I3ExuaUq9r89Y2br60XbYzKaOcctUXfiC48ePN3UMvWRm3n/UunXrmDx5suZ3Ozs7mjVrxtSpU5kxYwZmZmYEBgbSo0cPNm3aVOdzTZo0ib179xIbGwtAbGwsQUFBrF27lkmTJt3CV9F4kyZNYvfu3Vy9erXJMgx+MBVPvxKmDuxAcry6oxETYcNnu04y9KFUtq2tfaAtqFUhfUdmsOzF5uz6zgOAs386sPrnU0x4Np4FM1oDkJ9jzqJZLbTKHtvnhE9QMQPvT6tzMK8uQx7JxDOgjCk9W5EUq55FGH3RirWHwhk2IYuta2qf9desTTH9RuewdKYfO79yVmc/bMeavRGEzkkhbFIQAA4u5YyZkc7XH7rz7Sr1ma8zf9jhHVjGoy8nG9xZl+xNk93Y80t2yf5fy2/M2Qffn4KnbwnThnW+7vPVlk9/OcbQsclsW+9ba9mglgX0HZ7O8ldasGubJwDnjjmy6ofjjH8qltefaqdT5tHZ0cSE25GVbkGHbtkGZb6eMde9ZG+a7Pa/Z2CeVkr8kjZUeKqzl/lb4z/7IvZ7MskdWv8Mokonc0pDbGv9e5W9OaX22jPvrMILMC2oJGuMs0G5rzHmuh8yLhNP/zKm9Gpdk/2SFWsPXmLYhEy2rqm97tXZs9XZv3apyf57OKHPpxA2uZlm22l9W6FSKTAxVTE8NNOgrE2R3cGlnDHT09T1vvpavSvxDizl0ZeSGvUZO+jeeDy9C5n+UD+SE9VtN+aKPZ98tYch98Xx/ZbmtZYNCs6l76BElr/Vnt0/+QNw7rQLH2/ay/gpEbz+wl0A9OyXTFBwPi8+2U0zcHfiiDsfbNjH5CcvMWtKT4PzGz0VKGR6WJOQNfP+47755hsOHz7Md999x1133cXTTz/N66+/flPP8dprr7Ft27ZblPDfr2u/bMJPKzVfNABSr1px8aQ93QZk1V22fxblZQr2/1RzNqiqUsG+n1y5s2cO5hZVdZbPyzGnqlL/GcYGZR+YR/hJG80HP0BqgiUXjtnSbVDtsw2ulS0vU7DvB0ft7NsdubN3viZ7pz75WFiq+O07J63ye7Y60axNCR5+pZLdiLIbe37JLtn/a/mNOXuXfplEnLHX/nxNtObiKQe69qv7S3DXvpmUlyvY/0vN4EFVpYJ9v7hxZ49szMy1P1/bdMil74g0Pnoz2KCsejMYcd1L9qbJbnMyl5JgW81AHkCFuyUlLeywPVF39sZQHshCZaag4G6n+jeugzHXfdeBuYSftNWffWB92XOrs9dk0pcdQKUyvN/elNk19b5Ve8B3z3eN/4zt0iOViAtOmoE8gNRkGy6ec6Jrz7pnxHXpkUp5uYIDu2smNlRVmrB/tw8du6RjZl4JQMu22ZSUmNwwA0/BqT/daNkmBxfXYoPzC2EoGcz7j7vjjjvo2rUrAwcO5JNPPqFPnz6sXLnypp6jefPmdOigf7q/qJ9/SBFxkbrrOcRFWuMfXFRn2YDgIlKvWlJaoj39PS7SBnMLFV7+JTeUUGFiqkLpWM6QB1O4s0cO29YaPjU/oGUJseG66w7FRVjh3+LGfeuWTUmwoLRY+zAUF2GFhaUK78AyzXZlJQqSYix0tgMIaGHYh79kb5rsxp5fskv2/1p+Y87uH1xI7BU9n69XbPBvXvfnq39wEalXrXQ+X+Ov2GJuocI7oOaLm6lZFU8viOS7tb5aA4eNZcx1L9mbJrvF1RLK/HSzl/laYZFYd/Zr7H/LoNnE0wRNPo33W5FYhRfUub2irArbo9kUdrCnyq5xF30Zc90HtCghNkJP9ssNyN6iOnvJDdkvX8tu+OdPQ/wd2QNa1FLvl600fzc4f1A+cdFKncfjY5T4B9bdfv2b5ZOaZENpqXbbjYtRYm5Rhbev+rOiqkpBZYXu0El5ufqxgOb5hsYXwmAymCe0dO7cmby8PNLS0jSPbdmyhdatW2Nra0unTp04ePCgVplJkyYRGBhY73Nv2rSJ9u3bY2VlhaurKxMmTCA5OVlrmy+++IIOHTpgZ2eHvb09t912G6tXr77p5wkMDGT8+PF88sknBAcHY2VlRceOHfn999/1Zjt16hQ9e/bExsaGkJAQVq1apfnbiRMnUCgUbN++XafcpEmT8PX1pbKyst7XXxulQwUFubqdn/xcc+zsK+ou61hBQZ6+smaav19vxPgUfgo/zNfHjvH4vBhWvRnIb98bvmir0rGSglzddTTyc0xROtRdJ0rHCgpy9Je9PrvSsZKCPFNAUed2N0uy65a9PtOtyq55biPNL9l1y16fSbLXlsF48xt1docKCnJ1F+IvyDXDzr68nrLldX++OtRkeuCxBMwtqvh6jb9BOWvNYMx1L9nrzHSrspsWVFJlq7v/KltTTArrf8787k6kT/Ij6aVg0h/zx6SgAu+3I7G6WPtAhe3xHEyLq8jv6VLrNg1lzHWvdKysZf9mDche2+s20/z9Vvo7stde741/jXb2ZRTk696oIz/PAjtlPcd6+zIK8vV8TuSZa/4OkBhvh61dBX4B2u+FVu2yq7erez9C3AoymCe0xMTEYGpqip2demHnAwcOsHTpUt544w2++uorKisrGT58ODk5OTf1vGvWrGHChAm0bt2arVu38u6777Jjxw569+5NQYH6jMnBgwcZP348vXv35vvvv+fbb79l6tSpWvtqyPNcs3fvXpYtW8Zbb73Fli1bsLS0ZMiQIURERGhtl5eXxyOPPML48ePZvn07nTt35vHHH9cM/N1555107txZZ1AxJyeHr7/+milTpmBqWvfCsP8U+3925ZlRt/Pqo63Z8Y07j8+LYchD/94FWYUQQohbycu/mAenJ/Dxm8GUl0m3Whi3tCcCKezmREkrOwp6OJM4rwUVjuY4f5NcaxnlgSwq7M0ousPwNc+E+Kfbu9OH3GwLZr52moBmedg7lDI2NJJ27dVLIlXVvbKRELeE3ADjP66yspKKigry8/P5+uuv2bp1KyNGjMDGRn1ZSl5eHqdPn8bJSb0OgqenJ507d+bnn3/mkUceafA+XnvtNfr06cOWLVs0j7dq1YqePXvy+eef88wzz3DkyBEcHR1ZsWKFZpuBAwfe9PNck5aWxuHDh/HzU9/5qH///gQEBPDmm2+yceNGzXb5+fl89NFH9O3bF4BevXqxY8cOvvzyS81jTzzxBI899hhxcXEEBAQAsGHDBsrKypgyZUqD6qE2BXlm2DnongWsbVbA9fJzzXD31p16f23GwLWzXdfkZpmTm6U+03TigBOW1lVMeSGWnd+66506Xm/2XFPs9JyxUzpWkq/nLN2NZd19dc9iXTszdy17Qa4pdvaVgIrrz+bduJ1kN47smuc20vySXbIbwpjzG3d2M+wcdPdv51ChmXVRa9k887o/X6tn6M14+QpnjjoSfsYeW6X6b+bmVaBQ3922vExBWalhJ/yMu+4le1Nkr7Q1xaRQN7tJYSVVtjf/nCprU4o6OPB/9u47PKpi/+P4e9M2PSEkIaQnJBCKVEFAqSLSrddGV5pcvQoIeAUhiKiAgHi9/gBpCti4gIgi0qQoRZCilISQSkjvve/vj002LNm0DRCOfF/Pk+eBzczZTyaT2d05c+bYHzK8x6RpejFWF7LJHOgCpg3fy03JbZ+TaYqtgdVldo4ldcxe9Q7BFasEsw2smruV7kT26tu94T9jTrY5tnYGMlSz6k6vbpYFrs2q7ndXsXo7O0u74i83x5xFb93P9Lnn+HTzYQDiYq3Zsr4lYyaFkpZa9TLle4rcAKNRyCnEe1xQUBDm5uY4OTkxdepURo4cyfr163Xf79Gjh24iD+C+++4DICYmps7PERoaSlJSEiNHjtR7/KGHHsLHx4fDh7UDYteuXUlPT2fUqFH88MMPVVb/1fU4Fbp3766byAOws7Nj6NChHD9+XK+ctbW1btIOQK1W07JlS72f8bnnnsPR0ZHPPvtM99jq1asZOnQonp6G74a3Zs0a7r//fu6//36KNNXvAxEdZoWPgb3xvAPyiTGw18+NYq5a08yzELWl/guwd0AexUUq4mNqfmEJ+8sWa9symjgbtzQ8OtQSn1ZVfzbvlgXEXKn5uaNDLXHzKkJtpX8qy7tlAUWFKuKiLHTlLCwr9zq5sRxA9BU1xpDsjZNd6fklu2S/1/IrOXvMVWt8DOyN590ij5jwml9fo69a08yzoOrra4tciotUxEVb6Y7VrU8aW08e0331HZaMc7Mitp48xrhpUUZlB2W3vWRvnOzFnpZYxFbNbnG9gCIP4ycbqrvngt1vaajKILtXw+5iW0HJbR99xdLgvm/egfXIbnlT9sCK7Ma//tTFncgefaW2dje+f8ZE2uHtV/VScC/fHGKibGut28w9D7Vaf2GFt182xUUmxMVWvlZcPN+Ul/7Rn4nP9GPy832Z9Gx/SktMKCgw4WqIg9H5hTCWTObd43bs2MGpU6cICQkhNzeXL774AienyhfkG/8N2okugIKCum9SmpamXX7cvHnVGy24ubnpvt+nTx+2bt3KtWvXeOKJJ3BxcWHAgAH8+eef9TpOhWbNmlUp16xZM65fv6732I2TlRXUarXez2hpacn48eNZv349JSUlHD16lEuXLjFlypRqf+5JkyZx+vRpTp8+jYWq+heokwedCOqYjZtX5fO5ehTQpnM2Jw7UfFewkwebYG6hodfgyjOmJqYaeg9N5cyvjrVe8nNftyzyckzISK35rFV1Tuy1p3XnPNy8K1cvNPMsom3XXE7srflyixP77LXZh2XoZe8zIoMzR+x02U/9YkdxkYp+T6br1X/4qXQiL1uSeM24NziSvXGyKz2/ZJfs91p+RWf/pSlBHbJw86xcdeHqXkCbTlmc+KXm/b1OHmqKubmGhx5N1svea1AyZ35rQkn5pucfzGjN7LHt9b5OH21CZpo5s8e2Z9eX7tU9Re35ldz2kr1Rsud2dsDyai5mSZXZzZILsbySQ27n+l8Gq8orxfpsJoX+hie/bY+mUehtSZFvzZPjdaXkttdmz70pe6E2+76aJ3p02YfXnP12uRPZde3+xE3t/mTDX2NPHnUjqG0Gbu65usdc3fJo0z6Nk7+61Vz3t2basb5/5aXkJqZl9H44jjO/u1BSfPOKQRVxsbbERtuhtizl0RHR/LLHk8ICueBR3HnS6+5x7dq1IyAg4LY+R8WEYEJC1b3ZEhIS6NKli+7/Tz/9NE8//TQ5OTkcOnSI2bNnM2jQIGJjY+t1HIDExMQq5RITE/Hw8DDq53j55ZdZvnw5O3fuZMeOHfj6+vLoo48adawb/fRNM4aPSmDe/4XwxQpvNBoY83oMyQkW7P668gXI1b2A9QfO8OV/vfjyE+2Kw/BLthz+oSmT5kRiaqYhMVbN0BcScPMsYMn0QF3dwc8lENQxm3PHHElJsMDOsYTeg1PoNTiV9Uu9dR9K6mv3FidGjE8heEMUny9xQ6OBsTMTSI6z4MdNlR+UXD2K2Hj8MltWNGPLCu3PFH7BmkM7HZmyIA4zcw0JMRYMG5OKm1cRi1+p3EQ8M9Wc7Wucee6VJPJzTLn6lxV9RmTQ4cEcgsf5GZVbsjdedqXnl+yS/V7Lr+Tse/7XnOEj45j3yUW++NgXjUbF6FejSE5Q89O3lScGXd0LWLfnd778Px+++j/tVhoRl205vNuFSW9GYGamIeG6JUOfjcfNs4Cls4J0dUP/rDrBMODxRIqLVPx1ytHo7KDstpfsjZM9q19THPYl47YsgrR/NAeVCqf/xVHiZEHWw866cmbJRXhPv0j6E26kP6n9W3D4MRGLuELy29hS0sQc85QiHH5MwiyjhKSpvlWeyyIyD3VsASkjjXtfbYiS2373lqaMGJdC8PpIPl/SXJt9Vrzh7McusWWFG1s+Ks9+sTx78HXteHPNgmFjUsqz++g9T2D7PJp5FWFior2u0adlIQ8NzQDg1AH7KneVvVuya9vdhedeSSQ/10S/3cc37DV2z/feDHs6krcXn2LTmiA0Ghg1MZSURCt++q4yg4tbHuu+PchXG1ry1YaWAERcceDwfncmvXYRU7MyEuOsGfJkNM2a57E0uJPe84ydcpmroQ5kZVjQ3DOXp14Ip7TEhI3/17pB+YUwlkzmiduuVatWNGvWjK+//pqXXnpJ9/ixY8eIjo5mxowZVerY2toybNgwIiIieO2110hNTa33cU6cOMG1a9d0l9pmZ2fz448/MnToUKN+jhYtWjBw4ECWLl3KuXPnmDdvHiYmDT9TVphvypuj2zJpTiQzPwwDNJw77sjqRb4U5N1wNkgFpmagUulvSrD8zQDGTo9hzLQYbO1LiAixYe6LbQi/VLmsPCrUmh4PpzFhdhR2jiVkpplzLdyKeRODOHXI+EsjCvNNmfVMC6YExzHz4xhUKjj3qy2r5nnoZVdVZL+puZZN82Lc7HjGzkrA1r6UiEtWzBnpz9W/9M/wbvygOfm5pjw+IZkmLiXEhqtZNNmHk/uN32xZsjdOdqXnl+yS/V7Lr/Ts/x7fnkmzI3jjg1BQwfkTjqx+v4X+6yva7BUfjiusmNOSsa9FMfq1KGztSogMteXtSfcRftnO6Ez1za/ktpfsdz67xtKUuLcCabo5lmb/Fw1Afls7UkZ7oLG8sc9rUJWht89VcXNLbE5lYnM6A5P8UsqsTCloaUPyJG8KW9hUeS67o2loTCHnwZqvIqkPJbe9NnsAU4KvM/Pj6Mrs82/OrinPrj/eLJvuXZ49vjL7KH+uXtDPPmJ8MgOfqVzd1nt4Br3LV8WNeaA1ibH1X+F2p7JvXNyc/DwTHn/phnaf4svJ/Q27RLWwwIy3Xu3BxH9dZMa8s4CG8384s+ajdhTkV053qABTM02V/B+925ExU0IYMykUG9tiIq/aM2/6A4RfcdQr5+hUyKTXLuLQpJDMdDXHD7uxeW0rg3fSvZeogJs+noo7RKXRaKTp70EbN25k/PjxhIWFVbsyz9fXl4ceeojNmzfrPa5SqZg/fz7BwcEAjBs3jkOHDhEVFQVAVFQUfn5+bNiwgXHjxgHa/eMmT57MyJEjGTVqFNevX2fOnDnY29tz9uxZbGxsmDdvHomJifTr1w93d3diY2OZN28ednZ2nD17ts7HqcheWlqKra0twcHBqNVqFi9ezJkzZ/jrr79o2bKlLvv+/fuJjY3V+xn79u0LaO+Ie6Pvv/+exx57DHNzc65du2bwUl5DHEyd6W49rE5l7zZlubm1FxJCCCEaiamjcvcqKs3IbOwIQoHCt3SqvdBdrMXIs40dwXiqht/oQxjHzMer9kJ3oWPXt5BZWPXKsr8L26ZetBs8rbFj3DYlIV9y+vTpxo5hkKzME3fEpEmTsLa2ZunSpTz22GPY2toyZMgQlixZopuAe+CBB/j444+ZNm0aaWlpuLq6MnDgQBYuXFiv41To06cPffv25a233iI2NpY2bdrw008/6SbyjDF06FCsrKwYOnRonSfyhBBCCCGEEEIIIW4VWZkn/paqW1XYUPv27WPgwIHs37+fhx9+uM71ZGWeEEIIcXvIyjxxr5GVeY1IVuY1GlmZd3eSlXmNR1bmCVEH4eHhREREMG3aNDp37lyviTwhhBBCCCGEEOJvSdaHNYrbe59rIf4mFi5cyODBg1Gr1XzxxReNHUcIIYQQQgghhBD3KFmZJ/6WKm7Gcats3LiRjRs33tJjCiGEEEIIIYQQQtSXrMwTQgghhBBCCCGEEEIhZDJPCCGEEEIIIYQQQgiFkMtshRBCCCGEEEIIIUS9qeT+F41CVuYJIYQQQgghhBBCCKEQMpknhBBCCCGEEEIIIYRCyGSeEEIIIYQQQgghhBAKIXvmCSGEEEIIIYQQQoj60ZR/iTtOVuYJIYQQQgghhBBCCKEQMpknhBBCCCGEEEIIIYRCyGSeEEIIIYQQQgghhBAKIXvmCSGEEEIIIYQQQoh6U5U1doJ7k6zME0IIIYQQQgghhBBCIWQyTwghhBBCCCGEEEIIhZDLbIW4AzRlZZTlFzR2DKE0KlVjJzCaysy8sSMYTVNS3NgRGsTEyqqxIxhNU1zS2BGMpiktbewIDaIyNW3sCEYrzchs7AhGM3Vu2tgRGkal3HUBpcnJjR3BaC1Gnm3sCA1SuNe3sSMYTT0wqrEj3LNKomIaO4JRNJqixo4g/qaU+woshBBCCCGEEEIIIcQ9RlbmCSGEEEIIIYQQQoj60zR2gHuTrMwTQgghhBBCCCGEEEIhZDJPCCGEEEIIIYQQQgiFkMk8IYQQQgghhBBCCCEUQvbME0IIIYQQQgghhBD1ppI98xqFrMwTQgghhBBCCCGEEEIhZDJPCCGEEEIIIYQQQgiFkMk8IYQQQgghhBBCCCEUQibzhBBCCCGEEEIIIYRQCLkBhhBCCCGEEEIIIYSoHw2gkTtgNAZZmSeEEEIIIYQQQgghhELIZJ4QQgghhBBCCCGEEAohk3lCCCGEEEIIIYQQQiiE7JknhBBCCCGEEEIIIepNJVvmNQpZmSeEEEIIIYQQQgghhELIyjwhGplL8yImB8fSuVcWqODsr3asmu9FcpxFrXXN1WWMnRlH/yfSsHUoJfyiNevec+fCSTu9ck9OTKRDz2wC2+fRtFkJm5a7sXm5+63J717E5OA4OvfO1uY/aseq+e4kX69j/lkJ9H8yHVv7UsIvWrFuUXMunLTVK6dSaXjmn0kMGZ2Kk0sJseFqtqxoxq+7He/x7Nfp3OvG7B716DfxldkvWbFukXuV7E9OSqJDz5zKfrOsGZuXN29Q7grOzQuZPO8anR/KApWGc7/Zs2qBN8lx6rrln3Gd/k+kYmNfQsQla9a978WF3yv7vYdfAcPHJNKhRzZu3oXk55py5bwNny/zIPKydYOy34m21/WbUSnafhOhZssKtwb3G+fmhUyeE0WnBzNRqeDsbw6sfteX5Pg6tLtFGWOmxdD/sRRtu1+2Yf0SHy6csteVsbIp5fX3wwlom4OTSzElJSquR1qy84vm/LLTpeHZFdpnQNljvZLbXsnjPIBzswImzQqjU/c07d/sCSfWLAkkOcGy9vwWpYx+JZL+QxOwsSshItSWDR+14MIfTaqUbepayOh/RnB/r1Ts7ItJTVZz5KdmbPy4RcOyz7xCp+6p2uwnnVizpFXds/8zgv5D48uz27HhowAunDGUvYDR/wzn/oduyL7HjY0fBxidXcn9RsnZAUgqwWxVGiZn8gEo62RFyctO4Fq3j62qmCJMP8/A5HwBFGjQuJpSNtye0ifs9QumlGD2eQYmv+dBThk4mVHa14bSl6r2sbpSctsrOfvfIb8QxpCVeeK227hxIyqVSvdlZ2dHhw4d+OSTTygpKQHA19eXUaNG3bFMvr6+jBs37o49X3XUlmUs/jYMrxYFLJ3my9LXfPHwK2TJt1dQW5XWWn/6h9EMfj6VTcvcmTe2BWlJZry35Sr+bfL0yg1+IQVH5xKO/+x4a/NblbH423C8AgpZ+ro3S//lrc2/Nbxu+ZddY/ALqWxa6sa8sX6kJZnz3pcR+LfN1ys3dlYCo2YksmuDM3NH+XP5jDVz1kTTtX/WvZndsozF317Fq0VFdp/y7Ffr2G/Ks3/YnHnj/ElLNOe9LeH4t72536Ti2LSE4z87GJ3VcP5SFn8VileLAj6c4cfSaf64+xay+OvQOuWftiSSQc8l88UyD+a/2JK0JHMWbQrV6/ede2fSoUc2+7Y5M/+lQD6Z64ND02I++u4SAe1yG5D9zrT92FkJjJqewK4NLswd7c/lMzbMWR3VwH5TygebLuHpn8+ymQEsfSMAd998Fm+5WLd2fz+cQc8msWmlF8ETW5OWZMG7Gy7h37qyPc3MyygtgW9WebBgchBLpgVyLdyaWcuu8vj4uAZlV2qf0eZX7liv5LZX8jgP2rZ/f+1ZPP3yWD63DR++1QYPnzw+WHemTvlfXxDCoCfj2PSpH8GvtictWc3C/zuPf6tsvXKu7vms2HIKD588Vn8QyJzJHdnyf36Ulqoalv2zP/D0y2X52235cE5bPLzz+GDtH3XLHnyZQU9eZ9OnLQh+tSNpKRYs/L+zNWdf3Io5Uzqz5f/8G5Zdwf1GydkBKCjDfFYCqmvFlMx0pmSWC6rrxVjMTID8slqrq64UYv6veCjWUDKtKcXvulL6lAOU3nQNYEIxFq/Go4otpmRqU4rfd6NktCOYGh9dyW2v5Ox/h/xCGEtW5ok7ZuvWrXh6epKVlcXWrVt59dVXSUpK4p133rnjWXbs2IG9vX3tBW+zwSNTcPMuZEKfNsRFac9UR1y2YsPRiwwdlcL2z5pVW9e/dR79n0hn2XQf9n7bFIA/T9ix5uAlxrwRT/CLlWfTJ/Vvg0ajwsRUw7AxKbcu/wupuPkUMaFXEHFR2hUaEZcs2fBbCENHp7F9TfUrcfzb5NP/yQyWTfNi7zdO2vzHbVlzKJQxMxMIHucHgEPTYp6aksy3/3Xlf6tcATh/zBZ33yJefCueUweN+z0qOvvIVNy8i5jQu3Vl9suWbPj1MkNHp7J9jWst2dO12Sv6zXFb1vwSwpg3Egge768rO6lf0A39JtWorIYMej5Z2+/73Ud8tLbfR4ZYs/7Qnwwdmcz2tW7V1vVrnUf/x9NY9oYv+7Zqf0d/nrBjzb4LjJl+neAJgQAc/t6JXZ+7ApUf6M4ds+Pz3/7k8RcT+XC6v6HD1+pOtL1D02Kempyk7TerK/qNHe6+hbz47zij+82gZ5Nw8ypg4sCOxEdbAdp2X7f/LEOeT2TH+upXcPkF5dLvsRSWz27Bvm3aTH/+bs/qn84x+vVrLJgcBEB2hjlLprfUq3vqcBM8/PIZ+HQS320wbpWYkvsMKHusV3LbK3mcBxj0VBxunvlMGtGd+GvaFYqRYbas3XWCIU9fZ8cm72rr+rXMpt/QRFa8HcS+ndq/u79OO7Jqx++M+mck7/yrva7sK2+Hkpqk5s0JnSgt0Z7nv/CH0bG12Z+8rs3+WM8bstux9vtjDHk6lh2bfGrJnsCKeW0qs//hyKrtJxg1NZx3XutYmX1uSHn2LjdkN35lFSi73yg5O4DpTzmoEkooWucBHuYAlPmZYzH+OqY/ZlP6dA0nF8s0mC1JoayjFSXBla/Fmo5Vi5p/nIrG2ZTipW5gph13NO2rlqsPJbe9krP/HfL/LcieeY1CVuaJO6Zjx450796dgQMH8tlnn9G3b19WrlzZKFk6depEixbGXzpyq3R/JJOQMza6D3cAidfUXDxtS49HM2uuOzCT4iIVh7+vfNNaVqr9f5c+WZhbVJ7B1GiMP0Ndc4YsQs5Y6144oTz/KZs65M8qz++oe6ysVMXhnY506ZOty39/32ws1BoObNN/c35wexP82xTQzKvwHsxe0W8MZB9oZL+5KTvcxn7zSAYhZ211EwNQ0e/t6P5IRo11ezySQXGRiiO7nHSPlZWqOLTLic69M3X5s9LNuXFiACAv24zrEZY0dSsyPvsdaHtdv9nupFf/4LYG9puH0wg5Z6ebyANIjLXk0hk7egxIq6Vuurbdf2yqn/1HZ7r0ytDrN4ZkpZtR1oCVMkruM9r8yh3rldz2Sh7nAR7om0Lonw66yTCAxOtWXDrnQPd+NU/Wdu+bQnGxiiM/V04Ul5WacHiPK116pmJmrs3v5pnH/Q+msesrT91k2K3wQN/k6rP3Ta4le3I12ZsZyJ7Krq+8bml2JfcbJWcHMDmehyZIrZvIA6C5OZq2akyO51VfEVCdL8AkppjSp2qZVIkrxuR0AaWP2esm8m4FJbe9krP/HfILYSyZzBONpmvXrmRlZZGUlKR77Ouvv6Z169bY2Nhw//338+uvv+q+t2zZMtRqNcnJ+m8CNRoN/v7+PPfccwCUlJTw9ttv06JFCywtLXF2duahhx7SO5ahy2wjIyMZPXo0bm5uqNVq/P39ee2113TfP3XqFI888ghNmzbFysoKf39/pk6d2qA28GmZT1SoVZXHo0Mt8Q4sqKVuAQnXLCgs0P8zjg61wkKtwd339r+o+LQqICqk6t430aGWeLesJX+r8vz5N+e3LM9fpCtXVKAiLtKiSjkAn5bG/ZyKzt6ygKhQA9mv1CF7df3miuWd6zeB+UQb6vdhlngH5huoUck7MJ/Ea2oKC/SvhYm+Ut7vfarPb+tQgm+rfK5drfrcdXUn2t6nZTX95oql7vvG8A7MJ/qKoXa3xjug5nb3CcwjMdZAu4dZYW6hobnPzZk0mJhqsHMsZvCziXTplVnjyr/aKLnPgLLHeiW3vZLHeQDvFrlEXbWpmj/cBm//mi8/9m6RS+J1qyptH3PVBnMLDe7e2omRNp20H3QLC01ZtPosO0//wje/HmHGokvYORQ3LHu4bZXHo8Ntjc8ebqufvWOGNnuBCYtWnWHnqQN8c/QQM969gJ2D8ZPASu43Ss4OoIouQuNrXuVxjY8Fqpia+6PJxfLnLdJg/q84LAZHYfGPGEz/mwqFZVXLWagwn52AxdAoLJ6MwWxJMmTVfklmdZTc9krO/nfIL4Sx5DJb0WgiIyMxNTXF1lb7Zu/o0aOEhoaycOFCLC0tefvttxk2bBhRUVE4Ojoyfvx45s6dy4YNG5g1a5buOHv37iUyMpL169cDsHjxYlasWMGiRYvo2LEjWVlZnD59mrS06leeREZG0q1bN6ytrXnnnXcIDAwkJiaGvXv3ApCTk8Ojjz5Kt27d2LhxI3Z2dkRFRXHs2LEGtYGdYyk5mVU36MjOMMPOoaSWuiXV1DXVHft2qz6/KXYONT+/nWMJORk15S+pfI4sU25etXFzufpSfHaDz29Wh+zV97mK799udo6lZBvIkFPHfm+4rvYx2xradOo70aCCHeuqv6SxNnei7avvNw37Hdk5lJCTVfVlPzvDDFv7Oow31dStOPaNho9OYOr8KACKi1SseteXA98ZfwMMJfcZbQbljvVKbnslj/MAdg7FBv/ucjLr8DdbTd3sTPPy72vrN3XRfgCdtuAyB39w49t1PjT3ymfca+F4++fy+gv3G7Xi8/ZkLx9v7LWTOk1di8qzX+LgD835dr0vzb3yGPevcLz9z/L6yG7GZVdwv1Fydu1BytDYVV1rorEzgeyaV4CrUrXPa/5eMqUj7Ch7qQkmV4ow/SIDVXKp7tLbinJmy1Moe9iWkuccUMWVYLY+HfPoRIr/0xxMpN9UHPduz647toLzC2EsmcwTd0xpaSklJSVkZ2fz7bffsn37doYPH461tfYSjKysLM6dO0eTJtrly25ubnTt2pXdu3fzwgsv4OTkxLPPPsuaNWuYOXMmKpV2MF29ejVBQUH07dsXgOPHjzNw4EC9VXXDhw+vMdv8+fPJz8/n/PnzuLtXrh4ZO3YsACEhIaSnp7NkyRLat6/cVONuuImGEKJ2z06No//jaSyf6at3uaC4PY786EzIWTvsnYrp/nA6L8+LpKxUxU9fN2xS7E6SPtN4pO3vHFX5vMmfp5vw6XutADj/O+TlmPHm0ot0eTCN0782reEIjUel0m7S9OfpJnz6vnbfzvO/O2mzL7lAl56pnP7NuTEjijupfK6vtL8NpWO1nyVKO1hBGZitS6c0pgiNt4Vub6+y9paUvKrt25pOUGJjgvl7yZiczqesW8PvYC6EELebXGYr7pigoCDMzc1xcnJi6tSpjBw5UreaDqBHjx66iTyA++67D4CYmBjdY1OnTiU8PJwDBw4AEB8fz65du5g0aZKuTMUE4Jw5c/j1118pKqr9Uou9e/cybNgwvYm8GwUGBuLo6MjkyZPZvHkz165dq/WYa9as4f777+f++++nGMNLr3MyTbE1cMZIu5qh5rn26utqH8s2cJbpVqspg6HVGFXqGlhRUpnfrLKcfSk376x6c7n6Unx2g89veBVMlbrV9DltpjvTbwydKbWtY783XFf7WI6BNh0yMonxs6+zcakHe781fnVYxfPf7ravvt807HeUk2V4RUx1q+5ulF3Nahpdppt+b5lp5oRdsOWPI03473x/Dn7nwoQ3ozA1q/1uhAazK7jPVGRQ6liv5LZX8jgP1f/N2lazyla/rrnhv9nyS2crfnfZGdqVemeP6+8DdeaYdp9D/yD9u8fWVXXP37Ds5eNNljZzxSrDsyf09xc9c0w7QWN0dgX3GyVnB8DWBJWBFXiq7DIwsGLvRhp77c+n6ax/aX5ZF+0JAdVV7ecBjZ22XFl15cKNu0RbyW2v5Oy6Yys4v9KpAJXm7/t1N5PJPHHH7Nixg1OnThESEkJubi5ffPEFTk6Vb8Bu/DeAWq3dxLSgoHKvg27dutGlSxdWrVoFwNq1azEzM9OtoAN46623WLBgAd9//z29evWiadOmjB8/npSU6jeLTk1NxdPTs9rvOzg48Msvv+Du7s7UqVPx9vamXbt2bNu2rdo6kyZN4vTp05w+fRpz1AbLRF+xxKdl1T2HvFsWEBNW82qE6CtWuHkVobbUf9Pj3TKfokKV3iawt0t0qCU+raruReHdsoCYK7XkD7XU5re6OX9BeX4LXTkLy8o9K24sBxB9xbifU9HZr1ga3DfNO7Ae2W/uN4EFd67fhFkZ7Pc+AQXEhNW8P1b0FSuaeRWittR/4+UTWN7vo/XzP/xECq+8G83/1jTj60+M37Ot8vlvf9tHX6mt3xi3Uik6zAofA3uceQfkE1PLvmQxYVY086za7t4B+RQXqWpdPRV2wQZr2zKaOBu3B5eS+4w2g3LHeiW3vZLHeYCYcBt8WlTdX87bP5eYiKp76enlD7ehmUd+1b/ZFrkUF6mIi7HWlauJxrj59/LsOVUe9/bPMT67f85N2avuyXcjY28Io+R+o+TsUL43XnTV1wlVTBEa76p76enXrfn7FVdHGtqTz1C5+lJy2ys5+98hvxDGksk8cce0a9eO+++/n1atWmFpafxlM1OnTmXnzp1cv36dtWvX8o9//ENvItDc3JzZs2fz119/ER8fz4oVK9i2bRv//Oc/qz2ms7Mz169fr/F5O3bsyLZt20hLS+P48eO0aNGCZ555hgsXLhj9s5zY60jrzrm4eVeu3GvmWUjb+3M4sdeh5rr7HDC30NBrWLruMRNTDX2Gp3PmiB3FRbf/z/vEXntad867KX8RbbvmcmJvzXcTO7HPvjx/hu4xE1MNfUZk6OU/9YsdxUUq+j2Zrlf/4afSibxsSeI14148lZ/dQL/pmsuJfbX1m/Lsw2vOfjud2OdIUKcc3Lwq33g18yykzf05nNjvWGPdkwcctfmH6vf73sPTOHPUXi9/z0fTmf5hJHu+dmHtIu9bk/0OtL2u3zxxU795smH95uQBJ4I6Zuu1u6tHAW06Z3PigFMNNeHkQSdt9sGpetl7D0nlzK+Otfab+7plkZdjQkZqLR+iqqHkPgPKHuuV3PZKHucBThxyIah9Fm4elZOpru75tOmYyYlDNV8+evKwM+bmGh4aWHmTMRPTMno9msSZ406UFGvzh/xpT1qyBV166u8r3OUh7d/6lYu13Bm0puz3ZeHmUXkHUl32wzWvuNRlfyTxpuyJnDnetPbsD5Znv2BkdgX3GyVnByjrYYXqciHE3zChl1CM6mIhZT1qvvS1rJsVGnMw+UP/5IPJKe3/y1pqc2laq9E4mVYtd7q8XKt7r+2VnP3vkF8IY92760GFYj3//PO88cYbvPDCC8TExDBlypRqy7q5uTFhwgR2795d46TbwIED2b59O/Hx8TRv3rzG5zczM6N79+4sXLiQ77//nsuXL9OuXTujfpbdXzZlxPhkgteH8/kSdzQaGDsznuQ4C37cXPlG3dWjkI2/XWTLR83Z8pE2X/hFaw7tbMKU4FjMzDUkxFgwbEwKbl5FLH7VT+95Atvn0syrSLefr09gAQ+Vf7g6dcChyl0S65x/ixMjxqcQvCGKz5e4ledP0ObfVLnHjqtHERuPX2bLimZsWeGmzX/BmkM7HZmyIO6G/Kna/K9UfpDLTDVn+xpnnnslifwcU67+ZUWfERl0eDCH4HF+VTLdG9mbMmJcCsHrI/l8SXNt9lnxhrMfu8SWFW5s+ag8+8Xy7MHXMTPTkHDthn7zio/e8wS2z9P2GxPtGnOfloU8NDQDgFMH7I3uNz995cKIsUnMX3uVzz/0AA2MmXGd5HgLdm+p/JDn6lHIhiN/smWlO19+7FGe34ZD3zsxeX6Mtu2vqRk6Kgk3z0KWvOavq9uuWzZvfhxOxGVr9v2vKUGdKleIFBepCL9Y88qQ6tyJttf2GxeeeyWR/FwT/X4z3vh+89M3rgwfHc+8VSF8scIbjQbGvH5N2+5fVe5l5+peyPqDZ/jyE0++/MRLm/2SDYd/aMqkuVGYmmtIvGbJ0JEJuHkVsGRGgK7u4OcSCeqYzbljDqQkWGDnWELvIan0GpzG+iXeug/h9c6u4D4Dyh7rldz2Sh7nAfZsc2f4c7HM+/hPvviPPxpg9D8jSU5U89PWypWLrs3zWffjCb5c7ctXq7XPGRFix+GfXJk0K0w73ly3ZOgz13HzKGDpv9vq6paVmrBhZQtmvHuZV+aG8NsBF9y98xnzagTnf3fk/MkmN8eqW/btHgx/7hrzVp7ni09aoNGoGP3PcJITLflpq4d+9h+O8eUaP75a7V+e3Z7De5oxadaV8uxWDH0mtjx75fstbfYAZrx7iVfmXua3A664e+Ux5tVwzp9qwvnfjcuu5H6j5OwApYPtMP0+G/P5SZSOawIqMP08HVzMKB1qV1kwsQSLsbGUjnKkdJSj9jF7U0qfc8R0Swam1iaUdbTE5EohplsyKX3EBjzKTyaZqih5sQnmH6bAyhRKH7RBFVeM2cYMyjpYoulo3IIDJbe9krP/HfILYSyZzBOKY2Vlxbhx41ixYgX33XcfPXv21Pv+Y489RocOHejcuTNNmjTh7Nmz7Nmzh8mTJ1d7zAULFrB792569uzJW2+9RUBAANevX2fPnj1s3ryZH374gTVr1vD444/j5+dHbm4uH3/8MXZ2dvTo0cPon6Uw35RZzwQyJTiWmSujUKng3K92rAr2pCCvco8HlQpMzUBlon/h/rIZPoybFcfYmXHY2pcScdmKOaMDuHpB/+zliHHJDHym8sx17+EZ9C5fHTSme1sSY407m6TN34IpwXHM/DimPL8tq+Z5VJNfv/6yaV6Mmx3P2FkJ2vyXrJgz0p+rf+nn3/hBc/JzTXl8QjJNXEqIDVezaLIPJ/cbd9b975E9gCnB15n5cXRl9vk3Z9cY7jfTvcuzx1dmH+Vftd+MT2bgM5VnIPX6zQOtG9RvZj/fisnzrjFzRYQ2/2/2rH7H22Dbm9zU9svf8GPcrFjGzIgt7/fWzB3bkqsXKj/wd+yZhYWlhsD78lixPUSvfuI1C8Y+1MHo7Hei7Tcubk5+ngmPv3RDv5niy8n9Na/iqi37m6PaMmlOFDM/vApoOHfcgdXv+uplR5ddv/7y2S0YO+MaY6Zdw9a+hIjLNsx9sTXhFysvdYsKtabHgDQmvBmNnWMJmWlmXAu3Zt6EIE4dMu6DdUV2pfaZivxKHeuV3PZKHucr8v97QicmzQrjjfcugQrOn2zC6iWBFOTf8BZeBaZmGt2Jlwor5rVm7KsRjH4lAlu7EiKv2PL2yx0Iv2ynV+7A983RlMHTL8bwyOPxZGea88sPbmxc6Y+x1xwW5pvy74ldmDQzlDcWXSzP7sTqpS0NZ1fdnL0NY18NZ/Qr4ZXZp3YkPES/TQ/sckejUfH0+CgeeSxOm/1HNzauDGhQdqX2GyVnB8DKhKIlbpitSsNsSTJooKyjJcUvO4HVDWE1GlRlQJl+vykd5QBWKkx/yMb0f5ngZErpP+wpHemoV65soC3FJmD6TSbme3PAzpSyh20oebGJtnGMoOS2V3L2v0N+xdNotF/ijlNpNNLy4vbauHEj48ePJywsjICAAINlfH19eeihh9i8ebPe4yqVivnz5xMcHKz3+PHjx+nZsyeffPJJlctnly1bxtatWwkLCyMvLw9vb2+ef/555syZg7m5ue75+vbty8aNG3X1wsPDmTt3Lvv27SMnJwcPDw8ee+wxli9fTmhoKPPmzeP3338nPj4eOzs7unbtyvz583nggQdqbQN7lRMPmA6sQ2vdhcpqvqW7uI2MfEN5N1CZGXc55d1AU2Lcvm53CxOrmvcxu5tpiqtueq8UmlJlj5Uq09t/85vbRVNs3Ib1dwNT57vzTrF1dvOnYgUpTU5u7Aj3rMK9vo0dwWjqgVGNHUEozEnNAbI0abUXVCg7R0869n2tsWPcNvmx33D69OnGjmGQTOYJRZozZw4rV64kLi4Oe/u7/2yITOYJo8hkXqOQybzGI5N5jUcm8xqHTOY1HpnMazwymSfuJTKZp2x382SeXGYrFOXs2bOEhoaycuVKJk2apIiJPCGEEEIIIYQQQohbRSbzhKI88cQTJCYm8uijj7JgwYLGjiOEEEIIIYQQQtyzVHKtZ6OQyTyhKFFRUY0dQQghhBBCCCGEEKLRKHejCyGEEEIIIYQQQggh7jEymSeEEEIIIYQQQgghhELIZJ4QQgghhBBCCCGEEAohe+YJIYQQQgghhBBCiPqTG2A0ClmZJ4QQQgghhBBCCCGEQshknhBCCCGEEEIIIYQQCiGTeUIIIYQQQgghhBBCKITsmSeEEEIIIYQQQggh6k0le+Y1ClmZJ4QQQgghhBBCCCGEQshknhBCCCGEEEIIIYQQCiGTeUIIIYQQQgghhBBCKITsmSeEEEIIIYQQQggh6kcDlMmmeY1BVuYJIYQQQgghhBBCCKEQsjJPiDtAZWKCiZVlY8cwSllubmNHaBBTe/vGjmC00qysxo5gNE1xUWNHMJrKTNkvjWV5eY0dwXgqVWMnMJqJWt3YERqkrKCgsSMYTcl/s6UpqY0dQYg7Tj0wqrEjGC1qUY/GjmA0/4VnGztCg5i4uzV2BKOoYi0aO4L4m5KVeUIIIYQQQgghhBBCKIRM5gkhhBBCCCGEEEIIoRDKvS5BCCGEEEIIIYQQQjQeuf9Fo5CVeUIIIYQQQgghhBBCKIRM5gkhhBBCCCGEEEIIoRAymSeEEEIIIYQQQgghhELInnlCCCGEEEIIIYQQot5Usmdeo5CVeUIIIYQQQgghhBBCKIRM5gkhhBBCCCGEEEIIoRAymSeEEEIIIYQQQgghhELInnlCCCGEEEIIIYQQov40smleY5CVeUIIIYQQQgghhBBCKIRM5gkhhBBCCCGEEEIIoRAymSeEEEIIIYQQQgghRD1du3aNp59+GgcHB+zt7XnyySeJiYmptd7p06eZNGkSQUFBWFtb4+3tzciRI4mMjKzT88pknhBCCCGEEEIIIYQQ9ZCXl0f//v0JCQnh888/Z9OmTYSFhdGvXz9yc3NrrPv1119z8eJF/vWvf/HTTz/xwQcfcObMGe6//36uXbtW63PLDTCEEEIIIYQQQgghRL2p7uH7X3z22WdEREQQGhpKQEAAAO3btycwMJDVq1czffr0auvOnj0bFxcXvccefPBB/Pz8+Oyzz3jnnXdqfG6ZzBPiLuDsVsjkOZF0ejATlQrOHnNg9bt+JMera61rblHGmGkx9B+RjI19KRGXrVm/1IcLpxx0ZaxsSnn9vasEtM3FyaWIkhIV1yOt2PlFc3753qWGo9fOxb2IycFxdO6dDSo4e9SOVfPdSb5uUXt2dRljZyXQ/8l0bO1LCb9oxbpFzblw0lavnEql4Zl/JjFkdCpOLiXEhqvZsqIZv+52bFB2Z7dCJv07nE49M8rb3ZE17/uTHG9Ze3aLMka/FkX/4Unadg+xYcOHflw47VBtnd5DknhzeSgpCRaM6ftAg7Irud2Vnt+5eRGT51+j80NZoIJzv9qzaoEXyXF1zD4jjv5Ppmr7zUVr1r3vwYXf7fTKPTkhkfY9s2nZPhcn1xI2r2jO5hXuDcoNym53bfbrdO51Y3aPurf7zPjK7JesWLfIvfrso1K02SPUbFnhdkv6vHPzQibPjabTQ1mo0GjH+YU+JMfVcZyfHkv/x1OwsS8h4pIN6xd7ceGUva6MlU0pr38QoR3nXYvLx3lLdm5045edzg3KruR+o+S/V1B220t2yX6v5XezyeHf3Y7xoHssKjQci/fkvZM9ic+1q73yDSbed5Y37j/JH4luvLD78WrLDfG7yoq++0nItaHPt6MblP12v0Z5+OUzbFQiHXpk4eZVSH6uKVf+tOGL5Z5Ehtg0KDuAs2s+E1/9i05dk1Gp4NxpF9Z83I7kROs65C9l9IQQ+g28ho1dMRFhDmz4vzZcPK//2mnvUMj4qZd4oGcCltYlRIXbs3lta8787trg/EK5vv/+e7p3766byAPw8/PjwQcfZOfOnTVO5t08kQfg4+ODi4sL169fr/W55TLbW2jjxo2oVCrdl52dHR06dOCTTz6hpKSkXsfq27cvffv21f3/0KFDqFQqDh06pHvso48+Yvv27VXqBgcHo1KpjP0xalTxM0ZFRdVYrrCwkBUrVtChQwfs7Oywt7cnKCiIsWPHEhYWVq/n9PX1Zdy4ccaHvsupLUv5YNNFPP3zWTYrgKVvBOLuU8DizRdQW5XWWn/a+1cZ9Ewim1Z6EzwpiLRkC95dfxn/1pXLes3MyygtVfHNKg8WTAliyfSWXAu3YtayMB4fF2d8dqsyFn8bjldAIUtf92bpv7zx8CtkydbwOmWfvuwag19IZdNSN+aN9SMtyZz3vozAv22+XrmxsxIYNSORXRucmTvKn8tnrJmzJpqu/bOMz25Zyvsb/8TTL5/lb7bkw1mt8PDN54PP/6pT9tcXXWHQPxLY9B8fgqe0IS3JgoVrL+AflGOwvI1dCZP+HUFakrnRmXXZFdzuSs+vtixj8ddX8GpRwIfT/Vj6uh/ufgUs/ia0bn+vS6IZ9HwKXyxzZ/74ANKSzFm0OQz/Nnl65QY9n4Jj02KO/exodNYq2ZXe7t9exatFRXaf8uxX65b9w/LsHzZn3jh/0hLNeW9LOP5t9dt97KwERk1PYNcGF+aO9ufyGRvmrI5qeJ+3LOWDLZfx9C9g2Rv+LJ3RAnffAhZvuVy3frM4gkHPJbFphSfBE1qRlmzOu5+HVDPOu7NgUkuWvB7AtatWzFoRzuMvxhufXen9RqF/r6Dwtpfskv0ey29pWszng77H3yGd2Uf7Metof3zsM/li0C6szIrrfBxP2yxe7vAHKflWNZazsyjkrW6/kZRX+2RVbe7Ea1TnhzLp0COL/dtcCJ7Ykv/O88XBqYQV2y8S0K7mSxFrza8u4b2Vv+Hpk8PyRZ1ZtrAz7p45vP/xb6gta/8M/tqb53h0eBSb1wWxYFZ30lMtWbj8OP4BmboyZualvLfyGF0eSGT9/7Vh0ZxuJCdaMX/JCe7rlNKg/ELZLl68SLt27ao83rZtWy5dulTv412+fJmkpCRat25da1lZmXcbbN26FU9PT7Kysti6dSuvvvoqSUlJtS6TrEnnzp05fvw4bdq00T320Ucf8dBDD/Hkk0/qlZ0wYQKDBg0y+rluheeff569e/cya9YsunfvTmlpKZcvX2br1q1cunSJwMDAOh9rx44d2Nvb115QoQY9m4ibVwETB3YiPkb7wh0Zas26fWcY8lwiOzZUf3bfLyiXfiNSWP5mC/ZtawbAn787sHr3WUa/FsOCKdpBIDvDnCXTW+rVPXW4CR5++Qx8OonvNhq3gmDwC6m4+RQxoVcQcVHaM3cRlyzZ8FsIQ0ensX1N9av+/Nvk0//JDJZN82LvN07a7MdtWXMolDEzEwge5weAQ9NinpqSzLf/deV/q7Rnvs4fs8Xdt4gX34rn1EHj+sagfyTg5lXApMH339DuNqz9+RRDno1nx0bPauv6tcqh3/BkVrwVyL7tbgD8dcqRVT/8wah/RfPO1LZV6rw4M5LIUBvSki3o1CPDqMwVlNzuSs8/6IVk3LwLmdC3LfHR2hWckSFWrD98gaEjU9i+tlm1df1a59H/iTSWzfBh31bt2d4/T9ixZv9FxsyII/ilyjN6kwe0QaNRYWKqYdjoW/MmUcntPnhkKm7eRUzo3boy+2VLNvx6maGjU9m+pvqz4trs6drs3zatzP5LCGPeSCB4vH9l9slJ2uyrK7Lb4e5byIv/jmtQnx/0XDJuXoVMHNDhhn5jzbqD5xnyQhI71jWvtq5fUC79Hktl+Sx/9v1P+zv686Q9q3/+k9HTYlkwqRVQPs6/HqBX99QhRzz8Chj4j2S+W1/9c9REyf1GyX+voOy2l+yS/V7L/0yry3jZZjNo+3PEZGuv0ghNa8rPT33Fs60usfFihzodJ7jnEXZFBOJnn4GZSfXXLs68/wQh6U1JzrOmp3vtK3hqcideow7/0JRdm5oBlQtOzh23Z+ORczw2LoFlb7QwOv+jI6Jxc89l8gsPE39duwozMtyez746wODHovjum4Bq6/oFZNJvYCwr3uvI/t0+APx1rin/t+kgoyaE8M6b2itpevWLwy8gizdffZC/zmpfE/444conGw8x/uWLTJ/Ux+j8QtnS0tJo0qRJlcednJxIT0+v17FKSkqYMmUKLi4uvPTSS7WWl5V5t0HHjh3p3r07AwcO5LPPPqNv376sXLmyQce0t7ene/fudZrU8vT0pHv37g16voaIiIhgx44dLFq0iHnz5jFw4EAGDx7M9OnTOX78OMOHD6/X8Tp16kSLFsYP8He77v3TCTlnp5tQAkiMteTSGXt6DEirue7DaRQXqTjyY+Uy8LJSFYd/dKZLrwzMLcpqrJ+VYU5ZqfGrOLsPzCLkjLXuDRdA4jU1F0/Z0OPRzBpqausWF6k4/L2jfvadjnTpk63Lfn/fbCzUGg5s0x8kD25vgn+bApp5FRqV/YH+qYSet9dv9+uWXDprT/eHU2vO3r+83XdXvqksK1VxeLcLXR5Kx8xcv93bdMqk3/AkPn2n+jcT9aHkdld6/u6PZBJy1kb3ZleX/bQt3Qdm1Fi3xyOZ2n6zy0kv+6FdTnTunaX396rR3PrV1Ypu94GZhJyxMZx9YG3ZM8uzV2aqMft2J736B7fdgj4/IJ2Qs7b6/SbWkkt/2NFjQM1v9LoPyND2mx/0+83hH5rSpVdmHcZ5M8pK7s1xXsl/r6Dwtpfskv0ey9/fK5rzya66iTyA2Bx7ziS58bB3VJ2OMcw/jLZNU1h+uuatWDq7xjOiRRjvHO9lVNab3YnXqKx0c26cyAPIyzbjeqQlzm5FDcr/wIMJhF500k3kASTG23DpLye6P5RQa93iYhVHD3jckN+EI/s96dwtCTNz7crEVm3TKSgw1U3kaak4e8qFVm0yaOqczz1L8/f+Sk5O5v7779d9rVmz5hY2nr5XXnmFY8eOsXnzZoMThDeTybw7oGvXrmRlZZGUlATAnj176NGjB1ZWVjg4OPD4448TGhpa4zFuvszW19eX6OhotmzZorust+JSVEOX2ZaUlLB48WLatGmDpaUlLi4uDBo0iJCQEAAKCgqYNm0a7dq1w9bWFjc3N4YPH677fn2kpWknoNzc3Ax+38REv9sdPnyYRx55BAcHB2xsbOjQoQPr1q3Tfd/QZbaRkZGMHDkSFxcX1Go1HTt2ZMeOHXplKtohLCyMoUOHYmtri4+PD++88w5lZfoffpKTk5k6dSpeXl6o1Wq8vLwYPXo0hYWVL+jnz59nxIgRNGnSBCsrKx588EGOHj1a7/a5mXdgHtFhVZfIR4dZ4R2QZ6BGJZ+APBJj1RQWmN5U1xpzCw3NvQtuqqHBxFSDnWMxg59NoMtDGezYYNxqDQCfVgVEhVTdXy461BLvljc/d9W6CdcsKMzX7w/RoZZYqDW4+xbpyhUVqIiLtKhSDsCnpXFvurwD8ogy2O42eLeoud29A3JJvG5Zpd1jytvd3afyBd3UrIxX37nKtvWeehOHDaHkdld6fp/AfKJDq/4eo69Y4R1Yc3bvlvkkXrOgsOCm7FcqshvfpnWh6HZvWUBUqIHsV+qQvWV59lra3adlNdmvWOq+byzvwHyir1Q3ztf8AcAnsJpx/ooV5moNzX1qGOefS6JLr0x2rDf8elwXiu43Cv57BYW3vWSX7PdY/gDHNK5kOFV5/Gp6EwIca1+dY29RyL+7HWPpqe5kFlW/d7OZqpR3eh5h3V8d9CYOG+LOvkZVsnUowbdlPjFXG/b+2Mcvm+jIqvsSxkTZ4e2bXWNdb79sEuOtKSzUv2AxOsoOc4sy3D21lwCXlakoNXBirLhY2998/Gt+HqFcLi4unD59Wvc1adIkve83adLE4Aq86lbsVefNN99kzZo1rF+/noEDB9apjlxmewdERkZiamqKra0te/bsYejQofTv359vvvmGnJwc5s2bx0MPPcS5c+fw8PCo/YBoLz0dMmQIHTp0IDg4GDC8gWKF5557ju+++47XX3+dAQMGUFBQwJEjR4iPjycoKIjCwkKys7OZO3cuzZs3Jy0tjU8//ZQePXpw+fLlaifmDAkKCsLe3p4333yT4uJiHnnkEZo1M3wpy86dO3nqqad48MEHWb16Nc7Ozly8eJHo6Ohqj3/t2jUeeOABXF1dWbFiBS4uLnzzzTc89dRTfPfdd4wYMUKv/BNPPMH48eOZNm0au3btYv78+Xh5eTF+/HgA0tPT6dmzJ2lpacydO5f27duTlJTEzp07KSoqQq1Wc+bMGXr16kWnTp347LPPsLa2ZtWqVQwYMIBjx47RpUuXOrfPzewcSsjJrPqnmJ1pjq19zfs82DmWkJNlqK6Z7vs3Gj4qganzIwEoLlKx6l1fDnxn/Katdo6l5GSaVnk8O8MUO4ea99iwcywhJ8Nw3Yrv654jy5Sbz+bdXK6+qmv3nEyzurW7wd+Zme7YFf4xIRZzizK+Xe1lVE7Dz6/cdtcdW6H57RxLyTaQPSfDVO/3brhuia6P6NfVPmbbgDatC6W3u+HnN6tD9up+bjPd93XlDGbXL2cMO4eS8mNXzWBbh35jMH914/zoRKYu0L6GFhepWLXQhwM7jL/RkdL7jVL/XrUZlN32kr36TJK9ugzKze+gLiSrsOrNIjKLLLG3qH2CcFbX40RlOrD9aqsay01sfw4L01JW/9XJqJyG3MnXqBtNDY4CFXy3wfgTTgC29kXkZFfdkzo7ywJbu5r3K7SzLyInu+rNVXKytMezK69/PcYWG9sSvHyyuRZdOXEY1DZddxxxb2rbti0XL16s8vilS5f0tkiryaJFi1i8eDH/+c9/GD267jezkcm826C0tJSSkhKys7P59ttv2b59O8OHD8fa2pq5c+fi7+/PTz/9hJmZtvl79OhBy5YtWbZsGcuXL6/Tc3Tq1Am1Wo2zs3Otl9QePHiQbdu2sXLlSv71r3/pHn/88cd1/3ZwcGDt2rV6P8Ojjz5Ks2bN+Oqrr5g2bVqdf35bW1s2b97Miy++qOuM/v7+DB48mFdeeYWgoCAANBoNr732Gh07duSXX37RrdgbMGBAjccPDg5Go9Fw+PBhmjbV7n/06KOPcu3aNebNm1dlMm/GjBm6ibsBAwZw8OBBvvrqK91jK1asICIigtOnT9OpU+UL4/PPP6/798yZM/H29ubgwYNYWFjonrNdu3YsXLiQ7777rs7t05iO7HYm5Jwd9k2K6f5wGi/Pi6SsTMVPXzfsRVQY1tw7n2enXOPdV1pTXCQLoYUQt9+RH5sScs4W+yYldB+QzsvzoygrhZ++qn5/OCGEEI2nS7N4HmtxhSe/f5qbJxlv5G2XyZT2Z3jl4KMUlSr7Y/wzL1+n32OprJjtp3d5793q0D5PRr4YwrQ5Z1j5QSfSU9UMGhFNuw7arXnKym7Pdgvi7jdixAjeeOMNIiIi8PfX7sMcFRXFb7/9xgcffFBr/Y8//pi5c+eyaNEiXnnllXo9t3y6vA2CgoIwNzfHycmJqVOnMnLkSNavX09ubi5nzpzh2Wef1U3kQeWtiw8fPnxb8uzduxeVSsXEiRNrLPftt9/ywAMP4OjoiJmZGTY2NuTk5NR6CbAhw4cPJyoqiu3bt/Pqq6/i6OjIp59+SqdOndi/fz8AoaGhREdHM2HChCqX3tZkz549DBkyBAcHB0pKSnRfjz76KOfPnycrS/9OVEOHDtX7f7t27YiJidH9f+/evXTt2lVvIu9G+fn5HD58mH/84x+YmJjonk+j0TBgwACOHDlisN6aNWt019YXaapfYp6TZfisl51DscFVdzfKrmYVWcWKg4oVJRUy08wJu2DLH0eb8N/gFhzc6cKE2VGYmtW851K12TNNsTVwprS61RBV6hpY6VKx+qUie06mKbb2pWg3Lqi+XH1V1+62DoZXO+rVzazud1be7uVnI6fMCef8CQdCzttjY1eCjV0J5uYaUGnvbmuhNm6lj5LbXXdshebPyTS8OsDWsdTgKh79umYGVwNVrPDJaUCb1oXS293w85fULbvBn7tinDStLGcwu345Y+RkVRy7agZDq3xvlJ1pZjh/TeP8X7b8ccSR/87z4+AOZyb8O+beHOcV/PeqzaDstpfs1WeS7DVkUGj+rCI19uqqK/AcLArIKqq6Yu9G7/Q8wrawIBLybLCzKMTOohAzEw0mKg12FoWYm2izze3+KyfiPTiX3ExXztykDBXacmpT41YV3snXKIAhLyQyfmYsn3/oyd6txl8hVCEn2/AKPLtqVuzp1zXH1q7qqjpbe+3xssvr5+aYs2hONxwci/j0i1/46sc9PDI0hi0btCsp01Jr/h2Lv6+JEyfi6+vLY489xs6dO/n+++957LHH8PLyYvLkybpy0dHRmJmZ6d0U9euvv+b1119n0KBB9O/fnxMnTui+6nInXJnMuw127NjBqVOnCAkJITc3ly+++EJ3NxONRkPz5lX3KHNzc9PtNXerpaam4uTkhJVV9fsR7Nq1i2effZbWrVvz5ZdfcvLkSU6dOoWLiwsFBcbtE2RjY8MTTzzBxx9/zB9//MGxY8cwNTXlzTff1OUC7Q076iMpKYkvvvgCc3Nzva+ZM2fqHbeCk5P+/hVqtVrvZ0pNTa0xQ1paGqWlpSxcuLDKc37yySekp6dX2YMPYNKkSbpr6y1U1Z9xig6zwsfA3njeAfnEXK35dvMxV61p5lmI2lL/RdQ7II/iIhXxMTWf6Qr7yxZr2zKaONe8BL060aGW+LSq2j+8WxYQc6Xm544OtcTNqwi1lX7bebcsoKhQRVyUha6chWXlXic3lgOIvmLci2fMVetq2j2PmPCa2z36qjXNPAqqbfe4aCvd/7v1TWfrqeO6r77DknFuVsTWU8cZNz3KqOxKbnel54++YoVPy6r7x/gE5hMTVkv2K5Y08ypCbamf3SewIvvtfSOo7Ha3NLhnnXdgPbLf1O7eN7V79JXashu/ciD6ijU+Lasb52veKygmzMrwOB+YT3GhqtYVDWF/2dyz47yS/15B4W0v2SX7PZb/akYTAg3sjdfCMZ2rGTXvmxXgmM7zQZc4PXKD7qtLswQ6uSZyeuQGXgjSXsLXwiGdvl4xeuWGt7hKM5s8To/cwIwuJ43Kfidfo/o/nsw/34li22dufP1p3baXqk1MpB3eflX3rPPyzSYmqupeevp17WnWPA+1Wn8i1Ns3m+IiE+JibXSPXfyzKS89M4CJzz3M5Bf6M+n5hyktMaGgwJSroY635GdRIhWg0mj+tl+1sbGx4eDBg7Rs2ZLRo0czcuRI/Pz8OHjwILa2lTdl0Wg0lJaW6s0b7NmzB41Go7unwo1fU6dOrfW5ZTLvNmjXrh33338/rVq1wtKycgBr0qQJKpWKhISqd9VJSEioMul0qzg7O5OWlkZ+fvUbmH799dcEBASwceNGhgwZQrdu3ejQocMtnWCsuMNvxSyzs7P2bkDXr9fvdupNmzbl6aef5tSpUwa/3N3d63U8Z2fnGjM4OjpiYmLCq6++Wu1z1mdl4c1OHnQiqGM2bl6Vb15cPQpo0zmbEwdqfvE/ebAJ5hYaeg2unMA0MdXQe2gqZ351rPXSzvu6ZZGXY0JGas1nrapzYq89rTvn4eZdeSaymWcRbbvmcmJvzXdePrHPXpt9WIZe9j4jMjhzxE6X/dQvdhQXqej3pP4bpIefSifysiWJ14x703XiYFOCOmTh5ln5d+HqUUCbTlmcONi0xronf2mKuYWGhwal6GXvNTiZM781oaR8M9wPpgcxe8x9el+njzYhM82M2WPuY9eW+vVVXXYFt7vS85/Y70BQp9ybshfS5v4cTuxzrLHuyf2O5dkrM5mYaug9LJ0zR+1v+6XYim73vfa07ly13dt2zeXEvpo3ANdlH17H7E/clP3Jhvf5kwccCeqYc9M4X0ibLjmc2F/LOH+gfJwfUvl6XDnOO9Q+zj+Qfe+O8wr+ewWFt71kl+z3WP6DMb50cEnE07byCiEP2yw6N0vkYIxvjXVH/zS8ytfl1KaEpjsx+qfh7InSXro3/fAjVcodjfUircCS0T8NZ/PldkZlv1OvUT0HpjF9SQQ/f+PC2vd9jMpqMMOvbgS1ScfNPbcyv1sebe5L4+RvNW8ldPK3Zpiba3ioX9wN+cvo3f86Z065UFJ884pQFXGxtsTG2KG2LOXR4dH88rMnhQXKvuxZNIy3tzfbtm0jKyuL7OxsvvvuO3x9ffXK+Pr6otFodPc7ANi4cSMajcbgV8WNT2sive4OsrGxoUuXLmzdupXg4GBMTbWDQ3R0NMeOHePVV1+t1/HUanWNE3QVBg4cyAcffMDatWurfY68vDy9S38BNm3aRGlp/S8DzM7OxsTEBBsbG73HS0tLCQsL061MbNmyJb6+vqxdu5ZJkyZVuQNvdQYNGsTx48dp27ZtjasN62rgwIG8++67nD9/ng4dOlT5vo2NDb169eL8+fN07ty5QRN3hvz0TTOGj0pg3v+F8MUKbzQaGPN6DMkJFuy+YS87V/cC1h84w5f/9eLLT7Q3Uwi/ZMvhH5oyaU4kpmYaEmPVDH0hATfPApZMD9TVHfxcAkEdszl3zJGUBAvsHEvoPTiFXoNTWb/UWzf5VF+7tzgxYnwKwRui+HyJGxoNjJ2ZQHKcBT9uqpwQc/UoYuPxy2xZ0YwtK7Q/U/gFaw7tdGTKgjjMzDUkxFgwbEwqbl5FLH7FW1c3M9Wc7Wucee6VJPJzTLn6lxV9RmTQ4cEcgsf5GZUbYM9WN4aPjGPep5f44iNfNBoY/Vo0yQlqfvqmcvWsq3sB6/ae4stPvfnqU+0bj4jLthz+0ZlJ/47AzExDQqyaoc/H4+ZZwNKZQbq6oeervvEc8EQixUUm/PW7o9HZldzuSs//05fOjBibzPy1V/l8qfaM8pgZcSTHW7B7i/MN2QvZcPQCW1Y258uV2knb8IvWHPq+CZPnX9P2m2sWDB2djJtXIUte088U2D6XZp5FqEy0ZwS9Awt4aIj2g8epgw5V7rBZF0pu991bmjJiXArB6yP5fElzbfZZ8YazH7vElhVubPmoPPvF8uzB13XtPmxMSnn2yg8T2uwuPPdKIvm5JvrZxzesz//0tSvDRycyb80VvljmiUajYsz0WG2/+aryEiNX90LWHzrHl//x4Mv/aFeMh1+y4fAuJya9HV05zo9M1PabaQG6uoOfTySoUw7nfnMgJd4CuyYl9B6SSq8haaxf7HVPjvNK/nsFZbe9ZJfs91r+b6+0ZmTrC3w6YA8rz3RFo1HxWudTJOTa8E1o5Sb47jbZ7Hv6Sz4914X/nr8fgN8Tqq5QyyqywMxEo/e988lV9z59IiCUolJTg8eoqzvxGtWuaxazV14l4rI1+7a5ENSxciVdcZEJ4Zf0PzfWx55dPgx7KpK33z/Jps9ao9HAqIkhpCRZ8dNOX105l2Z5rPtmP19tbMVXG7WXx0aEOXJ4vweTXrugzR9vzZDHI2nWPI+l7+jf4HDs5EtcDXUkK9OC5h65PPVCGKUlKjauqttNDoS41WQy7w5buHAhQ4cOZdiwYUydOpWcnBzmz5+Pg4MDM2bMqNex2rRpw9GjR/nhhx9wc3PD2dm5ygwwQL9+/XjqqaeYPn06165do3///hQXF3PkyBGGDh1K3759GTRoEN999x3Tpk1j2LBhnD59mv/85z84OjrW+2cMDQ1l0KBBPP/88/Tt2xdXV1fi4+NZu3YtFy5c4NNPPwVApVLx0Ucf8eSTT9K/f3+mTJmCi4sLly9fJikpiQULFhg8/jvvvEO3bt3o3bs3r7zyCr6+vqSnp3PhwgUiIiJYv359vfJOmzaNL7/8kgEDBjB37lzuu+8+UlJS2LlzJ6tWrcLOzo7ly5fTu3dvHn30UV566SWaN29OSkoKZ86cobS0tE6bW1anMN+UN0e3ZdKcSGZ+GAZoOHfckdWLfCnIu+FskApMzUCl0l/uu/zNAMZOj2HMtBhs7UuICLFh7ottCL9Uuaw3KtSaHg+nMWF2FHaOJWSmmXMt3Ip5E4M4dcj4FaGF+abMeqYFU4LjmPlxDCoVnPvVllXzPPSyqyqy3/R5Ztk0L8bNjmfsrARs7UuJuGTFnJH+XP1L/zLXjR80Jz/XlMcnJNPEpYTYcDWLJvtwcn/NZ2lry/7vcfcx6d8RvLEkFFRw/rgjq9/3N9juN8/hrnirJWOnRTP6tShs7UuIDLHl7Ynt9Nr9dlFyuys9f2G+KbOfa8nkedeY+VGkNvtvdqxe4GUw+839ZvkMX8bNus6YN65rs1+2Yu6YQK5e0M8+Ymwyj/yjcsVt72Hp9C5fITS2ZzsSY+u/ckDp7T7rmQCmBF9n5sfRldnn35xdU55df5xcNt27PHt8ZfZR/lXafePi5uTnmfD4Szdkn+LLyf01r/6rS/43R7Vm0txoZi4LBxWcO+bA6oU+hsf5m/vNrBaMfeMaY2bEasf5y9bMHRdE+MXKDz9Rodb0eCSdCf+Owc6hhMx0M+04/1JLTv1S88qK2rIrud8o9e+1Ir+S216yS/Z7KX9+iTlj9wzn392OsaTXQVQqOB7nwXu/9ySvpHJltEqlwcxEU+X9fGO6E69RHXpmYaHWEHhfHsv/p78XWGKsBeN6G3933sICM956rScTX73AjLfPgErD+dMurPn4PgryK6c7tP1GU+U9wkfvdWLMpMuMmXgZG9tiIsPtmfdGD8KvOOqVc3QqZNK//sKhSSGZ6WqOH2nO5nVBBu+GK8SdoNJo6nAhsKiTjRs3Mn78eMLCwggICKi23J49e1iwYAHnzp3DwsKCvn37smTJElq1qrwVed++fQF0yysPHTpEv379+OWXX3TfCwkJYeLEifzxxx/k5+czduxYNm7cSHBwMAsWLODGX21JSQmLFy/m888/JyoqCgcHB7p27cqKFSto1aoVZWVlzJs3j/Xr15ORkUHXrl356KOPeOKJJ+jbty8bN27U+xkjIyMNThwCZGRk8PHHH7N//37CwsJISUnB1taWjh078s9//pOnn35ar/zBgwdZuHAhp06dAqBFixa8/vrrurvN+vr66mUAiI2NJTg4mJ9++onk5GSaNm1Ku3btGDt2LKNGjQLQtUNxcbHeqsNx48Zx6NAhoqKidI8lJSUxd+5cdu3aRWpqKs2aNaN///6sWbMGtVr7Jvzy5cssWLCAgwcPkpmZiYuLC507d2bKlCkMGTKk2t83gIOpM92th9VY5m5Vlptbe6G7mKl9w95YNqbSm27mIu4MlZmyz3NpSozbAPuuUMcV2ncjE7WyN78uM3J/3LuBkv9mFf33KsQ9KGpRj8aOYDT/hWcbO0KDmLjXfMns3epY7CYyC6pus/V3YW/vyf1d63cXViXJyvwfp0+fbuwYBslknhB3gEzmNR6ZzBP1peSJAVD45IBM5jUamcxrHIr+exXiHiSTeY1HJvPuTjKZ13jkBhhCCCGEEEIIIYQQQiiETOYJIYQQQgghhBBCCKEQyr0uQQghhBBCCCGEEEI0GpXs3NYoZGWeEEIIIYQQQgghhBAKIZN5QgghhBBCCCGEEEIohEzmCSGEEEIIIYQQQgihEDKZJ4QQQgghhBBCCCGEQsgNMIQQQgghhBBCCCFE/WjKv8QdJyvzhBBCCCGEEEIIIYRQCJnME0IIIYQQQgghhBBCIWQyTwghhBBCCCGEEEIIhZA984QQQgghhBBCCCFEPWlAI5vmNQZZmSeEEEIIIYQQQgghhELIZJ4QQgghhBBCCCGEEAohk3lCCCGEEEIIIYQQQiiE7JknhBBCCCGEEEIIIepNJVvmNQqZzBPiDtCUlVGWm9vYMe5JmpKSxo5wbzIxbewERtOUljZ2hHuXgjdQLissbOwI9yyVhUVjRzCavEYJY6g6tW3sCA2iOXuxsSMYze+dM40dwWghKzs0doQGabMorrEjGEfB723E3U0usxVCCCGEEEIIIYQQQiFkMk8IIYQQQgghhBBCCIWQyTwhhBBCCCGEEEIIIRRC9swTQgghhBBCCCGEEPUn+wI2ClmZJ4QQQgghhBBCCCGEQshknhBCCCGEEEIIIYQQCiGTeUIIIYQQQgghhBBCKITsmSeEEEIIIYQQQggh6kcDqrLGDnFvkpV5QgghhBBCCCGEEEIohEzmCSGEEEIIIYQQQgihEDKZJ4QQQgghhBBCCCGEQsieeUIIIYQQQgghhBCi/jSaxk5wT5KVeUIIIYQQQgghhBBCKIRM5gkhhBBCCCGEEEIIoRAymSeEEEIIIYQQQgghhELIZJ4QQgghhBBCCCGEEAohN8AQopG5uBcxOTiOzr2zQQVnj9qxar47ydctaq1rri5j7KwE+j+Zjq19KeEXrVi3qDkXTtrqlVOpNDzzzySGjE7FyaWE2HA1W1Y049fdjvd0fufmhUyeE0WnBzNRqeDsbw6sfteX5Hh17dktyhgzLYb+j6VgY19CxGUb1i/x4cIpe10ZK5tSXn8/nIC2OTi5FFNSouJ6pCU7v2jOLztdGpRdye0O4NK8iMnBsXTulaXN/6sdq+Z7kRxXx/wz4+j/RBq2DqWEX7Rm3XvuXDhpp1fuyYmJdOiZTWD7PJo2K2HTcjc2L3dveHb3IiYHX6dzrxvb3qMe2eMr2/6SFesWuVff9qNStG0foWbLCrcGt72S+42Ss1fmv7395slJSXTomVPZ55c1Y/Py5rcouzLbXsnjPCi77SV7I/V551wmTzxD504JoNJw7pwbq9Z0ITnZpta648acIzAwjcCANOzti1i2ojv79vvXWKd162SWLdmHiQkMGf4cZWUNWyui6LZvXsjkt2Po/GCWtu1/c2DVQm+S4+o23oydEUv/x1O1480la9Yt9uLC75XjjYdfPsNHJ9GhRxZuXoXk55py5U8bPl/uSeRl6wZlN0srxGVrDNaXswANeUEOJD/jTYlT7dlbTvnd4OPRc9pS6KXtd+aJ+TgeSsL6ShbmKYWUqU0p8LUhZYQnRZ4Nyw7g7JrPxGmX6NQtBZUKzv3elDUr2pKcaFVrXXOLUkZPvkK/QdexsS0mIsyeDZ8EcfFcU71ydvZFPD8hjAceSqRJ00LS09Sc+s2VL9cGkpVRezv9rcn9LxqFrMwTohGprcpY/G04XgGFLH3dm6X/8sbDr5AlW8NRW5XWWn/6smsMfiGVTUvdmDfWj7Qkc977MgL/tvl65cbOSmDUjER2bXBm7ih/Lp+xZs6aaLr2z7pn86stS/lg0yU8/fNZNjOApW8E4O6bz+ItF+uUfdr74Qx6NolNK70IntiatCQL3t1wCf/WuboyZuZllJbAN6s8WDA5iCXTArkWbs2sZVd5fHyc8dkV3O4AassyFn8bhleLApZO82Xpa77a/N9eqVv+D6MZ/Hwqm5a5M29sC9KSzHhvy1X82+TplRv8QgqOziUc/9mxQXmrZr+KV4uKtvcpb/urdcxe3vYfNmfeOH/SEs15b0s4/m31s4+dlcCo6Qns2uDC3NH+XD5jw5zVUQ3r8wruN0rODneu3wx+IRXHpiUc/9mhQXn1siu47ZU8zoPC216yN052dQmL3zuAl2cWHy7vztJlPXF3z2bx+wdQq0tqrT9i+BXUFqWc/N2jTs9nalrGv175nYwMS6Mz30jRbW9ZyuItIXj5F/DhG/4sndECd98CFn8ZUrfxZnEkg55L5osVHsx/qSVpSRYs+jxUb7zp3CuLDj2y2LfNmfkTWvLJ2z44OBXz0faLBLTLreHoNVMVleK5IgSLxAISxvmTMK4FFkkFeC4PQVVYe3aAzB7OxMxqo/dV1KyyX9hcysL6ShZZ3Z25PrUlSc/7YJpdjPfii6ijjc8OoFaX8t6nJ/D0yWH5gg4sC+6Au1ce7396ArVl7f3+tTl/8uhjMWxe05IFM7qSnqJm4crf8Q/MvKGUhnkfnqbvwDi2bW7B/Gnd2L7Zn96PxDF/2WlkNks0BlmZd4/YuHEj48eP1/3f1tYWf39/Jk6cyJQpUzAzu3NdYdy4cezfv5/Y2NhbdrxDhw4RFRV1S453Jw1+IRU3nyIm9AoiLkp7RifikiUbfgth6Og0tq+p/qy+f5t8+j+ZwbJpXuz9xgmAP4/bsuZQKGNmJhA8zg8Ah6bFPDUlmW//68r/VrkCcP6YLe6+Rbz4VjynDtpX+xx/5/yDnk3CzauAiQM7Eh+tPWsXGWLNuv1nGfJ8IjvWV7+Cyy8ol36PpbB8dgv2bdNm+vN3e1b/dI7Rr19jweQgALIzzFkyvaVe3VOHm+Dhl8/Ap5P4boNxq8SU3O4Ag0em4OZdyIQ+bYiL0r7Ri7hsxYajFxk6KoXtnzWrPn/rPPo/kc6y6T7s/VZ7xvTPE3asOXiJMW/EE/xiC13ZSf3boNGoMDHVMGxMitF59bOn4uZdxITerSvb/rIlG369zNDRqWxf41p99jb59H8yXdv2FdmP27LmlxDGvJFA8Hjt6geHpsU8NTlJ2/arK9reDnffQl78d5zRba/kfqPk7HBn+g3ApH5BN/T5VKPz6mVXcNsreZwHZbe9ZG+kPv/oVdzccpkweRjx8drV6pGRjqz/bBdDB4ex/bvWNdZ/6pl/oNGoaN48m0cGRNb6fE8/dRkV8PO+Fjz/7EWjMt9I0W3/XLL2vc3D7YmP1r63ibxszfpfzjP0hSS2r6t+lbRf6zz6P57Kspl+7Puf9mf886Q9a/b+xZjp1wmeqB1jDu9yYtcXroBKV/fccXs+P3qex8cn8OGMFoYOXyuHo8mYpxQStaA9xa7a7IWe1vjNO4/D0SQyBtS+wrvE0YICf9tqv5/V1YmMvq6gqsyeF2SP35zzNDmYQMJ447IDPPp4DG7ueUx+pi/xsdqVgJFh9nz2v0MMfiKG776qfnWpX2AW/QbFsWJhe/b/4AXAX2ed+L+vjjBq0hXemdkVAHevXNp0SOc/79/Hnu+8teXONKWsTMUrb17AwzuX6zHV//xC3A6yMu8es3XrVo4fP862bdvo1q0br776Ku+8805jx7pndR+YRcgZa90bFoDEa2ounrKhx6OZNdTU1i0uUnH4e0fdY2WlKg7vdKRLn2zMLcoAuL9vNhZqDQe2NdGrf3B7E/zbFNDMq/CezN/94TRCztnpPuABJMZacumMHT0GpNVSN53iIhVHfqxcfl9WquLwj8506ZWhy16drHQzykpVNZap8fkV3O4A3R/JJOSMjW4iT5f/tG0d8meW56/MVVaq/X+XPll6ba/RGN/GNT2/NruBth9oZPbq2n67k179g9sa2OcV3G+UnF2b4fb3G7hdfV65ba/kcR4U3vaSvXGyP3CdkNCmuok8gMREWy5ecqF79+u11q/PGNLcLZvnn73AJ592pbTk1ow9im77ARmEnLXVTeQBJMaqufiHHd0fyaixbo8B5ePND5Wv+2WlKg7tcqJzr0xd9qx0c26cyAPIyzbjeqQlTZsVG5UbwPbPDAr8bHUTeQAlzmryW9hhe77m7HVVZmuuN5EHUGZlRpGrJWYZxmcHeKBXIqEXmugm8gAS46259GcTuvdOrLVucbGKo/sqT7yUlZpwZJ87nbunYGauXZlobq5deZeXq78AJjfHHAATE1mZJ+48mcy7x3Ts2JHu3bszcOBAPvvsM/r27cvKlSsbO9Y9y6dVAVEhVS9NiA61xLtlQa11E65ZUJiv/2ccHWqJhVqDu2+RrlxRgYq4SIsq5QB8Whr/AVXJ+b0D84m+UnUfjegwa7wD8g3UuCF7YB6JsWoKC0xvqmuFuYWG5j43/+waTEw12DkWM/jZRLr0yqxxRUhtlNzu2rr5RIUaaPtQS7wDa8nfsjx/wc35rcrzG5+rLnxaFhAVaqDtr9Sh7avLfsVSL7tPy2ra/oql7vtGZVdwv1Fydm3d299vbhclt72Sx3lQdttL9kbK7pNJdLRj1ewxDnh71zwZVl+vvnKKo796c+Fi9SuL60vRbd+ymvHmilWt4413YH61442FWoN7lfGmkq1DCb4t87kWbvylzhbx+RR6VM1e1NwKi/ias1dwPJJIwCunCHj1NJ4rLmMVll1rHZPcEtRx+RS5NewybR//HKIj7Ko8HhNhi7dfTo11vf2zSYyzprDwpraPsMXcogx3zzzd//8648RzL4YREJSBpVUJLdtk8PxLYZw65sK1qKrPfy9RaTR/26+7mUzm3eO6du1KVlYWSUlJvP3227Ro0QJLS0ucnZ156KGH+PXXXwEYPnw4nTp1qlI/MjISExMTVq1apffY6NGjcXNzQ61W4+/vz2uvvVal7tmzZ+nVqxfW1tYEBgbqHaPC77//zoABA7C1tcXGxoaHH36Y3383vMnqjeLj4xkzZgzOzs6o1Wrat2/P5s2bq5Tbv38/nTp1wtLSkoCAANauXcu4cePw9fUFoLCwEBcXF6ZNm1al7saNG1GpVISEhNSapzp2jqXkZJpWeTw7wxQ7h5r3qLBzLCEnw3Ddiu/rniPLlJvP5N1czhhKzm/nUEJOVtXLy7MzzLC1r/mYdo7V16049o2Gj07gx9ATfHv6NC/Pj2TVu74c+M74jdGV3O66YxvMb1al7arWLan2Z6849u1k51haTfuZ1aHtq/+5K76vK2ew7fXL1ZeS+42Ss+uOfZv7ze2i5LZX8jivzaDgtpfsNWa6bdlti8jOqXqjiJxsC+xsi4w6piH9+0USGJDG2vVVPxs0hKLb3qGE7MyqY0ZOZt3e22Qb+Llzyscb2xrG+anB0aCCHevd6pm4kmluCWXWVbOX2phhmld7e2Q90JTE5325/loQiaN8Mc0pwXNFCFahNe9B6Pp1NGgg/WHjswPY2heRk2Ve5fHsLAts7Wpe9WdnX0xOdtW6OVnavyM7h4r6KuZP68r1aBtWfv4b2w79zIoNv5Fw3Zr33uzSoPxCGEv2zLvHRUZGYmpqymeffcaKFStYtGgRHTt2JCsri9OnT5OWpr0M5eWXX2bo0KH8/vvvdOvWTVd/zZo12NjYMHLkSN3xunXrhrW1Ne+88w6BgYHExMSwd+9evefNysrihRde4PXXX2fevHls2LCBl19+mVatWtGvXz8A/vzzT/r06UObNm10E2cffPABffr04cSJE3To0MHgz5Sbm0ufPn1IT0/nvffew8vLi82bNzN69Gjy8vKYNGkSAJcuXWLo0KF069aNr7/+mqKiIhYuXEhmZiYmJtp5brVazfjx41m3bh3vv/8+lpaVZ45Wr15Nnz59CAoKukW/DfF3deRHZ0LO2mHvVEz3h9N5eV4kZaUqfvq6+r3hhBBCKIeM8+JeYWtbyKQJZ9jweQcyM2/NjS+EcZ59OY7+j6eyfJaf3uW9d5r+fnd25HRogu87f+H8fSzXZrYxWKfJnjjsT6WSMNpP7/Leu9m/3vqLVu0y+M8H7bgWaYuXXw6jJobx1vt/sGBG19uy1YUQNZHJvHtMaWkpJSUlZGdn8+2337J9+3aGDx/O8ePHGThwoN4KuuHDh+v+PWjQIPz9/Vm9erVuMq+4uJgNGzYwcuRI7Oy0S4vnz59Pfn4+58+fx9298vKSsWPH6uXIzs7m008/1U3c9e7dm59//pmvvvpK99g777yDWq3mwIEDODo6AvDII4/g6+vLggUL2L59u8GfccOGDYSFhfHLL7/Qt29fAAYPHkxiYiJz587lpZdewtTUlHfffRd7e3t+/vlnrK21t0Tv1asXfn5+uLlVniGaMmUKy5YtY+vWrYwePRrQTjSeOHGCr776qtq2XrNmDWvWrNG2FYaX7OdkmmJr4EyjnWOpwTN0N9d19ax6tqlilUbF6oGcTFNs7UvR3mVJVW05Yyg5f06W4ZUZ1a3GuFF2phmu7lV/pxVnc28+M5uZZk5mmvas3x9HmqC2LGPCm1Hs/Z8LpSX1XyCt5HbXHdtgfsNntW+u6+pZdXVBZa6af/6Gysk0NXiGvLqz6jfXNZy9vN+UZ6++7fXLGZVdof1Gydl1x77N/eZ2UXLbK3mcB4W3vWRvnOw5hlfg2doZXrFnjLFj/iQtzYojR72xsdE+V8WebjY2xRQVmVJYeA+2fZapwRV4ttWs2NPPbkYzDwO/t/LxxtCKwyEvJDF+ViwbP/Rk79aGrQIutTbFxMAKPNPcEkoNrNirjcbSlNx2jtgfSzb4fYcjSbh8F0vKCE+yHmxYdoCcbHNs7Q387u2LDK6606ubZY6rW9VLiW3ttb+P7Ext/a4PJtL30Tje+ucDnD/tDMDFc01JuG7Nov/8zgO9EjlxpGErDIWoL7nM9h4TFBSEubk5Tk5OTJ06lZEjR7J+/Xq6du3K7t27mTNnDr/++itFRfovKCYmJkyePJmvv/6azEztnhvfffcdiYmJTJ48WVdu7969DBs2TG8izxBra2vdpB1oV8C1bNmSmJgY3WNHjhxh2LBhuok8AHt7e0aMGMHhw4erPfaRI0fw8PDQTeRVGDVqFMnJyVy6dAmAEydOMGTIEN1EHkDz5s3p2bOnXj1/f38effRRVq9erXts9erVuLi48OSTT1abY9KkSZw+fZrTp09jjtpgmehQS3xaVd0Hw7tlATFXaj5LFR1qiZtXEWor/U24vVsWUFSoIi7KQlfOwrJyr5AbywFEXzGcrS6UnD86zAqfwKov3t4B+cRcrbpvyI1iwqxo5lmI2lL/Dad3QD7FRapaz46GXbDB2raMJs7Gbfir5HbX1rXEp6WBtm9ZQExYLfmvWGnzW96cP788v/G56kKb3UDbB9aj7W/OHliglz36Sm1tb9wZbCX3GyVn19a9/f3mdlFy2yt5nAeFt71kb5zsMQ74GNgbz8crk5gYB6OOaehY/v4Z/O+bbWz79n9s+/Z/PPsP7XvrrV9vY/bMY0YfW9Ftf8XweOMTWPt4E33F8HjjE1D+3uam8ebhJ1J4ZWEU//vMja//27C9OQGK3K1Qx1XNbhGfT1HzmrPXl92JFFy/iiJtgBtpQxqeHSAmwg5v/6p79Hn55RATWfMdZmMi7WjmnodafdNY75dDcZEJcbHaz4m+LbTHv3JZ/+/oykVH7XP51rw3nxC3g0zm3WN27NjBqVOnCAkJITc3ly+++AInJyfeeustFixYwPfff0+vXr1o2rQp48ePJyUlRVf3pZdeorS0lE2bNgGwatUqunXrpreXXmpqKp6enrXmaNKkSZXH1Go1BQWVL+BpaWk0b171Vuhubm6kp6dXe+ya6lV8H7T76rm6Vt20t1mzqpfETJ06ld9++40LFy6Qm5vL5s2bGT9+PBYWDTvLeWKvPa075+HmXXn2v5lnEW275nJir33NdffZY26hodewDN1jJqYa+ozI4MwRO4qLtH/ep36xo7hIRb8n9dvs4afSibxsSeI14z8IKjn/yQNOBHXMxs2rss+5ehTQpnM2Jw441VATTh500mYfnKqXvfeQVM786qjLXp37umWRl2NCRmrNZwuro+R21+Z3pHXn3JvyF9L2/hxO7K35w8aJfQ7l+StzmZhq6DM8XS//7aJtewPZu+ZyYl9t2cvbfniG7rEa2/6Jm9r+yYa1vZL7jZKzV+a/vf3mdlFy2yt5nAdlt71kb6TsJz0ICkrBza1yYqGZaw5t2iRz4qSHUce82arPujDrzYf1vvbt9wPgzbf68/mm9kYfW9Ftv78JQZ1y9MabZh6FtOmSw4n9jjXWPXnAUZt9SOVdtk1MNfQelsaZXx30xpueA9OYviSCPd+4sPY9b6Oy3iynfRMsI3MwT67MbpZSiFV4Drnta85uiEl+KTZ/ZVDgqz+RZns2DbcvIsh80IWUp29NdoCTR5sR1DYDN/c83WOuzfNo0yGdk0dr3urg5FFXzM01PPRwfGV+0zJ6D4jjzElnSoq1qyLTU7X9olUb/cnyVu0yAEhJVsalwreNRvP3/bqLyWW295h27doREBBQ5XFzc3Nmz57N7NmzSUhI4IcffmD69Onk5eXxzTffANC0aVOeeeYZVq9ezaOPPsovv/zC2rVr9Y7j7OzM9evXb0lWJycnEhISqjyekJBgcDLwxnqhoaEG61V8H7Sr8JKSkqqUS0ysegvzIUOG4Ovry+rVq+nQoQPZ2dm6vfcaYvcWJ0aMTyF4QxSfL3FDo4GxMxNIjrPgx01NdeVcPYrYePwyW1Y0Y8sK7aRk+AVrDu10ZMqCOMzMNSTEWDBsTCpuXkUsfqXyBTIz1Zzta5x57pUk8nNMufqXFX1GZNDhwRyCx/nds/l/+saV4aPjmbcqhC9WeKPRwJjXr5Ecb8Hurypf+F3dC1l/8AxffuLJl594abNfsuHwD02ZNDcKU3MNidcsGToyATevApbMqPz7GvxcIkEdszl3zIGUBAvsHEvoPSSVXoPTWL/Em5Ji4z6EK7ndAXZ/2ZQR45MJXh/O50vcy/PHa/Nvdr4hfyEbf7vIlo+as+Uj7QR9+EVrDu1swpTg2Bvyp2jzv6qfK7B9Ls28ijApv4rGJ7CAh4Zq37yfOuBQ5e6gdcq+pSkjxqUQvD6Sz5c012afFW+47Y9dYssKN7Z85HZDdkemBF/HzExDwrUbsr/io6urbXsXnnslkfxcE/22H2982yu53yg5uzb/7e83AIHt87R93kT75tOnZSEPDc0A4NQBeyP7vHLbXsnjPCi77SV7I/X5PQGMGHaF+W8f5vNNHUADY0b9SXKKNbt/quy3ri65bFj3PVu+aseXX92ne/y+dok4OBTSpIl2lVZgQCr5+dqPi7/+ps0fEVH1PXj7+7Tvnf/8y5Wysnuzz//0tQsjxiQyf00Yny/31Lb99FjtePNl5eIBV49CNhw6z5aPPfjyP9oJ1vBLNhza5cTkeTHa7NfUDB2VhJtXIUter9yPrl23LN78OJyIy9bs+58zQR0rJ22Li1SEX7IxKnvmQy44HkrE/f/CSBnhCSpw/j6WYicLMnpVZjdLLcTv7fOkDvUgbag2e5O98VgkFpDXyo4SBwvM0wppsi8Bs6xiEl6szG4VloXbunAKPa3J6uGMZURldo2ZikJv47ID7PnOi2FPR/H20tNsWt0SjUbFqMmhpCRa8tOOyt+9i1se67Yd4qv1gXy1LhCAiCsOHN7XnEnTLmJqVkZinDVDnoqmmXs+S+dXLlj57ZAbo6eEMn3+Ob5eH0hstA2ePrm8MCGMpARLjh+SS2zFnSeTeaIKNzc3JkyYwO7du7lw4YLe96ZOnUqPHj2YMGECDg4OPPfcc3rfHzhwINu3byc+Pt7g6rj66NOnD7t37yY7O1u3J192dja7du2qcgntzfW2bt3Kb7/9xoMPPqh7/Msvv8TV1ZU2bbQbsXbv3p3du3eTl5enu9Q2Pj6e3377rUr2isuMP/jgA44ePcqAAQNo0aIFDVWYb8qsZ1owJTiOmR/HoFLBuV9tWTXPg4K8yv0xVCowNQPVTe+Plk3zYtzseMbOSsDWvpSIS1bMGenP1b+s9cpt/KA5+bmmPD4hmSYuJcSGq1k02YeT+2s+y/l3zl+Yb8qbo9oyaU4UMz+8Cmg4d9yB1e/66mVHpTGYffnsFoydcY0x065ha19CxGUb5r7YmvCLlWcho0Kt6TEgjQlvRmPnWEJmmhnXwq2ZNyGIU4eqn5CuS3altntl/kCmBMcyc2VUeX47VgV7VpNf/6zYshk+jJsVx9iZcdr8l62YMzqAqxf0848Yl8zAZyrPcvcenkHv8tVNY7q3JTG2/mfftdkDmBJ8nZkfR1e2/fyb215jOPt07/K2j69s+1H+VbJvXNyc/DwTHn/phraf4svJ/cZfJqXkfqPk7JX5b3+/GTE+mYHPVK420evzD7RuQJ9XZtsreZyvyK/ktpfsjZC90IzZbz3M5IlnmDnjGCrg3Hk3Vq/pTEFB5SpRlUqDqakGE5X+WDN65F+0b195onvE8DBGDA8DYNDQF4zOVef8Sm77fFNmjwxi8twYZi4L12Y/Zs/qd3z0s6PNbnLTOL98pj/j3rjGmBnXy8cba+aObcXVi5WTXB17ZGGh1hB4Xx4rtl3Wq58Ya8HYXh2Nyq5RmxI7LQiXrTG4bQxHpYG8IHuS/uGDxvKGsVIDqjJQlVVmL3KzxPZcOrbn0jHJL6XMyoT8FnYkjvajwK9yrLQOycKkRINlTB7eS/WzFztZEPmecdkBCgvMeOuf3Zk47RIzgs8DGs6fdmbNijYU5FdOd2j7jQbVTf3+o4UdGDMllDFTrmBjW0xkmD3zXu9GeGjle678XHNmvPQgIyde4anR4Tg1LSQtVc3Jo658ubal3vMIcaeoNJq7fO2guCU2btzI+PHjCQsLM7gy77HHHqNDhw507tyZJk2acPbsWd566y0mT57MihUr9Mp27tyZs2fP8uqrr/Lxxx/rfS8qKoquXbtia2vLW2+9RUBAANevX2fPnj1s3rwZgHHjxrF//35iY2P16lZM0B06dAjQ3mTigQce4L777mP27NmoVCoWL16su/lExd1sx40bx6FDh4iKigK0d7Pt1KkTmZmZLFq0CE9PT7Zs2cLmzZtZvXq13t1sO3bsyAMPPMAbb7xBYWGh7m62ZmZmRERE6OVLTk7Gy8uLwsJCtm3bVuN+eTezVznxgOrhOpcXt46JtXXthe5SZXl5tRe6W5nc3k35bytNWe1l7mbyst44VAq/i52C+42M8+Jeo+rUtrEjNIjm7MXGjmA0lfr27lN6O4Wu7NDYERqkzaK4xo5glGMJX5JZWPXKr78Le1sPurebXHtBhUor+Z7Tp083dgyDZApZANq7yW7dupX//ve/5OXl4e3tzaxZs5gzZ06Vsv/4xz84e/as3o0vKvj6+nLixAnmzp3Lv//9b3JycvDw8OCxxx6rd6b27dtz6NAh5syZw9ixY9FoNHTv3p3Dhw/rJvIMsbGx4fDhw8yaNYs333yT7OxsWrVqxaZNmxg1apSuXJs2bfjxxx+ZOXMmzzzzDB4eHsyePZs9e/boJgZv5OLiQp8+ffjrr78YMWJEvX8eIYQQQgghhBDib0MDKPw8uFLJyjxRbw8++CAmJiYcPXq0saPccjk5OQQEBDB06FDWrVun97309HS8vb15/fXXWbhwYb2OKyvzGo+s2GgksjKv8cjLeuOQlXmNRsZ5ca+RlXmNR1bmNR5ZmXd3srfxoHvbv/HKvDJZmScUrrCwkDNnzrB//36OHTvGzp07GzvSLfHqq6/Ss2dP3N3diYuLY+XKlaSnp/Paa6/pyiQnJxMaGsrKlSspKytj6tSpjZhYCCGEEEIIIYQQ9zKZzBN1Eh8fT8+ePXF0dOStt97621xmWlBQwOzZs0lMTMTCwoJu3bqxf/9+2rdvryvz448/Mn78eLy9vfn8888bfGMPIYQQQgghhBBCCGPJZJ6oE19fX/6OV2R/9tlntZYZN24c48aNu/1hhBBCCCGEEEIIhVChQfU3nCdQApPaiwghhBBCCCGEEEIIIe4GMpknhBBCCCGEEEIIIYRCyGSeEEIIIYQQQgghhBAKIZN5QgghhBBCCCGEEEIohNwAQwghhBBCCCGEEELUn9wAo1HIyjwhhBBCCCGEEEIIIRRCJvOEEEIIIYQQQgghhFAImcwTQgghhBBCCCGEEEIhZM88IYQQQgghhBBCCFF/f+c981SNHaB6sjJPCCGEEEIIIYQQQgiFkMk8IYQQQgghhBBCCCEUQibzhBBCCCGEEEIIIYRQCNkzTwghhBBCCCGEEELUjwYoa+wQt5FpYweonkzmCXEHqExMMLG2aewYRinLzW3sCA2juot3Lf070yj3VV1lehe/ateBpqSksSPcm1QKv9hBU9rYCYQQ4u7XLqCxExit9ZuhjR2hQRKebdPYEYxSvM2isSOIvymFv/MUQgghhBBCCCGEEOLeIZN5QgghhBBCCCGEEEIohEzmCSGEEEIIIYQQQgihELJnnhBCCCGEEEIIIYSoN5VG09gR7kmyMk8IIYQQQgghhBBCCIWQyTwhhBBCCCGEEEIIIRRCJvOEEEIIIYQQQgghhFAI2TNPCCGEEEIIIYQQQtSf7JnXKGRlnhBCCCGEEEIIIYQQCiGTeUIIIYQQQgghhBBCKIRM5gkhhBBCCCGEEEIIoRCyZ54QQgghhBBCCCGEqCeN7JnXSGRlnhBCCCGEEEIIIYQQCiGTeUIIIYQQQgghhBBCKIRM5gkhhBBCCCGEEEIIoRCyZ54QdwFnt0Imz4mk04OZqFRw9pgDq9/1IzleXWtdc4syxkyLof+IZGzsS4m4bM36pT5cOOWgK2NlU8rr710loG0uTi5FlJSouB5pxc4vmvPL9y4Nyu7iXsTk4Dg6984GFZw9aseq+e4kX7eoPbu6jLGzEuj/ZDq29qWEX7Ri3aLmXDhpq1dOpdLwzD+TGDI6FSeXEmLD1WxZ0Yxfdzs2KLu0e+O0e2X+63TudWN+D5Lj6ph/Znxl/ktWrFvkXn3+USna/BFqtqxwa3i/aV7E5PnX6PxQFqjg3K/2rFrgVffsM+Lo/2Sqtt9ctGbd+x5c+N1Or9yTExJp3zOblu1zcXItYfOK5mxe4d6g3KDsfqPk7AAuzYuYHBxL517afnP2VztWza9Hv5kZR/8n0rB1KCX8ojXr3nPnwsmb+s3ERDr0zCawfR5Nm5Wwabkbm5ff2/3GuXkhk+dEVY7zvzmw+l3f+o3zj6VgY19CxGUb1i/x4cIpe10ZK5tSXn8/nIC2OTi5FJeP85bacX5nw8Z5UHbbS/ZG6vPOuUyeeIbOnRJApeHcOTdWrelCcrJNrXXHjTlHYGAagQFp2NsXsWxFd/bt96+xTuvWySxbsg8TExgy/DnKyhq2VkTxbT/hDJ073tD2a+vY9qPL275Fedt/1J19B6q2/ZL39tP+vqQqj6/6rDPffR9kfHa3AibNjqBTz3TtWHnckTUftCA53rLWuuYWZYz+VxT9hydhY1dCRIgNG5b5ceEPx2rr9B6cxJvLQkhJsGBM/+5G567QzD6H6Y8eo7t/LKg0/B7hybI9PUnIsquxnptDNjMH/UYrtxSa2ORTUGxOeFITPv+tI79d9al3OSHuJFmZJ0QjU1uW8sGmi3j657NsVgBL3wjE3aeAxZsvoLYqrbX+tPevMuiZRDat9CZ4UhBpyRa8u/4y/q1zdWXMzMsoLVXxzSoPFkwJYsn0llwLt2LWsjAeHxdnfHarMhZ/G45XQCFLX/dm6b+88fArZMnW8Dpln77sGoNfSGXTUjfmjfUjLcmc976MwL9tvl65sbMSGDUjkV0bnJk7yp/LZ6yZsyaarv2zjM8u7d4o7Q6gtixj8bdX8WpRkd+nPP/VuuX/sDz/h82ZN86ftERz3tsSjn/bvKr5pyewa4MLc0f7c/mMDXNWRzWw35Sx+OsreLUo4MPpfix93Q93vwIWfxNat36zJJpBz6fwxTJ35o8PIC3JnEWbw/Bvo5990PMpODYt5tjPjkZnrZJdwf1Gydmhos+H4dWigKXTfFn6mq82/7dX6tjnoxn8fCqblrkzb2wL0pLMeG/L1Sr9ZvALKTg6l3Bc+o02u2UpH2y6pB3nZwaw9I0A3H3zWbzlYh3H+XAGPZvEppVeBE9sTVqSBe9uuFR1nC9BO85PDmLJtECuhVsza9lVHh9v/DgPCm97yd442dUlLH7vAF6eWXy4vDtLl/XE3T2bxe8fQK0uqbX+iOFXUFuUcvJ3jzo9n6lpGf965XcyMmqf8KkLxbf9ovK2/6g7S5eXt/2iOrb9sPK2P1V720dEOvL6GwP1vg4fMX5CSW1Zyvsb/sTTP4/lb7Xiwzdb4eGTzwcb/qxTu7/+biiDno5n0398CJ7alrRkCxZ+dgH/oByD5W3sSpj073DSkmufoK0LS7NiVo35Hl/ndOZ/1495O/rj7ZTJ6rG7sDQvrrGutUUxGfmWfPpLN177cgjvfN+HvCJzPh75E/2CIupd7p6kQXsDjL/r111MVuaJGn333XcsX76ckJAQsrOzcXV1pVOnTkyZMoVBgwbd8ufz9fWlb9++bNy4sV71xo0bx6FDh4iKirrlmW63Qc8m4uZVwMSBnYiPsQIgMtSadfvOMOS5RHZsqH5VhV9QLv1GpLD8zRbs29YMgD9/d2D17rOMfi2GBVNaA5CdYc6S6S316p463AQPv3wGPp3EdxuNW7kx+IVU3HyKmNAriLgo7SqHiEuWbPgthKGj09i+pvpVCf5t8un/ZAbLpnmx9xsnbfbjtqw5FMqYmQkEj/MDwKFpMU9NSebb/7ryv1WuAJw/Zou7bxEvvhXPqYP21T5HTaTdG6fdAQaPTMXNu4gJvVtX5r9syYZfLzN0dCrb17jWkj9dm//bppX5fwlhzBsJBI/3r8w/OUmbf3VFfjvcfQt58d9xxvebF5Jx8y5kQt+2xEdrP7xEhlix/vAFho5MYfvaZtXW9WudR/8n0lg2w4d9W5212U/YsWb/RcbMiCP4pQBd2ckD2qDRqDAx1TBsdIpRWW+m5H6j5OwAg0emaPtNnzbERWn7TcRlKzYcvcjQUSls/6z6fuPfOo/+T6SzbLpPZZ8/Yceag5cY80Y8wS+20JWd1P+GfjNG+s2gZ5PKx/mOxEeXj/Mh1qzbf5YhzyeyY30t4/xjKSyf3YJ927SZ/vzdntU/nWP069dYMFm7AqbWcb6G15LaKLntJXsj9flHr+LmlsuEycOIj9euSIqMdGT9Z7sYOjiM7d+1rrH+U8/8A41GRfPm2TwyILLW53v6qcuogJ/3teD5Zy8alflGim77gVdxa5bLhJdvaPsoR9av3sXQQWFs31lL2z93Q9s/XHPb5+ebExLqbFROg9mfTsDNs4BJQ7ve8J7YhrU/nWLIM/Hs+Nyz2rp+rXLoNyyZFXNasm+HGwB/nXJk1fenGfVKFO+80q5KnRdnRBAZYktasgWdeqQ3OP8TXS7j0SSbJz95jth07RUyYYlN2fHqVzzV5RJbTnSotm5EshMLv++r99ivV3z4/rUtjOgYyi8h/vUqJ8SdJCvzRLU+/vhjnnjiCQIDA1m3bh0//vgjc+fOBeDgwYO35Tl37NjB22+/fVuOfbfq3j+dkHN2uhdPgMRYSy6dsafHgLSa6z6cRnGRiiM/Vr6gl5WqOPyjM116ZWBuUVZj/awMc8pKVcZnH5hFyBlr3RsugMRrai6esqHHo5m11i0uUnH4e0f97Dsd6dInW5f9/r7ZWKg1HNjWRK/+we1N8G9TQDOvQuOyS7vrZ79D7a7NkEnIGRvD+QfWlj+zPH9lrhrzb3fSz7+tgf3mkUxCztroJvJ02U/b0n1gRo11ezyizX5kV2WmslIVh3Y50bl3ll6/0WiM7x/VZldwv1FydijvN2dsdBN5uvynbeuQv5o+/30TuvSRflPj8z+cph3no28e5+3qMM6nl4/zTfWz13WcTzdr0DgPCm97yd442R+4TkhoU91kEkBioi0XL7nQvfv1WuvXZwxp7pbN889e4JNPu1JacmvGnr9l21++9W1/qz3QP5XQ8/b674mvW3HprAPd+6fWWLd7v1SKi1Uc+alyorWsVMXhn1zo8lA6Zub6Y2WbTpn0G57Ep+8G3Hwoo/VuGc1fsa66iTyAuAx7zse40adVVL2PV6oxIafQgtKymn8ndS0nxO0ik3miWh9++CGPP/4469atY/jw4fTv35+JEyfy3Xff8cEHH9yW5+zUqRMtWrSoveDfiHdgHtFh1lUejw6zwjsgz0CNSj4BeSTGqiksML2prjXmFhqaexfcVEODiakGO8diBj+bQJeHMtixobnR2X1aFRAVUvXSiuhQS7xb3vzcVesmXLOgMF9/GIoOtcRCrcHdt0hXrqhARVykRZVyAD4tjXvTJe3eOO2urVtAVKiB/FfqkL9lef6Cm/JfqchfqCtnMP8VS933jcoemE90qFWVx6OvWOEdWPMxvVvmk1iH7LeLkvuNkrNr6+YTZajfhFrW2m+q7fOhVtJvauEdmE/0FQPtHmaNd0C+gRo3ZA+sbpy30o7zPjWN84l06ZVZ48q/ulBy20v2Rsruk0l0tGPV7DEOeHvXPBlWX6++coqjv3pz4WL1q+nrS9Ft751JdIxj1ewxDnh73dq2b+Gfxravt/LDjq/4v4938+gj4Q06nndALlFXDbwnvmqNd4ua3xN7B+SRGGtZZayMuWqDuYUGd5/KsdbUrIxXF4SxbYOn3sRhQ/m7phGe7FTl8YjkJvi71G3lnwoNpqoymtrkMbH3aXyaZvLNqaqrCutaTog7QSbzRLXS0tJwc3Mz+D0TE/2u8/vvvzNgwABsbW2xsbHh4Ycf5vfff69S7/DhwzzyyCM4ODhgY2NDhw4dWLdune77vr6+jBs3zqhj3yw+Pp4xY8bg7OyMWq2mffv2bN68uUq5/fv306lTJywtLQkICGDt2rWMGzcOX19fAAoLC3FxcWHatGlV6m7cuBGVSkVISEiteapj51BCTmbVK96zM82xta95jw07xxJysgzVNdN9/0bDRyXwY8hxvj11ipfnRbLqXV8OfGf8mzA7x1JyMk2rPJ6dYYqdQ817bNg5lpCTYbjujdntHEvJyTIFVDWWqy9p96p1b8x+u9pdd2yDGczqkL+6n91M931dOYP59cvVl51jKdkGnj8nwxQ7h9r7TbaBPpdTnsm2AW1aF0ruN0rOrjt2Nf22Lv2mup+94ti3k5Lb3s6hmrE6w8z4cb5iDLnp9zZ8dAI/hp7g29OneXl+xTjfsBtgKLrtJXuNmW5bdtsisnOq7kOWk22BnW2RUcc0pH+/SAID0li7vtMtOyZI29fFXxddWfVZF4Lf7c27H/Tierwd0/51kuefuWD0MbXvic2rPJ6TaYatfc17ztk5FNf8nviGsfIfL13D3KKMb9d4G53VEAerQrLzq97UKDPfEjuruk3OvvbICX6ft4a9b3zB6J7n+ff/BnAqsurlxXUtd88p+xt/3cVkzzxRrW7duvH555/j7+/PY489RsuWLQ2W+/PPP+nTpw9t2rTRTW598MEH9OnThxMnTtChg3afgp07d/LUU0/x4IMPsnr1apydnbl48SLR0dHVZqjrsW+Wm5tLnz59SE9P57333sPLy4vNmzczevRo8vLymDRpEgCXLl1i6NChdOvWja+//pqioiIWLlxIZmambsJSrVYzfvx41q1bx/vvv4+lZeUZw9WrV9OnTx+Cgoy/e9SddGS3MyHn7LBvUkz3h9N4eV4kZWUqfvra8KStuDWk3YUQ4u/tyI/OhJy1w96pmO4Pp2vH+VIVP31d/X6IQiiRrW0hkyacYcPnHcjMvDU3vhB1t2lLe73/nzjpydtvHeG5Zy6y4/tWFBRUnZS7GzT3zufZydd4919tKC66+9YTfXniPn6+0AJn23yGdghl0VMHmP2tKUfDfIwqJ8SdIJN5olqrVq3i6aefZtasWcyaNYumTZvyyCOPMH78eAYOHKgr984776BWqzlw4ACOjo4APPLII/j6+rJgwQK2b9+ORqPhtddeo2PHjvzyyy+6ibIBAwbUmKEuxzZkw4YNhIWF8csvv9C3b18ABg8eTGJiInPnzuWll17C1NSUd999F3t7e37++WesrbXLy3v16oWfn5/eqsQpU6awbNkytm7dyujRowHtROOJEyf46quv6t22N8rJMsPWwMqM6s503Sg70wxX96pnnCrOglWsIKiQmWZOZpr2Rf6Po01QW5UxYXYUe//nSmlJ/V9YczJNsTVwprS61Us313X1rHq2r2KVSUX2nExTbO1L0d4qSVVtuXpnl3avUvfG7Ler3XXHNrCaSLtyrS75q57hrjiTXnFmvfr8+uWMyW5odYCtY6nBVXf6dc1o5lH1cpWKFXk5DWjTulByv1Fydt2xDeY3vFrz5rqG+3xFLuP6cl0pue1zsgyvwKtu1d2Nqh3nK8aQzBrG+SNNUFuWMeHNKPb+z8WocR4U3vaSvXGy5xheBWZrZ3jVmDHGjvmTtDQrjhz1xsZG+1wV+9HZ2BRTVGRKYaG0fYVb2fbVOXTEhwd7xOLnk8Hl0PqvCM7JNMPWoWrb2TqUkJNV8+RgTtb/s3fncTXlfRzAP7dNkdJethb7TggNSlJUyJK9VIgMkjVLuyVMZBtlT9bBJBKJNltGjKVBjSVLSlpQKqnu80dPZ1z3tpnROTff9+vl9dQ95/Z8unO695zv+f2+P+mqz4n//145a/lj3L3RBI/uKqBR4/Jt0tJlAK98ddvPxTwUf/q2z7MPhQ1EjsBTlCsSOWJPlMw8eWTmyQMALv+tjaCpYZhvdl2oSFfT/QipC9wrixPOaNu2Lf7880/ExcVhxYoV6N69O0JDQ2Fubo5Vq1Yx+8XHx8PKyooptgGAgoICRowYgbi4OABAcnIynj9/junTpwtN0a1KTX52Zc9r1qwZU8irMGXKFLx9+xYPHjwAACQkJMDCwoIp5AGAlpYWDA0NBZ6np6cHc3NzBAUFMY8FBQVBTU0No0ePFplh586d6NWrF3r16oVifuV9Pp7/LQdtET3aWrYuxAsR/Su+9OJxQ2g0/4QGsoInPi1bF+BzMQ/pL6q+Y/r3fXk0lC+DkmrVQ+gr8zxZFtrthH+3lm2L8CKl6v/v58my0GxRjAZyguOXW7YtQvEnHl6nyjD7ycj+0+vky/0A4HlKzT6khf7/6XUXem5dvO7lz5UV2bOuZZta5Jf9Kn+bivwNmP+PqvN/22iC5yly0G4r3GtLu00hXvxdTfYUWWiIyK79VfbvRZyPG3HOXv5cWZHHTcu2RTU4buREH/NtC+m4qS7733LQbiPidW9diBePq+7X9OJvuUre5wvL3+efV/M+n9ToX73PA2L+2lN2drK/UIS2iN542i3e48ULRRHPqD3tFu+hp/cOJ46dxMnfTuDkbycw3qb8vPr40ZNYuvjaN//sevvav/xvXvvq8L+aOlxTLx43hLaI3ngtWxXgxZOqz4mfP24IjeZFwu+VrT7iczEPr/+/AFHLVgUwMMrB8RvXmH/GVm+hqlGM4zeuwd419ZuyA+W98VqJ6I2nq5aLp2+VRDyjeg9fq6O5cvW9Dmu6HyHfAxXzSJUkJSUxcOBArFq1ChcvXsTTp0/RpUsXeHt7Ize3/E0zJycHWlrCzfw1NTWZfbKzy1dCat68dj0FavKza/u8iu1AeV89dXXh3mUaGsLTYmbPno2rV68iKSkJHz9+xMGDB+Hg4AAZGdF325ycnJCYmIjExETI8Co/AbkRrYz23fOg2eKfkxf1ZkXoqJ+HhEtVfwDdiFaCtAwfA4b9s9KUhCQfAy2zcftKk2qHsXcx+ICCfAm8y/62IfkJFxTQQb8Ami3/uRum0bwYnXp/RMIFhaqfG6VQnt3qnUB2oxHvcDu+MZP9ZkxjfC7mYdBowf/eg8fk4tlDWbx5+W0nXfS6vxPIXlev+z/5P36V/1N5/qiqT3iZ/MNrmH/UV/lH/7v8CRcV0b6HcPaOvfKRENWkyufeuNjk/6/9P5kkJPkYaJWL25cVvvu0E3E+bsQ5e3n+JqKP+V75SLhQ3TGvKPK4MRqeK5D/exHn1/7Gpare54WbpQs8N1pZ9Pu8Rd28zwPi/dpTdpay32iG9u2zoKmZ/0929Xx07PgWCTeafdPP/Frgrp5Y4jZY4F/URV0AgNtyEwSHdK3mJ1ROrF/7P5qhfbssaGp89dp3+O9e+8qYGKWi6JMknqU2+abnJ8SooH23D9Bs/s/ND/WmRejY4wMSYlSqeCZwI1YF0tJ89Dd/yzwmIcnHgKFvcfuqEko+l7/ufgs7YOnUrgL/Ei8r4X2ONJZO7Yozh799waC4ZB10bv4GzZp8YB7TUvyA7i3eID5Fp9Y/jwc+urdMx6ucqo+5mu5HyPdC02xJrTRt2hTTp0+Hi4sL/v77bxgYGEBZWRkZGRlC+2ZkZEBJqbwooqqqCgBIS6t+afYv1eRnV/a85ORkkc+r2A6Uj8LLzMwU2u/NmzdCj1lYWEBHRwdBQUHo1q0b8vLymN57/8a5YxoYPiUDHjse4cCmluDzAbv5L/A2QwYRX/RUU29ahL2XbuPw9hY4vK0FAODJA3nEhavAacUzSErx8eZVA1hOyoBm8yKsX9CGee6wCRlo3z0Pd641QVaGDBo3KcHAYVkYMCwbeze0ZD5oayvikDJGOGTBa18qgtdrgs8Hpi7OwNvXMjgb8s+Hv3qzYuy//hCHNmng0Kby3+lJUkPEhjXBLO/XkJLmI+OFDKzssqHZohjr5vzTGPd9tjR+36mKCXMyUZgvicf35WA04h26/ZQPL3vdb8oN0OvO1utenl8FI+yz4LX3GYLXa5XnX5IuOv+1Bzi0SROHAv6f/6//5/dKg5QUHxkvZWBll/X//P9McSjPr4YJc96g8KOEYH6Hf3HcHFbFiKlv4bn7MYI3lJ+c2y18jbfpMog4pPpF9k/YdzkJhzZr4fDmpv9kP62EmZ4vmeyWtm+h2eIT1rsIZmrT9SM0mheDJ8EHUD7ysL9F+YXHzWhFoZVNa0Kcjxtxzg4AEYdVMMLhLbz2PkHw+qb/z///Y/6g4HGz/+pfOBSghUMB5Tekyo95JczyevVF/v8f83NFHDctiiHx/8EZ2m2K0N/y/8fNpR/vuDl3TB3DbdPhEfjl+/zL8r/XI//ctFNv+gl7o2/j8LbmX7zPNyp/n1+ZCklpPt68lIXl5AxotijC+oWtmecOm/Dm/+/ziv+8z1tkY8CwHOxd/+3v84B4v/aUnaVj/nxrjLBKgad7HIJDugF8wG7KPbzNaoiIc/8ct+pqH7Fvz2kcOtIZh490YR7v0vkNFBU/QUmpvKjTpnU2CgvLLxevXC3P//Sp8Pl31y7l58337qujrOzHPObPRbbGCMsUeK6MQ/DBr17781+99rtO49DRzjh89KvXXqGS1/5aef5OHTMxfuwDXL3eAm/eNEKjRp9havIU/fqmYc/+7t88vfn8CS0Mn/waHtv+woEtOuDzebCdm4q3GQ1w7rd/BkeoNy3CnvN/4PAObRzZUX7O9fShPOIi1ODk9rT83CZNFpbj06HZvAgblvzTUzz5nnDBy9T6DT4X83D/ZpNvyl0h9HYHjDdIwsYJ5/FrTG/w+Tw4D7qJjA+NcDKxI7OfpmIewuYdxu64ntgV3wsA4GR0E4pyn3DnpSay8xtCRb4A1j0eoVOzTKw4+U87qJru96Pi8flsR/ghUTGPVCo9PV3k6LaKlVsrRrkZGRkhIiICeXl5aNy4MQAgLy8PZ86cYaa5tm3bFjo6Oti9ezecnJzA49VsGHhNfnZlzzt+/DiuXr2Kn376iXn88OHDUFdXR8eO5W/sffv2RUREBAoKCpiptunp6bh69arQ7y4hIYGZM2fCz88Ply9fhqmpKVq1alWj36Mqnwol4WbbCU4rnmHxL38D4OPO9SYIWq2DooIvekfwAEkpgMcTfLPc6NYaUxe8gJ3rC8grlODpo0ZY6dgRTx7IM/ukJjdEv8E5mL40FY2blOB9jjRePpGDx4z2uBlb9eiE6rIvGdcKs7xeY/GWF+DxgDtX5BHo0UwgO68i+1fnd/6uLWC/NB1Tl2RAXqEUTx/IYcVkPTy+Lzikf7+fFgo/SsJ6+lsoqZXg1ZMGWD1TGzcufvudMHrd2Xnd/8nfGrO80rB4y/N/8nt+nZ////yCr73/gpb/z5/+T/4penic9FX+dVooLJCA9bQv8s/SwY2L3z7d5VOhJJZOaIuZHi+xOOBZefarjRHk3ULka/91V4GNC3VgvyQNdovSyrM/lMNKuzZC2UdMfYshNv+MCBpolYuB/x+ZNdWwM968qv3IAXE+bsQ5+z/522CW1yss3pz6//yNEejVvJL8Xx3zC7Vhv+Q1pi5+zRw3K2xbCx839m9hNi6H+X7g8HcY+P9RrHZ9O/2Qx43blE5wWpGKxb88Rvn7vCKCVn39Ps8XmX3j0laYuvAl7Fxflr/PP2yElY4d8OSvr97nTXMw3e35/9/npfDySUN4TG+Pm7HfNr3ry/zi/NpTdhayf5LC0uWDMXPGbSxeeA08AHfuaiJop77Awgg8Hh+SknxIfHVuYzv5Prp2/ecm94jhf2PE8L8BAEMtJ31zrhrnF/fXfuVgzJx+G4sX/P+1v6eJoF01fO0n3UfXLl+89lZ/Y4TV/1/74eWvfU6uHHgSfNhOvgcFhU8oLZHAs9Qm8NtgiNh4nW/PXiiJZQ5d4bT0KRb5JQM84G5CEwStbSX4XomKcxvB7JtWtMVUl1TYuqRCvnEJniXLw92pC548bPzNmWqj6LM0ZgUPxwLza/AZFQ0egJvPmuGX84Yo/PzFaw8+pCT4Auf0j9LVMKnvPZh1fgz5BsXIzm+IlDcqmL5vJO6+1Kr1foTUJR6fT2VUIpqKigpMTU1hYWEBXV1dfPjwAREREQgMDISNjQ2OHTsGoHwhiD59+qBLly5YunQpeDwe1q1bxywQ8eVqtqNHj8bAgQMxa9YsqKmp4eHDh8jMzIS3tzcAQEdHB8bGxti/f3+tfra9vT1iY2ORmpoKoHw12x49euD9+/dYvXo1mjdvjkOHDuHgwYMICgoSWM22e/fu6NOnDxYtWoRPnz4xq9lKSUnh6dOnAq/J27dv0aJFC3z69AknT56stF/e1xQlVdG3odW/+u/BlrKPH9mO8K9INGrEdoRvJtavfQ0L9lzEk/y+Cwp8b/wS4Yb/pA5IiPdxgzLhpvPiQqJh1T2duKysQLhPFSHV4fXoxHaEf4X/519sR/hmvJ7i+9pLPHnFdoR/5c34jtXvxEHJJzehIPMl2zG+G0U5LRjqOrAd47t52/ACEhMT2Y4hEvXMI5VavXo1CgsL4eHhATMzM4wfPx7Xr1+Hn58fQkJCmP26du2K2NhYKCgoYOrUqbC1tYW8vDzi4uKYYhsAjBw5ElFRUQCAadOmYcSIEdi5cyd0dHQqzVDTn/21Ro0aIS4uDmZmZnBzc8PIkSNx9+5dhISECEyN7dixI86ePYu8vDyMGzcObm5umDNnDnr27AlFReHRO2pqajAyMoKWlhZGjBhRm5eTEEIIIYQQQggh5F+jkXmEfCU/Px+tW7eGpaUl9uzZI7AtNzcXLVu2xPz58+Hr61vjn0kj89hDI/NYQiPzWEMj81hCI/NYQyPzyI+GRuaxh0bmsYdG5nGTopwWDHXs2Y7x3bxtFMXZkXnUM4/88ObOnQtDQ0M0bdoUr1+/xubNm5GbmwsXFxdmn7dv3yI5ORmbN29GWVkZZs+ezWJiQgghhBBCCCGE/KiomEd+eEVFRVi6dCnevHkDGRkZGBgY4OLFi+jatSuzz9mzZ+Hg4ICWLVsiODhY5MIghBBCCCGEEEIIId8bFfPID2/Xrl3V7mNvbw97e/vvH4YQQgghhBBCCCGkClTMI4QQQgghhBBCCCG1wwdQRsswsIFWsyWEEEIIIYQQQgghRExQMY8QQgghhBBCCCGEEDFBxTxCCCGEEEIIIYQQQsQEFfMIIYQQQgghhBBCCBETtAAGIYQQQgghhBBCCKklPsCnBTDYQCPzCCGEEEIIIYQQQggRE1TMI4QQQgghhBBCCCFETFAxjxBCCCGEEEIIIYQQMUE98wghhBBCCCGEEEJI7VHPPFbQyDxCCCGEEEIIIYQQQsQEFfMIIYQQQgghhBBCCBETVMwjhBBCCCGEEEIIIURMUM88QuqAtBKQrZP0XX7227dvoaam9l1+dl0Q5/yUnR3inB0Q7/yUnT3inJ+ys0OcswPinf/7Z3/23X5ynbzu+t/vR3/3/Hwxfu31vt+ProvjRvLmne/yc7939oZlhd/tZ3MG9cxjBRXzCKkDWVlZ3+1n9+rVC4mJid/t539v4pyfsrNDnLMD4p2fsrNHnPNTdnaIc3ZAvPNTdvaIc37Kzg5xzk5+bDTNlhBCCCGEEEIIIYQQMUHFPEIIIYQQQgghhBBCxAQV8wgRc05OTmxH+FfEOT9lZ4c4ZwfEOz9lZ48456fs7BDn7IB456fs7BHn/JSdHeKcnfzYeHw+dSskhBBCCCGEEEIIITWn2EAThs2msB3ju3mrHMvZnoo0Mo8QQgghhBBCCCGEEDFBxTxCCCGEEEIIIYQQQsQEFfMIIYQQQgghhBBCCBETVMwjhBDCeWVlZUhKSkJcXBw+fvzIdhwiJu7du4dt27bB29sbGRkZAIDHjx8jLy+P5WRVS0lJYTsCEWP5+fl4/vw5Pn/+zHYUQkgl/vzzT4wePRqqqqqQkpLC7du3AQDLly/H+fPnWU5Xv9Fn7H+ND/DL6u8/DqNiHiFixNHREc+ePRO57fnz53B0dKzjREQc7Ny5U6wLYNu3b4empia6desGExMTJCcnAwCsra2xZcsWltMRLvr06RNsbGzQo0cPzJs3Dz4+Pnj9+jUAYMmSJVi9ejXLCavWvn17DB48GMePH0dJSQnbcWrlwoULbEf4YYWHh0NfXx+Kiopo1aoV7t+/DwCYPn06Dh8+zHI6wlW0FmLdu3LlCvr164dHjx5h0qRJKCv7p2AgISGBwMBAFtPVjDgXxMT5M5aQL1ExjxAxsn//frx9+1bktqysLAQHB9dxotpbvnw5Xrx4wXaMb3Lt2jWEh4cz32dnZ2PixIno0qULFi1ahNLSUhbTVc7Z2RlNmzbFzz//jHv37rEdp1Z27doFFxcXWFtb49ixYwIXHQMGDMDJkydZTFczYWFh2LdvH/P98+fP0a9fPzRu3Bhjx45Ffn4+i+mqduDAgUr/HTx4EGfOnMGrV6/YjilkxYoVuHjxIkJCQvDmzRuB42bYsGGIjIxkMV319u7di8LCQowfPx7NmzfH8uXLK72RwzVDhw5F69atsWHDBmRlZbEdp9bE9ebHqVOnMHLkSKiqqmLdunUCxQFdXV2xOD/IysoSOj8ICgrC3LlzBT57uUpcR1ppa2vD19eXueFRHzx48AAnT57k7O/k5uYGc3Nz/PXXX9i4caPANn19febY4TJxLoiJ82csIV+iYh4hYobH44l8PCMjA3JycnWcpva2bt0KPT09WFhY4PTp0wIXHFzn5uaGW7duMd8vXrwYERERaNu2LXbs2IE1a9awmK5yT548wezZs/H777+jR48e6NevH4KDg1FUVMR2tGpt3LgRCxcuxM6dOzFq1CiBbe3bt2dG6XHZqlWrBIrwCxYswKtXr+Dk5IT4+Hh4eXmxF64a9vb2cHBwgIODA+zt7Zl/Dg4OmDp1KkaOHAkdHR1MnjwZxcXFbMdlHDlyBKtWrcKkSZOgrKwssE1XVxepqansBKshe3t7XLt2DXfu3MGYMWPw66+/ok2bNhg6dCjCwsI4/b4ZHR2N3r17w93dHc2bN8ekSZMQFxfHdqwaE9ebH97e3nBwcMCFCxcwf/58gW2dO3dGUlISO8FqwdHREX5+fsz3vr6+cHZ2xuHDhzFy5EgcO3aMxXRVE+eRViYmJvDz84OOjg5Gjx4tdqNr58yZg1mzZjHf//777+jWrRtsbGzQsWNH3Lx5k8V0ot2+fRvOzs7g8XhC5/WqqqqV3rjnEnEuiInzZywhX6JiHiEcFxoaCjs7O9jZ2QEAPD09me8r/tnY2GDatGno2bMny2mrl56eju3bt+PNmzewtraGtrY2vL29kZaWxna0aj18+BC9evUCAHz+/BknTpzApk2bcPLkSaxevZqz05h0dHSwdu1avHz5EkePHkXDhg3h6OiIZs2awdXVFQ8fPmQ7YqWePXsGc3NzkdsaNWqEd+/e1W2gb/DkyRN07doVAFBYWIiIiAhs3LgR/v7+WLNmDUJDQ1lOWLmrV69CW1sbc+bMQVxcHB49eoS4uDjMnj0bLVu2xNmzZ+Hn54fQ0FBOFSWzs7PRoUMHkdvKysrw6dOnOk70bbp27Yrt27fj9evXCAoKwps3bzB69Gi0bNkSXl5eePPmDdsRhRgbG+PIkSN49eoVfH19kZiYiEGDBqFDhw7YvHkzcnNz2Y5YJXG9+fHw4UOMHz8egPBNPyUlJWRnZ7MRq1YSExMxePBg5vvAwEAsX74c2dnZ+Pnnn4VGMHGJOI+02r9/P16/fo1ffvkFKSkpGDp0KFq1aoV169aJRVHp3LlzMDQ0ZL739PSElZUV7t69CwMDA3h7e7OYTjRZWVkUFBSI3Jaeng5FRcU6TlR79aEgJo6fsZzF59fffxxGxTxCOO7Fixe4fPkyLl++DAC4c+cO833Fv/v378PQ0BA7d+5kOW315OXlMXPmTNy6dQs3btyAmZkZNmzYAF1dXYwaNYrTU1Hy8/OhoKAAAPjjjz/w8eNHWFlZASg/Wef69GEpKSnY2Njg0qVLSE5ORpcuXbBlyxZ07twZRkZGOHv2LNsRhaiqqlY6iio5ORnNmjWr20DfoKioiBk1e+3aNZSUlMDMzAwA0K5dO85OAwKAX375BRMmTMDmzZsxYMAAtG3bFgMGDMDWrVsxceJE7Ny5E4sWLcLChQtx9OhRtuMydHV1cf36dZHb/vjjD7Rr166OE/07qampuHfvHlJTUyEjI4POnTtj48aNaN26NWeLwaqqqli8eDFSUlIQFRUFVVVVLFiwAM2bN4e9vT3Tz41rxPXmh4KCQqXTmlNTU6GmplbHiWovJycHGhoaAICkpCRkZGRg6tSpAMp7pHJ5JLa4j7RSVFTEvHnzmIWmDA0N4eXlhRYtWmDChAmIjY1lO2Kl0tPToaOjAwB49eoV/vrrLyxbtgxdunTBvHnzODkyr3///ggICBBoz1Jx3OzZswcmJiZsRau1+lAQE8fPWEIAKuYRwnkuLi549uwZnj17Bm1tbZw7d475vuLfo0eP8Pvvv4vdBWrv3r2xZ88ePHv2DIaGhggLC4OlpSX09PSwfft2zt3Va9asGe7evQug/E5w586doa6uDgDIzc1Fw4YN2YxXI3l5efj1118xZswYxMfHo3v37li9ejVKSkowYsQIeHh4sB1RgJWVFXx8fPD06VPmMR6Ph6ysLGzatAnW1tbshashHR0dXLlyBUB5/7yePXsyd90zMzM5fQf+woULAiNlvmRiYoJLly4BAAYOHMip0bV2dnbw8/PDoUOHmBU9eTweYmJisGnTJrFYLKi4uBiHDh3CwIED0aVLF5w5cwZubm54+fIlzp8/j+fPn2Po0KFYsGAB21GrFBERgS1btiAhIQHq6uqwtbVFXFwc9PX1sWPHDrbjVUrcbn4MGTIEa9euFRitzOPx8OnTJ2zbtg3Dhg1jL1wNqaioMD04o6Oj0bRpU7Rp0wZA+Wh4rp0TfKk+jLSq8NNPP2HUqFHo3r07iouLcebMGQwePBgGBgacLGY3bNiQ6T0bFxcHBQUFZhaFvLw8J1cv9/X1xe3bt9GtWzf4+vqCx+MhODgYgwYNQkJCAjw9PdmOWGviVhCrL5+x5MdGxTxCxERxcTG6deuG9+/fsx3lP/PkyRMsWbIEnTp1wtWrVzFq1CgcOnQI/fr1w/z58wV6oHDBxIkTsXz5cowdOxYbN27ElClTmG23b99mLjq4KDExETNmzEDTpk2xcOFCdO/eHdevX8etW7fg5uaGq1evwsvLC9u3b2c7qoBVq1ahQYMG6Ny5M0xNTcHj8TBv3jx06NABkpKSnCs+ijJz5kx4eXmhV69e+PXXXzFt2jRm2/Xr19GxY0cW01WtQYMGAn0iv3Tr1i3IyMgAKJ+62qhRo7qMVqUlS5bA0tIStra2UFJSAlA+EsLU1BRDhw7F3LlzWU5YtYULF6JZs2aYOnUqGjdujNOnT+PJkydYunQpVFVVAZRPnXRxccHz589ZTissIyMDq1evhq6uLqysrPDu3TscPHgQL1++RGBgIB4/foyZM2fCx8eH7ahVEqebH6tXr0ZGRgbatWuH6dOng8fjwc/PD927d8erV684NQ2+MqampvDy8sK2bdvg7+8vcLPm0aNH0NbWZi9cNerDSKuXL1/Cw8MDLVu2xLhx49CkSROEhYUhLy8P58+fR2FhITNSkkv09fWxfft2JCUlYfv27RgyZAgkJMovcZ89ewYtLS2WEwrr1q0b4uPjoaGhgdWrV4PP52Pbtm0AyguS4nJzXlwLYuL+GUtIBR6f1iMnRGw0btwYZ86cgbGxMdtRvllpaSlCQ0MRFBSEmJgYaGhoYPr06Zg5cyaaNm3K7BcYGIilS5dyqnhZWloKPz8/JCQkoHfv3lixYgUkJSUBlE8BMjIygqurK8sphenr6+Pu3bvQ1dXFzJkzMW3aNKFFAQAgISEBhoaGnBv9kJeXh4CAAERGRiIzMxMqKioYOnQoXF1dmWnPXHfo0CHmuKnofwmUF/p++ukngce4xNnZGfv378eqVaswduxYqKurIzMzE8ePH4e7uzscHR2xfft2rFu3DqdOnap0aitbLl++LHTcGBkZsR2rWurq6nBwcMCsWbOgq6tb6X5ZWVk4e/Yspy6wx4wZg/DwcMjKymLKlCmYPXs2OnXqJLTftWvX0L9/f8693wDlNz+CgoJw9OhRlJSUYNy4cZg9ezb69OnD7OPr64uAgABO9aJ79eoVPD09hY55Hx8ftGjRgu141Xrz5g2mTJnCvFf+9ttvzIW1gYEBevbsydnRnHfv3sVPP/0EHR0djB07Fr6+vpg7dy7u3r2LW7du4ebNm5wt0Jw5cwZBQUGIjIyEoqIiHBwc4OzsDD09PYH9oqKiYGlpyanFjgDg5s2bGDp0KN69e4cmTZogJiaG6VM7cuRINGzYEEeOHGE5ZeWKioqQk5ODJk2aiMUMjwoLFy7EgQMHkJubC3Nzc8yePRsWFhZC08yvXLmCgQMHcuq9Xpw/Y7lIsYEGDLUmsR3ju3mrehmJiYlsxxCJinmEiBFzc3MMGjQIbm5ubEf5Zpqamnj79i0GDhyI2bNnY9SoUZCSkhLa78aNG+jXrx+nPvzF1YgRI+Ds7IyhQ4dWuhoyUH6HNT09ndOjH0jdKiwsxIwZM0ReCE2aNAm7du2CrKwszp49i8aNG2PgwIEspKx/iouLmVGP4qZr165wdnaGra0t5OXlK90vLy8Pt2/f5lxxVdxvftRXHz58gKysLKf/Lm7fvo3FixcjPj4epaWlkJCQwIABA7Bx40b06NGD7XiVkpCQQO/evTF79mxMmDABDRo0ELnf06dP4evri3379tVxwup9/PgRjx49Qps2bQRu8p09exZt2rRB27ZtWUwn7PPnzyguLhY5ov3jx4+QkZGBtLQ0C8lqTpwLYuL8GctFijIaMNScyHaM7+at+hUq5hFC/r2//voL1tbWcHFxgbW1NbS0tISKMxVTC7hq3rx5cHZ2rnSlSS7LyspCQUEBWrZsyTwWFBSEpKQkmJubM4thcElxcTGWLl2KSZMmoXfv3mzHqbWUlBSkp6eLvOCPj4+HlpYWp6c3A0B4eDhSU1MxZ84coW3bt2+Hrq4uLCwsWEhWcykpKbhx4wbS09OhpaUFAwMDzo4yAerHa07YIa43P96+fYvc3FyRRYuUlBQoKyszo9y4qj78DoD4jbS6ffs29PX12Y7xQ5k6dSo+f/6Mw4cPC22bMmUKZGRksHfvXhaS1RwVxEgFKuaxh9tX/YQQAV26dMGTJ0/g4uICbW1t5s7dl/+4bsuWLWJZyAMAR0dH+Pn5Md/7+vrC2dkZhw8fxsiRI3Hs2DEW04kmIyODnTt3orCwkO0o32T+/Pk4c+aMyG3h4eGcnNb8NV9fX3z8+FHktsLCQvj6+tZxotpr27YtbG1tsWTJEtja2nK6kAeI/2teXFwMb29vtG/fHg0bNoSkpKTAP1Gjmcm/V1xcjFatWkFVVbXKQh5Q/t7KlUIeAMyePRv+/v4it23atAmzZ8+u40S1Vx9+B6B8MYymTZuKRSEPgNgX8lxdXWFraytym62tLRYvXlzHiaoXExODkSNHitw2YsQIZnEpLhPnQp6uri709PRE/mvdujV69uwJJycnJCUlsR2VkCrR2SAhYsTDw6PaCwyui4+Pr3SbhIQEFBUV0b59e04WJhMTEwWmCQQGBmL58uVYtWoV5s2bh40bN2L8+PEsJhSte/fuuH//vlhOgUxMTKx0IZSBAwciODi4jhPV3qNHjyq9WOrevTtWrVpVx4lqLyMjAy9evEBRUZHQNi4eV+L+mi9evBjbt2/HsGHDMHr06EqnvXGRhIREpZ9TPB4PioqK0NfXx+LFi2FmZlbH6apWcfNj1KhRbEeptStXrlS6gJGZmZnIUapcI+6/w9OnT/Hbb7+JfK/k8XjYs2cPS8mqFxcXhyNHjlSancvFpdOnT1e6wIu5uTm8vb2xYcOGug1VjczMTKirq4vcpqamhjdv3tRxotrT1dWt9L2+4ny+Z8+emDdvHjp37lzH6apmZGSEmJgYZGZmwtDQEBoaGnjz5g2uXr0KTU1NaGtr48yZMwgJCcGlS5dgaGjIdmRCRKJiHiFipKrV6GJjY3HgwIG6C/ONjI2Nqy1INmzYEPPmzcPq1avrKFXN5OTkQENDAwCQlJSEjIwMprhnbW3N2dff398fEydOhLa2NiwtLcWqIJyXlwdZWVmR26SlpTm1QEplysrKkJ+fL3JbXl4ePn/+XMeJai4tLQ22traIi4sDAPD5fOb4qfj6y9UbuUKcX3MAOHHiBLy9vbFixQq2o9Sau7s7goODUVRUBEtLS2hoaCAjIwMRERGQlZWFtbU1YmNjMWzYMISFhXGuPYG43vzIzc2FoqKiyG0KCgqcWqijMuL8O5w6dQrjxo1DWVkZ1NXVhQrwXP7cDQoKgrOzM5SVldG2bVuh7FzvyJSWlibQ/uRLzZs3R1paWh0nqp66ujru37+PQYMGCW27f/8+VFRUWEhVO+JcEBswYABu376NGzduQFNTk3k8PT0d5ubmGDZsGEJCQjB48GB4enoiKiqKxbRiguPvE/UVFfMIEWOPHz/GgQMHEBISghcvXkBOTo7zPTbCwsIwd+5cdOvWDWPHjmU+/H/77Tfcu3cPvr6++OOPP7B+/XooKSlh0aJFbEdmqKio4NWrVwCA6OhoNG3alOnX9vnzZ842QrexscH79+8xcuRISEtLQ01NTeDCgsfj4fnz5ywmrJyenh4uXbokcgRPdHQ0dHR06j5ULXXr1g2HDh0SOdrn0KFDzKp7XOTs7Iz79+9j/fr16NKli9iMEBPn1xwA8vPz0a9fP7ZjfBNZWVno6uri3LlzAoX4wsJCDBs2DGpqarh9+zYsLS2xZs0azhXzxPXmR/PmzXHjxg0MHjxYaNuNGzegpaXFQqraEeffwd3dHcbGxjh06BDU1NTYjlMr/v7+mDRpEvbu3SuWUyeVlJTw+PFjkb11Hz9+XOVCPGyxsrKCr68vjI2NBT6P7t+/j9WrV4vF6GBxLoitW7cOa9asEcgNAFpaWli5ciWWL1+OGTNmwMXFpdLZIYRwARXzCBEz79+/x7FjxxAcHIyEhAQA5Reubm5umDiR+81HT506haFDhyIwMFDgcVtbW8ycORMxMTHYt28fJCQksGfPHk4V80xNTeHl5YWsrCz4+/vD2tqa2fbo0SNO9U/60uDBg8XmgvRrdnZ2cHd3R8uWLTF9+nQ0aNAAnz59wu7duxEQEFDlaFWuWLhwIcaMGQMbGxvMmDGDGSmwc+dOhIaG4vjx42xHrNTly5exZcuWSvsRcZU4v+YAMHz4cMTHx8PExITtKLUWGBiIrVu3Co2olZOTg6urK+bMmYMVK1Zg+vTpnFrdsIK43vwYO3Ys1q5di27dusHS0pJ5/OzZs/Dz84OzszOL6WpGnH+Hp0+fwt/fX+wKeUD5yDYHBwexLOQB5edmq1atgpWVFTN7AgDevHmDNWvWYMiQISymE83HxwdRUVHo2bMnevfuzXxG/fHHH9DV1eV8KwhAvAtiL1++rPTmpKysLDOas1mzZiguLq7LaITUChXzCBEDZWVlOH/+PIKDg3HmzBkUFRWhadOm+Pnnn7F9+3YEBASIzZSg0NDQSheKGDt2LNNzbujQodi5c2ddRqvW+vXrMWXKFCxbtgy9e/eGp6cns+3QoUPo378/i+kqt3//frYjfLNFixbh5s2bmDt3LlxcXKCsrIycnByUlZVhzJgxWLp0KdsRqzVq1Chs3rwZK1aswO+//w6gfNqSvLw8tmzZgtGjR7OcsHJycnKV9vXhMnF8zZ8+fcp8PXfuXNjZ2UFCQgIWFhZQVlYW2l9PT68u49XY27dvK53GXFxczEyVVFVV5eT0PXG9+eHh4YH4+HiMGDECmpqaaNasGdLS0pCRkYG+ffsKfF5xlTj/Du3bt+f0NOCq9OzZE0+fPhU5IlIc+Pr6onfv3mjTpg2srKyYwlh4eDhkZWU5WRhTVVXFzZs3sXHjRkRFReHOnTtQVVXFihUr4OrqWul0cy4R54JYhw4d4O/vDzMzM4HfoaioCL/88guzUN/r168FCsSEcA2Pz8UzKUIIY+HChTh8+DAyMzOZfkNTp06FqakpPnz4AGVlZcTGxopNMU9RURHr1q0TeZdux44dcHNzw/v373Hp0iWMHj1aLHqiAcCHDx8gKyvLyTvbPj4+mD59Opo2bSq0LT09Hbt27YKHhwcLyWouOjoaUVFRyM7OhqqqKszMzGBsbMx2rFrJy8vDtWvXmN/B0NCQk9N/vuTp6YknT57g4MGDbEf5JuL0mn+9cETF6VllhSUu9ioEyqdevXv3DhcuXBCYFvn69WuYmZlBWVkZ8fHxOHDgAHx9ffH333+zmLZ++fz5M0JCQoTeK6dMmSI2KyCL6+9w6dIlzJ8/H2FhYZwttFfmzp07mDx5Mnbs2CE255JfS01NhYeHh9Bx4+3tzdlZE+JOX18fCgoKiIyMFCqImZmZIT8/H7dv38bRo0fh5uaG1NRU9sJ+5eLFi7CysoKioiIsLCygrq6OzMxMRERE4N27d4iIiMDgwYMxb948FBUVcW5wAdcoymjAUJ17CwD+V95qXkNiYiLbMUSiYh4hHFdxgWdhYYH9+/cLNMV9//49lJSUxKqYN3HiRERGRmLXrl2wtraGpKQkSktLERoaCicnJwwdOhSHDx/Gli1bsH//fty+fZvtyELKysrw4MEDZGdno1evXmjUqBHbkaokKSmJ69evw8DAQGjbrVu3YGBgwNnCAGHXzp074efnB11dXQwbNkzkCDFHR0cWktU/tV2ZmYtTVAHg9u3bGDx4MIqKitC3b1/mIun69eto2LAhoqOj0b17d2Z1dm9vb7YjE/KvDRgwAE+ePEF2djbatGkj9F7J4/GYhYS4oEWLFgI3Ct6/f4/8/Hw0bNgQSkpKAvtydWo5YZe4F8QePHiAVatW4caNG0hPT4eWlhb69u2LlStXMiPzSM1QMY89VMwjhONmzJiB48ePM6PwJkyYADs7OxgYGIhlMS8rKwujRo3C1atXISUlBSUlJeTm5qKkpAQ//fQTTp06BRUVFQQHB6NRo0YYO3Ys25EFbN++Hd7e3sjKygKPx8PNmzehr68Pa2trmJiYYN68eWxHFCIhIYGEhASRxbyLFy9ixIgRKCgoYCFZ7WRmZqKoqEjo8cpWsWNTfHw89PX1IS8vj/j4+Gr35+rfr4SERJXbubqaLVBedP/jjz/w4sULkceNnZ0dC6l+DNnZ2fD39xe6SFqwYIFYrNJ4//59eHt7Iy4uDrm5uVBSUsKgQYPg7u6OLl26sB2PcJCxsXG107NjYmLqKE317O3tazWdfN++fd8xzY8pODgYR44cEfkZxePx8OTJE5aS1RwVxAhAxTw2UTGPEDFQVFSE0NBQBAcH49KlSygrK0Pbtm0xatQorFu3DjExMZwtBlTmwoULSEhIQEZGBvPhz8UmxV/atWsXnJ2d4ejoCDMzM4wbNw6JiYnQ19eHv78/Tp8+zZk777GxsYiOjgYArFq1Cg4ODmjWrJnAPoWFhTh79iwaNWqEmzdvshGzWh8+fICLiwuOHTuGT58+idyHi8WkLwuoX0+f/BKfz+d0QawmozG4OIXpwYMHsLa2xpMnT0T2ZePya/61169fIy0tDc2aNRM5VZ78t27evAkjIyPIyckxvdsyMjJw5swZFBYWIj4+Hj179mQ7ppDi4mKsXbuWKQ58/X7J4/FQUlLCUrrK6enpITQ0FN26dYOurm6VBSZxKXCQ78/R0RHu7u7Q1dWtdnQ4j8fDnj176ihZzfj6+sLT0xOdO3dG586dRfaeowLq98fn8/HgwQPk5ORARUUFHTp0EMueqWyjYh57uNt8ghDCkJWVxcSJEzFx4kSkp6cjJCQEBw4cgJ+fHwDAzc0Ns2fPxtixY4VWEOQqMzMzmJmZsR2jVjZu3IiFCxdi3bp1QoWA9u3bY8OGDSwlExYXF8c0febxeCJPCmVkZNCxY0ds2bKlruPV2M8//4yTJ09i2rRp6NKlS6XNlrkmJiYGHTt2ZL4WV1ws1NXE7NmzUVJSgt9++02sjpsvHThwAJ6ennjx4gXzWMuWLeHr64spU6awmKxmcnJycP36deYiqW/fviKnaXPNsmXL0LlzZ1y6dAmNGzdmHs/Ly4OpqSmWLVuGCxcusJhQtMWLF2P79u0YNmwYRo8eLTbHvJGRERQUFJiv6UKa1ERMTAxcXFwAlPfUra4IzDV79uyBi4sLNm3axHaUf01cC2K7d+/GypUr8fbtW+YxdXV1rFq1CtOmTWMxGSE1RyPzCBFjiYmJCA4OxtGjR5GdnQ1FRUXk5uayHatGwsPDERcXh5ycHCgrK2PQoEGwsLBgO1aVZGVlERERARMTE5SWlkJaWpoZmRcbG4uhQ4eKnM7Htqqm2XKdmpoavLy88PPPP7MdhYgRBQUF7N+/n5Or1tbEtm3bMG/ePJiammLChAnQ0NDAmzdvcOTIEURHR2PLli2c/ptYuXIl/P39BUaHNWjQAIsWLYKvry+LyaonLy+PkJAQjBo1Smjb77//jqlTpyIvL4+FZFVr1qwZZs+ejRUrVrAd5YdRX9opAMDff/+NVatW4fr168xIYENDQ6xcuRKtW7dmO16907hxY4SFhcHExITtKP+KuBbEDh06BFtbWwwePBhTpkxhRmAfOnQIly5dwsGDBzFx4kS2Y4oNRRl1GKrV45F5WtdpZB4h5L/Xq1cv9OrVCxs3bkR4eDgOHDjAdqRq5eXlwcrKCpcvX4aUlBRUVFSQnZ2NjRs3YsCAAQgPD+fsapOqqqqVrsaVnJwsNI2VK8rKytiO8K+0a9eO7Qg/lPow7U1VVZWTK0vXlL+/P+zt7bF3716Bxx0dHWFvb49ffvmFs8W8gIAArFmzBtOmTRO4SDp48CDWrFkDNTU1TvYWrVDdiBKujjjJz89Hv3792I7xr4jbyuvGxsbMjbKqeuZxvZ1CbGwsLCwsICcnB0tLS+bmwZkzZ3Ds2DGcP38eRkZGbMesV4yMjHD37l2xLuYdOnQITk5OIgtiTk5OaNiwIWcLYuvXr8fkyZMREhIi8PjUqVNha2uLdevWcTY7IV+ikXmEkDo1d+5c7N+/H4GBgZgwYQKzmu3Ro0fh7OwMe3t7zk77nDVrFs6fP4/o6Ghoa2tDWloat27dQosWLdC/f39YWlrC39+f7ZhCrl27hpycHFhZWQEob04/Z84cJCUlwdzcHOvWrYOkpCTLKUWbO3cuJCQksHnzZrajfLOysjLs3LkTx48fx8uXL0U2uubSSoEODg7w8PCArq5ujZqkc7Gvz9atWxEREYHw8HDOHttVkZOTQ1hYmMhWBBcuXIC1tTVnF61p3749hg0bJnL6mKurK86dO4dHjx6xkKxmTE1N8f79e0RHRwtMs/348SNMTEygqKjIyWm2U6ZMQevWreHl5cV2lG8mbiuvx8XFoWfPnpCXl69Rv1yuFsR69uwJWVlZREZGCtxMzcvLg5mZGT5//szZUSmAeJ7jPH78GKNHj8aiRYtgYWEhsgVBdQtQsa1bt27o2rWrUEEMAGxtbXH//n3cuXOn7oPVgKysLMLCwmBubi60LTIyEtbW1igsLGQhmXiikXnsoZF5hJA6dfLkSaxatQqTJ09mHpOUlMTkyZORlZWF9evXc7aYt2rVKsTExKBz587o06cPeDwe5s2bh0ePHkFdXZ1TIwa+tHTpUpiamjInuosXL0ZERARMTU2xY8cOKCoqwt3dneWUopmZmWH+/PnIy8ur9ISX63e2lyxZgo0bN6JHjx7o3bs350eMfVmc279/P3tB/oW3b98iOTkZHTt2xJAhQ4SOGx6PB29vb5bSVa9Lly6Vjnj8+++/0blz5zpOVHOpqamwtLQUuc3S0hI7duyo40S1s2bNGhgbG0NbWxtWVlbQ0tJCRkYGIiIiUFBQgNjYWLYjijR37lzY2dlBQkKi0vdKPT09FpLVXFXjC3JzcznXB/DL4hxXC3U18eDBAxw7dkxoVkTjxo2xdOlSzo9QcnNzw+DBg8XqHKdt27YAym+eicLVBWu+lJycjPXr14vcNmXKFFhbW9dtoFpo3LgxXr16JXLbq1evBG7kEMJlVMwjhNSp7OxsZmGAr3Xs2BHZ2dl1nKjmVFVVkZiYiICAAERGRqJVq1YoKSnBnDlz4OrqyjTx5ppHjx7Bzc0NAPD582ecOHECAQEBcHR0REBAAIKCgjh3olth5MiRAIBnz54JFJZ4PB7npy5VOHjwINzd3TldPBKluLgYffv2hZ+fn9gtVlOx+AtQXvz6GteLeZs3b8aECROgqqqK0aNHMyOYT548iQ0bNuDo0aNsR6yUiooKkpKSYGpqKrTtr7/+goqKCgupas7AwAAJCQnw8fFBZGSkQF9Xd3d3dOnShe2IIlVMsfXy8qr02Obie+WXK68DQFBQEMLDwwX2qVh5vVOnTnUdr8ZSUlKQnp4usqgXHx8PLS0ttGnThoVk1WvevDmKi4tFbisuLuZsC5EKDx8+xNKlSwGIzzmOh4cHZ6fs15Q4F8SGDRuG5cuXo23bthgwYADz+PXr17Fy5UoMGzaMxXRiiA9AzFv6iCsq5hFC6pSuri7Cw8MxZMgQoW0RERHQ1dVlIVXNNW7cGO7u7pw7MaxKfn4+U2j8448/8PHjR+YOtr6+vsBqmVwjzivBVigpKeF04/PKyMjI4NmzZ5CSEr9TBXHvEzlu3Dh8+PCBaUWgpKSE3NxclJaWQl5eHuPGjWP25do07VGjRsHd3R0qKiqYOHEipKSkUFJSguPHj8PDwwNTp05lO2K1unbtihMnTrAdo1b27t0rlsWB+rLy+vz589GxY0eRxbzw8HA8ePBAqEjJFUuXLoWnpycMDQ0F+hWmpaXB29sby5cvZzFd9cTxHEecp8NXEOeC2Pr165GQkABjY2M0a9aMGYH96tUrtG7dutIRh4RwjfidoRNCxNrMmTOxcOFC5OfnY/LkycwH6NGjR7F7925s3LiR7Yj1TrNmzXD37l0MGDAA586dQ+fOnaGurg6gfOpSw4YNWU5YOXGeulRh7NixiIyMxODBg9mOUmtDhgzBhQsXOD+Vub4ZPHiwWBZmAGDt2rW4e/cupk6dCkdHRygrKyMnJwelpaXo378/1qxZw3bEKpmYmODXX39F+/bthbalpKRg1qxZAiPJuMLe3p7tCN/E09MTnp6eAMR75fXExETMmjVL5LaBAwciODi4jhPVXFxcHD58+AA9PT307duXWQAjISEBGhoaiI2NZaaX83g8zv0u4nyOA5QXI7Ozs9G0aVNIS0uzHafGxLkgpqmpiTt37mDv3r24fPkycnJyoKOjAyMjI9jb23P+mCGkAhXzCCF1ytXVFW/fvsXGjRuZaZN8Ph8yMjJwc3ODi4sLuwGrERwcjCNHjuDFixciFzLg4sqeEydOxPLlyxEbG4uIiAiBKVi3b9/m7NSfL2VlZSEhIQHZ2dkYPnw4lJWVUVRUBBkZGc43id64cSMmT54MJycnmJubQ0lJSWgfrhbL5s6diylTpqCkpATW1tbQ0tISKjJxtQ8Xn8/HmTNnEB8fj+zsbHh5eUFbWxtxcXFo06aNyBUzuUJcexUC5aOX4+PjcfbsWeYiSVlZGUZGRhg2bBjni5SxsbH48OGDyG15eXk1WuiATWVlZXjw4AGys7PRq1cvNGrUiO1INSbOI2rz8vIgKysrcpu0tDTev39fx4lq7sqVK5CSkoKWlhaeP3/OjPTV0tICAFy+fJnZl4t/v+J6jhMeHg4PDw/cvXsXAHDz5k3o6+tj+vTpMDExwaRJk1hOWDVxL4g1bNgQc+bMwZw5c9iOQsg3o9VsCSGsyM3NRUJCAnOh17dvX5FFDi7x9fWFp6cnOnfujM6dO4tsxs3FlT1LS0vh5+eHhIQE9O7dGytWrGBWdrO2toaRkRFcXV1ZTikan8/HkiVLsHXrVhQXF4PH4zEnvObm5ujfvz/npzw/efIEo0ePxv379wUeF4e+f18WSiu7iONi9tzcXFhYWODGjRto3Lgx8vPzmeNmypQpUFZW5vSUPcIeCQkJ3LhxA7179xba9ttvv2HGjBmcLcxs374d3t7eyMrKEnivtLa2homJCebNm8d2xBrLzMwUumEGAC1btmQhTfU6deoEKysrrFu3Tmjb0qVLERYWxulVnMWZOJ7jnDp1CmPGjMHgwYNhZmaGJUuWIDExEfr6+li9ejXi4+MRGRnJdkxCakRRWh2GqjZsx/hu3ja7QavZEkLIl5SUlDjdT0OUPXv2wMXFBZs2bWI7Sq1ISkpixYoVIredOnWqbsPU0tq1a7Ft2zZ4eHhgyJAh6NOnD7Nt+PDhCAkJ4Xwxz8HBAVlZWdi8eTPat2/P+dVsv8TF4nRNLF68GC9fvsTVq1eFVhA2NTXFhg0bWExXc3fv3kVycrLIooadnR0Lieqnffv2Mcc6j8eDk5OTUPP2wsJCJCUlcXa6/K5du+Di4gJHR0eYmZkJ9FUcMGAATp48yfliXllZGVauXImgoCC8e/dO5D5cvHkAlP89uru7o2XLlpg+fToaNGiAT58+Yffu3QgICKgXPdK4ShzPcby9veHg4IDdu3ejpKQES5YsYbZ17twZv/76K4vp6iddXd0ajyzl6kwbTqPxYaygYh4h5LuLj4+v1f5cXSygYoonqTu7d++Gh4cHli1bJnQR17p1a7E42UpMTMSBAwcwduxYtqPUmjgsViBKWFgYfvnlF/Tr10/ouGnZsiVevnzJUrKaeffuHSwtLZGQkACgfIQqIDg6kkvFPAkJiVpdJJWUlHznRLUjISHBjOTh8/kC31dQUVGBs7Mzs2om12zcuBELFy7EunXrhI759u3bi0UBOyAgANu3b8fSpUuxcuVKrFixAhISEjh06BAkJCSYVdm5aNGiRbh58ybmzp0LFxcXpldkWVkZxowZw9njpkJBQQH27t2LuLg4gRWcHRwcICcnx3a8Kk2aNAnOzs4CizBw3cOHD5mecl+/dyopKSE7O5uNWNUS54KYkZERJ6eJE/JvUDGPEPLdGRsb1+gDlOtTDo2MjHD37l3O9jf7kp6eHkJDQ9GtW7dqT764dsL1pbS0NPTt21fkNhkZGXz8+LGOE9Vey5YtxWo0niji1ocrPz8fzZo1E7mtqKgIXO8wsnz5cmRnZyM+Ph4DBgxAaGgoFBUVsXfvXly/fh1Hjx5lO6IADw8Psb5Imjp1KlO4HjRoEHbs2CFyAQwue/bsGczNzUVua9SoUaUj3bhk37598PDwwPz587Fy5UqMGjUK+vr6WLlyJczMzDi5KmkFSUlJnDhxAtHR0YiKikJ2djZUVVVhZmYGY2NjtuNVKSMjA8bGxkhJSYG2tjY0NTXx9OlTnDx5Elu3bkVsbCw0NDTYjlmphIQEHDt2DO3bt8fMmTNhZ2eHJk2asB2rSgoKCsjKyhK5LTU1FWpqanWcqGbEuSAmzr1oCakMFfMIId9dTEwM2xH+EwEBARg9ejRUVFRgYWEBZWVloX24shiDkZERFBQUmK/F9eSrWbNmSEpKwqBBg4S23b17F7q6uiykqp2VK1di3bp1MDExgby8PNtxak0c+3C1a9cOFy5cgKmpqdC2uLg4dOnShYVUNRcZGQlPT0+mkN28eXP07NkTxsbGcHZ2xubNm3HgwAGWU/6jPk0hrOzzKjs7GyoqKnWcpuZUVVWRmpoqcltycnKlxW0uefr0KXr16gVJSUlISUmhsLAQQPkCEvPnz8fcuXM5f6yZmJiIxQ2/Ly1ZsgS5ubm4fPkyfvrpJ+bxa9euMaMKuVwIefr0KSIjIxEUFIRFixZh2bJlGDduHGbOnFnpzUC2DRkyBGvXrsWwYcOYKf08Hg+fPn3Ctm3bONuGhsvHASE/IirmEUK+OyMjI7Yj/Cfatm0LoLwHmihcmj72Za8zcT75srGxgY+PD/T19ZmTch6Ph5SUFPj7+8PJyYnlhNWLjIzEq1evoKOjg379+gkt9MLj8RAcHMxSuqqJax+u2bNnY86cOVBUVGRWBHz37h327duHbdu2YefOnSwnrFp6ejr09PQgKSkJWVlZ5OXlMdtGjx6NCRMmsJiu5vLz85GbmwslJSWxKWTv2rUL7969w+LFiwEA9+/fx7Bhw5Ceno4ePXogPDwcmpqaLKcUZmVlBR8fHxgbG0NbWxtA+XtLVlYWNm3aBGtra3YD1oCioiLTH7Jp06ZITk5mikslJSXIyclhM169de7cOaxbt06gkAcAhoaGWLVqFaenN1cwNzeHubk5MjIysGvXLuzZswcHDhxA165dMXPmTEyZMoVT70GrV6+GgYEB2rVrBwsLC/B4PPj5+eHevXt4//49Z3v91Sf379+Ht7c34uLimM+pQYMGwd3dnfM3/DiJ4zMe6isq5hFCWJGTk4Pr168zvVn69esncqQbl4j7VDJx5OXlhWvXrmHgwIHMBaqNjQ1evnwJQ0NDsbjIuHLlCiQkJNC4cWMkJSUJbefyMSWufbicnJzw9OlTeHp6wsPDA0D5SAgJCQksWbIEkydPZjlh1TQ1NZlpkdra2rh+/TozVe/x48fsBauhyMhIrFixAnfu3GHaJ1Ss0jhkyBC241Vp69atAjcJFixYgCZNmmDp0qXYsmULPDw8OFkMXrVqFWJiYtC5c2f06dMHPB4P8+bNw6NHj6Curs78HXBZjx498ODBA6Yw4+npCTk5OUhJSWHFihXQ19dnO6IASUlJXL9+HQYGBtX2jeTSzb6v5efno2nTpiK3NW/eHPn5+XWc6NtpamrC3d0d06ZNw6RJkxAfH4/Zs2djyZIlmDlzJry8vDjRJkJHRwe3b9+Gp6cnIiMjISkpifj4eAwdOhQ+Pj6V/vfgGnEtiN28eRNGRkaQk5PDiBEjoKmpiYyMDJw5cwZnz55FfHw8evbsyXZMQqpFxTxCSJ1buXIl/P39UVxczPSuatCgARYtWgRfX1+W01WO69N7qpKTk4OzZ8/i5cuXQitj8ng8eHt7s5SsanJycoiNjcXhw4cRGRmJ1q1bQ0VFBe7u7pg8eTKkpLj/Mfbs2TO2I3wzce7D5efnB2dnZ0RFRSEzMxMqKioYMmQI9PT02I5Wrf79+yMhIQFWVlawtbWFt7c3UlNTISUlheDgYIwYMYLtiJWKjIyEpaUlWrduDXd3d2hqaiI9PR3Hjh2DhYUFIiIiOF3Qe/78OdMv7/3794iLi8OpU6dgYWEBFRUVLFu2jOWEoqmqqiIxMREBAQGIjIxEq1atUFJSgjlz5sDV1ZVpu8Bl8+fPx9OnTwGUr/Z5+/ZtpvCura2Nbdu2sRlPiIeHB5o3b858zeUbM1Vp164dQkJCMHToUKFtBw8eFKv+kdHR0QgMDERYWBjk5eXh6uoKGxsbnDlzBlu2bGF6AXJB8+bNsWfPHrZjfDNxLogtW7YMnTt3xqVLlwRWLs/Ly4OpqSmWLVuGCxcusJiQkJrh8bneBZoQUq8EBARgwYIFmDZtGqZMmcJ8+B88eBB79+7Fpk2bODltT5xduHABY8aMqXSxCC4vOkLY1bx5c/j4+MDR0RGlpaWQlpZGYmIi9PX1ERQUhPXr13N28RRx9uTJE7x+/RoDBgzA58+f4ebmhmPHjqGgoABDhw7F1q1bOdu/rWIqeXh4uEAP0bKyMlhZWeHdu3e4du0aiwmr1rhxY4SFhcHExARnz57F6NGjkZubi4YNG+Ly5cswMzNjermR74vP5+PJkycoKChAhw4dIC0tzXakeungwYOws7ODiYkJJk2aBC0tLWRkZODo0aO4ePEiQkJCmHYFXJSdnY19+/Zh586dePLkCfT19TF79mxMnDgRsrKyzH5Hjx7FtGnTxGLhLHFgamqKDx8+VFoQU1RU5GxBTF5eHiEhIRg1apTQtt9//x1Tp04VaG9BqqYorQ5D5TFsx/hu3ra4icTERLZjiMT9IQ2EkHolMDAQLi4u2LRpE/NYu3btYGRkBHl5efz666+cKub5+Phg+vTpaNq0KXx8fKrcl8fjwd3dvY6S1dyCBQvQo0cPbN++He3bt6cLIhYUFBRg7969iIuLY6aWDxo0CA4ODpCTk2M7XqXEqQ/XixcvoKWlBWlp6RqtetmyZcs6SPVtWrVqhVatWgEob/7v7+8Pf39/llPVzN27d3H8+HGhxYAkJCQwe/Zsgb6LXNSmTRucPXsWJiYmOHr0KAwNDdGwYUMAwOvXrznfDqI+4fF4aN26Ndsx6r0pU6agoKAAHh4emD59OvO4hoYGAgMDOV3IA8oXypKQkMD48eNx6NAh9O7dW+R+7du3h7q6eh2n+4ejoyPc3d2hq6sLR0fHKvfl8XicH7WXkJCAkJAQgUIeUH5DZOnSpcwK4VxU3ShacR1lyx4+UEbjw9hAI/MIIXVKVlYW4eHhIleZvHjxIqysrISmgbJJQkICCQkJTE+cqnB1hJu8vDxCQ0M5PbXtS3p6eggNDUW3bt2gq6tbbR8iro8My8jIgLGxMVJSUqCtrc2MRn3+/DnatWuH2NhYaGhosB1TpKysLPz00094+fIl+vTpg/j4eBgaGjJ9uK5duwZFRUW2YwKoXf8qAJz8WwWA4uJiaGpqYv/+/ZyeTlsZJSUl/Prrr5g4caLQtiNHjmD27NnIzc1lIVnNHD58GLa2tlBSUkJubi6OHz+O0aNHAwBmzZqF58+f49y5cyynLGdiYoJff/0V7du3r3YFVR6Ph0uXLtVRsm9XUlKC69evi2wJAaDaIkhdqu4G35e4erPvS2VlZUhOTmZuOLVr167a8x4u2LhxIxwcHIQWl+IaXV1dnDp1Ct26dYOOjk615zYVU865qnHjxjhw4EClo9vs7e3x4cMHFpJVz9TUFO/fv0d0dLRAMfLjx48wMTHh9KhCLlKUVoNhk3o8Mk87kUbmEUIIAKioqCApKUlkMe+vv/7i3NSxsrIykV+Lkx49euD169dsx6gxIyMjpr+TkZGR2N8hXbJkCXJzc3H58mWB1QKvXbuGMWPGYOnSpZxdcVic+nDt3buXGc22d+9esT1uZGRkICUlJTA9TJwYGxvD3d0dffv2ha6uLvP4ixcv4OXlhUGDBrGYrnqTJk1Cy5YtcePGDfTu3RsDBw5ktmloaHCqwPrl/fiysrIqj3lxuHd/+/ZtjBo1Cq9evRKZl8fjcaqY93UfXR6PV2luAJwv5klISKBDhw7M99nZ2Zw7JxNlwYIFbEeokS/756amprIX5D/Sp08frFmzBqampkIFsXXr1qFv374spqvamjVrmBkHVlZWzNTyiIgIFBQUIDY2lu2IhNQIjcwjhNSpOXPmIDg4mBm5ISUlhZKSEhw/fhyzZs3C1KlTsWXLFrZj1is3b96Evb09du/ejX79+rEd54ejpqaGdevWibwI3bNnD9zc3PD27VsWkhGuqlhNlYurplYnJSUFP/30E96/f4++ffsyF0kJCQlo0qQJrly5gjZt2rAdk3CQgYEBPn78CD8/P7Rv3x4yMjJC+1RM9+eaBw8eYMSIEXBycsKECROgoaGBN2/e4MiRI9i1axfCw8M5u5DErl278O7dOyxevBhA+Qqlw4YNQ3p6Onr06IHw8HBoamqynLJqHz58QEREBF68eCFykS+uF1LF0R9//AFjY2PIyspWWhCrbMozF9y7dw8+Pj64fPkyMxrVyMiI8yvxchGNzGMPFfMIIXUqLy8PFhYWuHr1KiQlJaGsrIycnByUlpaif//+iIiIgLy8PNsxRUpJScG7d+9gYGAAACgsLISPjw+SkpJgbm6OOXPmsJxQtLKyMsyfPx/bt29Ho0aN0KRJE4HtPB4Pz58/ZyfcD0BOTg6hoaEiVwqMjIyEtbU15xvqZ2VlISEhAdnZ2Rg+fDiUlZVRVFQEGRkZTk7Devv2LXJzc9G2bVuhbSkpKVBWVoaqqioLyWomNDQU8+bNQ58+fWBtbQ0tLS2hUVfVTatkU3p6Ovz9/YUuklxdXaGlpcV2PCH1qd+iOJOXl8dvv/0GCwsLtqPUmomJCczMzODm5ia0be3atbh48SJnpzl37doVTk5OzDnMkCFDkJ6ejpkzZ2LLli0YNGgQp28sXL16FcOHD690dXUutkDZt28fnj9/LjS6Eygf8amrq8vpnnMVqCBGACrmsYmKeYSQOsfn83H27FmhD/9hw4ZxemqcmZkZunfvjvXr1wMon9qxbds2dOnSBffu3UNAQAB+/vlnllMKc3V1xebNm9GjR49KRzvs27ePhWTVc3V1RVZWFkJCQoS22draQkNDA7/88gsLyWque/fu6NSpEw4dOiS0zdbWFklJSfjzzz9ZSFY9Pp+PJUuWYOvWrSguLgaPx8PNmzehr68Pc3Nz9O/fn5MjHmxsbKCsrIygoCChbc7OzsjOzsZvv/3GQrKaqaxAWjGNj4sXp+KsPvRbXLduHV69eoWtW7cKbZs3bx5atGjBjLziKn19fSxbtgw2NjZsR6m1Ro0aISwsrNJ+wCNHjuTsKqqKioo4efIk00dMTU0Np06dgoWFBQ4fPoxly5Zx+oZf7969UVpail27dqFLly4iz3G4pnv37pg2bRrmzp0rtO3XX3/Frl27OHteQMjXFKXU0K+JcO/E+iJL5zZni3nUM48QUud4PB6srKxgZWXFdpRauXv3LlOsKysrw4EDB7Bu3Tq4urrC29sbO3fu5GQxb//+/XB3d4e3tzfbUWrt9OnTIu9cA4C5uTm8vb05X8xbtGgR7Ozs8ObNG0yaNImZinL06FFcvHhRZKGSK9auXYtt27bBw8MDQ4YMQZ8+fZhtw4cPR0hICCeLeVeuXMH27dtFbjMzM+PsKNoKMTExbEf418RpNGd96Le4b98+LFy4UOS27t2745dffuF8MW/NmjVYunQp+vTpI3ajHxUVFREVFSWymHfhwgXOLBQkSllZGfM3eeXKFfB4PBgbGwMAWrRogczMTBbTVe/hw4f47bff0LNnT7aj1Njjx4/RqVMnkds6dOjA+YW9xFF9W02YEICKeYQQUmPv379nmkH/+eefyM3NxdixYwGUN33nalFJQkJCoIm7OElLS6v0oq558+ZIS0ur40S1N2XKFBQUFMDDwwPTp09nHtfQ0EBgYCAmTZrEYrqq7d69Gx4eHli2bJnQaKTWrVtz9oIjNze30otnBQUFZGdn13Gi2jEyMmI7wjerbDSnsrIyRo4cycnRnF9OZ7O3t2cvyL/w4sWLSnsR6unpcXpkVYWhQ4ciNjYWbdq0Qdu2bYVWJ+XxeIiLi2MpXdUcHR2xdu1a5Ofnw8bGhumZ99tvv2Hnzp1Yvnw52xEr1aZNG5w9exYmJiY4evQoDA0N0bBhQwDA69evoayszHLCqrVs2RKfPn1iO0atSElJISsrS+Q2ceqhGxcXhyNHjlTaq5BLU8tjYmLg4uICAIiOjq52NWFCxAEV8wgh311tpjDxeDyUlJTUYbqa09DQwOPHj9G/f39cuHABrVq1QosWLQAA+fn5kJLi5luqjY0Nzp07h8GDB7MdpdaUlJTw+PFjkcWNx4++xZ0uAABU8UlEQVQfc7a/4tecnJwwffp0JCcnM1PL27Vrx7kRSl9LS0urdEU6GRkZzk4ba968OW7cuCHymL9x4wYn+7bVF+I4mtPHx6fG+3K1mX7Dhg0rvbnx6tUrNGjQoI4T1Z6fnx/Wr18PNTU1KCgoQFJSku1INebj4wMej4eAgAAEBgYCKC9sN2rUCMuXL690hDkXLFq0CLa2tggODkZubi6OHz/ObIuJiUHXrl1ZTFc9T09P+Pn5YfDgwZxaYb0qBgYGCAwMxLhx44S2BQYGcnrhiApBQUFwdnaGsrIy2rZtK/Qew7VOXvVtNWFCACrmEULqgIeHB5o3b858La53vEaMGIFly5YhKSkJ+/fvx8yZM5lt9+/fh56eHovpKjds2DC4urri/fv3GDp0qNBoB4C7zfRNTU2xatUqWFlZQUNDg3n8zZs3WLNmDYYMGcJiutqRkJBAhw4d2I5RK82aNUNSUhIGDRoktO3u3bvQ1dVlIVX1xo4di7Vr16Jbt26wtLRkHj979iz8/Pzg7OzMYrrqVfX3KCEhAUVFRfTs2RPTpk0T+LvgAnEczSmq0FLRn1DU41ws5g0YMAAbNmzA2LFjBS6qP336BH9/fwwYMIDFdDUTEBCAmTNnYtu2bWJVyAPK/y59fX2xcOFC3Lt3DxkZGdDS0kLXrl05PcUWACZNmoSWLVvixo0b6N27t8BIfg0NDYwYMYLFdKLZ2dkJfP/mzRvo6uqiX79+QiMJeTwegoOD6zJetVasWAFTU1P06dMH06dPR7NmzZCWlobdu3fj9u3biIqKYjtitfz9/TFp0iTs3btXLPoUku+sjFvF2x8FLYBBCCE19PHjR8yfPx8JCQno3bs3tm3bxkxFMTQ0hJGREdauXctySmHi3Ew/NTUVvXv3xqdPn2BlZcVMrQ0PD4esrCwSEhI4W1D60ocPHxAREVHpVBQuFgcAYOnSpdi7dy9OnTqFvn37QlpaGrdu3UKjRo1gYmICJycneHh4sB1TSEFBAUxNTXHjxg1oamoyF0oZGRno27cvoqKimL9dLho0aBBSUlKQnp4OXV1dZsres2fPoKWlBQ0NDTx8+BDy8vKIi4tDx44d2Y7MaNCgAc6fP49BgwahtLQU0tLSSExMhL6+PqKjo2Fpacm51Zu/fv8rKSmBnJwcbty4AX19faH9uVhounv3LgwNDaGqqoopU6Ywx/zBgweRnZ2Nq1evolu3bmzHrJKCggJOnTrF2ZtLhDt0dHRqfGOYx+Ph6dOn3zlR7YWFhWH+/PkCU+B1dHQQEBDAyQLq1xo1aoTTp0+L5ayP+rKaMFcoSqmhn4I12zG+myy9Pzm7AAYV8wghdSIvLw/Xrl3D58+fYWxsDHl5eSQnJ8PLywv37t2Duro65s6di9GjR7Mdtd6pSY8hLvfoSk1NhYeHB6KiopCdnQ1VVVWYmZnB29sb2trabMer1tWrVzF8+HC8e/dO5HYuF1MLCwthZmaGa9euQVtbG6mpqdDT08PLly9haGiIyMhIzt6R//z5M0JCQoSOmylTpnB2SnyFM2fOYP78+Th+/LhAMenWrVsYN24cNm7ciJ49e8LMzAzt2rVDaGgoi2kF6enpwdXVFXPnzhUq5m3atAm7du3CgwcP2I5Zpa9zi4s//vgDixYtwrVr15hFDfr3749ffvkFvXr1YjtetcaPH4+uXbtixYoVbEf5JmlpafD390d8fDxycnJw+vRpdO7cGQEBAejXr5/AlHOuKSgowN69exEXF8e0ghg0aBAcHBwgJyfHdrwqZWVlQV5eHrKysmxH+SbJycnMZ1Tbtm3ZjlNjAwcOhK2tLWbMmMF2lFqj1YT/W1TMYw8V8wgh311KSgpMTU2RlpYGPp8PTU1NnDlzBsOGDQOfz4eenh6ePHmC3NxcREZGilwNjhBx1bt3b5SWlmLXrl3o0qULZ4tflSktLcXhw4cRGRmJzMxMqKioYOjQoZg8eTLni2Liqlu3bkwfq68dOHAAGzZswP3797Fv3z4sWrSIUwt6iOtozi+JazGvQmFhIXJzc6GkpMT5QsyXrl+/Dnt7e9jZ2VXaEoKr7Sz++usvDBgwAJKSkujXrx/Onj2LmzdvQl9fH66urnjz5g0OHz7MdkyRMjIyYGxsjJSUFGhra0NTUxMZGRl4/vw52rVrh9jYWM5N5y8rK4OPjw82b96MDx8+QFJSEsOHD8eePXvQpEkTtuP9EO7cuYPJkydjx44dYrfImry8PE6fPi1yFHBMTAxGjhyJDx8+sJBMPFExjz10Fk4I+e7c3d0hKyuLCxcuoHHjxli+fDmsra3Ro0cPhIWFQVZWFgUFBbCysoKfnx9ni3nVTf3h2spdX8vKykJCQgKys7MxfPhwKCsro6ioCDIyMpxfiKHC+/fv8ffff0NTU5Ppw8h1Dx8+xG+//YaePXuyHeWbSEpKwtbWVmRhSVxERETgwYMHaNq0KaytrTk9xRYovwGipqYmcpuamhoeP34MAGjVqhXnFiHx8vLCtWvXMHDgQGbkrI2NDTOa083NjeWE9Z+cnBzk5OSQlZUFKSkpSEtLsx2pRn766ScA5ecMlRV8uTqKeeHChejQoQMiIyMhKysrcNPG0NAQS5cuZTFd1ZYsWYLc3FxcvnyZ+W8AANeuXcOYMWOwdOlS7N+/n72AIuzYsQM+Pj4wNjZG79698fTpU4SGhkJBQQH79u1jO55IT548wYMHDzB8+HCBx6Ojo+Hm5oYHDx5AS0sLixcvhpOTE0spq9aiRQuB6c3v37/HoEGD0LBhQ5GrT3N1Fe36spowp9D4MFZQMY8Q8t1dvXqVWWkMALZu3YpOnTrh119/ZaZFNGzYEHPnzuV0Y/qysjKhHi3Z2dlITk6GmpoaZ6dH8Pl8LFmyBFu3bkVxcTF4PB5u3rwJZWVljBw5Ev379+dUz7bIyEjExMTAz89P4PHVq1fDx8eHWe14/PjxOHDgAOdHh7Vs2RKfPn1iO0a9t3XrVpw6dUqgoM7n82FhYYELFy4wixm0adMGV65cqbRYxgU6OjrYtWsXhg4dKrRt586d0NHRAVBeoFdRUanjdFWTk5NDbGwsM5qzdevWUFFRgbu7O43m/I8lJibixo0b+PnnnwUeP3jwIBYsWIDs7GzIyclh3rx5WLNmDUspa27v3r1iu0DWlStXcOTIEcjLywsVHDU0NJCRkcFSsuqdO3cO69atEyjkAeVFyFWrVnGyAL9r1y7MmDEDQUFBzGNBQUGYM2cOgoKCODkC3tfXF3///bdAMS85ORlWVlaQlJSEubk5UlJS4OzsDDU1NYwaNYrFtKINHjxYbP9Gv1QfVhMmBKBiHiGkDmRkZKBVq1bM9xVfN23aVGA/LS0tTt8Ri42NFfn4kydPYG1tjeXLl9dtoBpau3Yttm3bBg8PDwwZMkSgb8/w4cMREhLCqWJeYGCg0MliVFQU3N3d0aVLF0yfPh0PHz5EUFAQevbsiYULF7KUtGY8PT2ZYraCggLbcWqluLgYa9euxZEjR/DixQuhoiSPx2OKq2wLDQ1F+/btBR7bs2cPIiMjMWXKFCxevBgPHz7EzJkzsWrVKmzevJmlpNXz8PDAlClT0LVrV4wZMwbq6urIzMzEyZMnkZSUxEzXu3jxIif7cFWM5pw8ebLA41y9CPy6OX5FMSYtLU3klD2uTPX09/dHdna2QDHv5s2bsLe3h6amJubPn4+HDx9i3bp1aNWqFaZNm8Zi2urZ29uzHeGbVTW6PSsri9PTnfPz84XOxyo0b94c+fn5dZyoek+fPsUvv/wi8Nj48ePh7OyM58+fo02bNiwlq9yNGzcwc+ZMgce2bduG4uJiXLt2DQYGBigrK8PQoUOxbds2ThbzuDZC81vVh9WECQGomEcIqQNlZWUCq/9VfP31hR1XL/Sq06pVK7i5uWHx4sWcbJi7e/dueHh4YNmyZUIjBlq3bo0nT56wlEy0P//8U6i4uG/fPsjKyiIyMhKamprM44cPH+Z8MS88PBxv3ryBrq4u+vXrB2VlZYHtPB4PwcHBLKWr2uLFi7F9+3YMGzYMo0ePRoMGDdiOVKlHjx5h+vTpAo8dP34cysrK2L17N2RkZNClSxc8fvwY+/bt43Qxb+LEiVBVVYWnpyfWrFmDz58/Q1paGr169cKFCxeYVgQbN27kxMqqGRkZmDZtGsaPHw87OzsA5QWxr0fHyMvLIyUlhXP9t1q3bi3y88fa2lrk/lyZ6nnz5k2h97+goCBISEggNjYWrVu3BgBMmDABe/fu5Xwxr0JZWRkePHiA7Oxs9OrVC40aNWI7UrUMDAywb98+oSmUAPDbb78JjXrjknbt2iEkJETkSOCDBw8K3SThgvz8fKGbY40bNwZQvuAaF71+/RodOnQQeOzcuXPo0aMHDAwMAJQXhadPn87pWSr1gZGREU6cOIH58+cLFFh1dHRw8uRJGBsbsxeOkFqgYh4hpE6kpaUxox8qG/Xw6tUrNqL9J9TU1JCSksJ2DJHS0tLQt29fkdtkZGQ413MrMzNTYCQnUD4yr3///gKFPEtLS4SEhNR1vFq7cuUKeDweFBQU8Ndffwlt53IR+8SJE/D29haL1SVzcnIE+iiWlpbiypUrsLCwECgqGRgYwNfXl42ItTJkyBAMGTIEZWVlyMrKgqqqqtDoH66s3vjrr7/i9u3bOHHihMDjfD4fM2bMQNOmTcHn83Hs2DEEBgbC09OTpaSicbXHVnUyMjKE2jucP38effr0YQp5QHlxeOrUqXUd75ts374d3t7eyMrKYlpC6Ovrw9raGiYmJpg3bx7bEUVyd3eHqakpzMzMMGnSJPB4PFy8eBGbN29GaGgo4uPj2Y5YqUWLFsHOzg5v3rzBpEmToKWlhYyMDBw9ehQXL17k7Ofsl+eVQNUjarkwmpbP5wvcfMnMzMTTp0+FjummTZtycjTk11xdXZGVlSXy+LC1tYWGhobQ6EkuGTlyJEaOHCm2qwkTAlAxjxBSR8aOHSv02NejHvh8PqcLG5XJzs7Gxo0bhQpQXNGsWTMkJSVh0KBBQtvu3r0LXV1dFlJVrnHjxgIFxr///hvZ2dlCBUkFBQXOjJCpyrNnz9iO8M3y8/PRr18/tmPUyNd9qW7fvo3CwkKh/JKSkpzsp1SZgoICfPr0CQUFBZCXl2c7jkjnz5/HjBkzhKYS8ng8zJw5k1kRVk1NDQcOHOBcMU9cCl1fk5GRwefPn5nvX758idevX2PSpEkC+6moqKCoqKiu49Xarl274OLiAkdHR5iZmQn0sxowYABOnjzJ2WKekZERTp06xeQHADc3N+jo6ODUqVOcnA5fYcqUKSgoKICHh4fA6GYNDQ0EBgYKHU9cIeq8EhA9opYL5wp6enq4ceMGM7I6KioKPB5P6NwsMzMTqqqqbESsldOnT8PLy0vkNnNzc3h7e3O6mFehXbt2bEcQf3w+UFbGdoofEhXzCCHfnbiOeviarq6uULGxuLgYb968AQCcPHmSjVjVsrGxgY+PD/T19ZmCGI/HQ0pKCvz9/Tm3alr79u0RFhYGS0tLAEBYWBh4PB7MzMwE9nv27BnnpuvVN8OHD0d8fHy1KzlzQe/evbFjxw6MHj0aUlJSTDN9CwsLgf2SkpIq7Q/FJZGRkVixYgXu3LnD3OjQ19fH6tWrMWTIELbjCUhOToaPj4/Q4/yvVrdr27YtkpOT6ypWvdemTRvExMQw0yMjIiLA4/GEVoR/9eoV1NXV2YhYKxs3bsTChQuxbt06oeJL+/btsWHDBpaS1YylpSUsLS3x+PFjZGZmQkVFRWwKBU5OTpg+fTqSk5ORk5MDZWVltGvXjrMr3YvjeeXUqVPh6ekJRUVFaGhowN3dHaqqqkLnNrGxsZzs+fe1tLQ0tGzZUuS25s2bIy0trY4T1c79+/fh7e2NuLg45ObmQklJCYMGDWL6MxMiDqiYRwj57sR11MPXjIyMhIp5srKy0NbWho2NDWdH5nl5eeHatWsYOHAgtLW1AZQX+F6+fAlDQ0POrVTn6uqK0aNHIycnBxoaGti/fz+6dOki1HMoIiIC3bp1Yyll7RQUFGDv3r2Ii4tjLpQGDRoEBwcHTjdGnzt3Luzs7CAhIQELCwuhfn8AN6YvAcDKlSvRr18/tGzZEkpKSnj48CFGjRol1O/p5MmTlU4754rIyEhYWlqidevWcHd3h6amJtLT03Hs2DFYWFggIiKCUwW9oqIioVGDkpKSSE9PFxhhIisrKxYjxMTFrFmz4OTkhNLSUmhoaGDDhg3Q1tYWGulz8eJFdOzYkaWUNffs2TOYm5uL3NaoUSO8e/eubgNVIzo6usrtaWlpAgUNrt8UkZCQEOrpxlXieF75888/4/Lly8zoUgUFBRw6dEjgHKCgoABHjhyBi4sLWzFrTElJCY8fP4aRkZHQtsePH3N2JDlQ3m/UyMgIcnJyGDFiBDQ1NZGRkYEzZ87g7NmziI+PR8+ePdmOSUi1ePyvb5sSQgipd0pLS3H48GFERkYyIwaGDh2KyZMnQ0qKe/d1tmzZAn9/f+Tk5MDAwACBgYECd6ozMjLQuXNnrFmzhnMjC7+WkZEBY2NjpKSkQFtbmzlpfP78Odq1a4fY2FjOjjD8clRGZVPguTB9qcLNmzexdetW5ObmwsDAAIsXLxboK5eRkQEnJyfMnTuXU8Wwr/Xr1w9KSkoIDw8X+G9QVlYGKysrvHv3DteuXWMxoaAWLVpg9erVzOIXlTlw4ABWrFiBly9f1lGy+o3P52PhwoX49ddfUVxcDF1dXRw+fFhgSmdOTg60tbXh5eXF+cWCmjdvDh8fHzg6OqK0tBTS0tJITEyEvr4+goKCsH79ek4t2CQhIcG8L359OcXj8ZgRtRX/y6X3ygMHDtRq/+r+tknNPXv2DDk5OWjfvr3Q4i75+flITk5G69atoaioyFLCmrG1tcWVK1eQkJAgcA7z5s0b9OvXD/369cOhQ4dYTFg5U1NTfPjwAZcuXWIWTgHKF08xNTWFoqIiLly4wGJC8aIoqYp+8iPYjvHdZLW5h8TERLZjiETFPEIIqUZeXh6uXbuGz58/w9jYGPLy8khOToaXlxfu3bsHdXV1zJ07F6NHj2Y7KuEgOzs7REZG4vfffxcYXXjt2jWMGTMG5ubm2L9/P3sBq7B///5q+1iK4wgJrmvYsCGOHz/OTDX/Unh4OMaNG4eCggIWkok2ceJEZGVlISoqqsr9TE1NoaqqiqNHj9ZRsh9DUVERPn78CBUVFaFtJSUleP/+PRQUFCAtLc1CupqbNWsWzp8/j+joaGhra0NaWhq3bt1CixYt0L9/f1haWsLf35/tmAwJCQkoKChgzJgxGDNmTLWr7ooawcSW2kyf5VohknBDamoqevfujU+fPsHKyoqZWhseHg5ZWVkkJCRwridzBXl5eYSEhGDUqFFC237//XdMnTqVs6sic5GipCr6NRJeybu+yGp7n7PFPO4NxyCEEA5JSUmBqakp0tLSwOfzoampiTNnzmDYsGHg8/nQ09PD/fv3YWNjg8jISKFeRYScO3cO69atE5ombGhoiFWrVnFumvOX7O3t2Y7wQ2rQoAE+fPggclteXh4aNGhQx4mqNm/ePPTv3x+LFi2Cn5+f0GjfkpISLFmyBLGxsbh8+TJLKesvWVnZSlc2lpKSElnk46JVq1YhJiYGnTt3Rp8+fcDj8TBv3jw8evQI6urq8PDwYDuigNjYWAQHB+PEiRM4fvw4Ro0ahalTp3J+Oi0g3gszEW7Q0dHBzZs34eHhgaioKGZF2FGjRsHb25tp68JF1d2kFMfF+MiPiUbmEUJIFcaPH48///wTO3bsQOPGjbF8+XIkJyejY8eOCAsLg6ysLAoKCmBlZQUJCQlcvHiR7chCiouLsXbtWhw5cgQvXrzAp0+fBLbzeDyUlJSwlK7+k5OTQ2hoKNOk/kuRkZGwtrZGYWEhC8kIV40aNQr3799HVFSUwMiGFy9eYMiQIejUqRN+//13FhMK8/f3x5IlS6CmpoYhQ4YwjdFfvHiBqKgoZGVlYe3atVi8eDHLSQmX5eXlISAgQKglhKurKxQUFNiOJ1JRURF+//13hISE4OLFi9DS0sLkyZNhZ2cnNj3oCPmRmJqa4v3794iOjhaYZvvx40eYmJjQNNtaopF57KFiHiGEVKF58+bw8/PDlClTAAAPHz5Ep06dEBYWhuHD//ngCg0NhbOzMzIyMtiKWikXFxds374dw4YNQ5cuXUSO6vH09GQh2Y+he/fu6NSpk8jeMba2tkhKSsKff/7JQjLRHB0d4e7uDl1dXTg6Ola5L4/Hw549e+oo2Y8jJSUFP/30E96/f4++fftCS0sLGRkZSEhIQJMmTXDlyhVOrnYYExODdevWIT4+nlnoQlZWFgMHDsSSJUvEYsQSIf9Geno6Dh8+jAMHDiApKQnOzs7Ytm0b27EI+c/t3LkTkydPrnZ6ORf98ccfMDY2hqysLKysrJjP2IiICBQUFCA2Nha9e/dmO6bYoGIee2iaLSGEVCEjI0NgldqKr5s2bSqwn5aWFt6+fVun2WrqxIkT8Pb2xooVK9iO8kNatGgR7Ozs8ObNG0yaNIk5aTx69CguXryIkJAQtiMKiImJYVbSi46OrnK6CU1F+T7atm2Le/fuwd/fH5cvX8bt27ehrKwMFxcXuLq6QktLi+2IIg0aNAiDBg1CaWkpsrOzAQAqKiqQlJRkORkhdUNFRQU6OjrQ0dHBX3/9hdzcXLYjiaSnp4fQ0FB069YNurq61b7Pc2nhEcINzs7OWLx4MaZMmQInJyd069aN7Ug1ZmBggISEBPj4+CAyMhI5OTlQVlbGoEGD4O7uji5durAdUezwy8rYjvBDomIeIYRUoaysTOBCtOLrr098uVzUyM/PR79+/diO8cOaMmUKCgoK4OHhgenTpzOPa2hoIDAwEJMmTWIxnbAveymlpqayF+QHp6WlhV9++YXtGN9EUlIS6urqbMcgYig4OJhpCVExurMCl4tKV69eRUhICI4fP45Pnz5h5MiROHv2LGdXzTYyMmKmLRsZGXH6HIZw05MnTxAUFIT9+/cjMDAQBgYGmDVrFsaPH19pD08u6dq1K06cOMF2DEL+FZpmSwghVZCQkMDJkyeZO46lpaVo164dwsLC0KlTJ2a/P//8E+PGjePkim9TpkxB69at4eXlxXaUWikuLkbfvn3h5+cHMzMztuP8a2VlZUhOTmbuALdr165WKwqSH09WVhYSEhKQnZ2N4cOHQ1lZGUVFRZCRkaFjh9Q7vr6+8PT0ROfOndG5c2eRLSH27dvHQjLRHj9+jJCQEBw8eBCpqakYOHAg7OzsYGNjA3l5ebbjEY558eJFrfav6DvKdSUlJQgNDUVgYCBiY2PRpEkT2NnZwcnJSWx6Rr5//x5///03NDU10bx5c7bjiB1FSVX0lbNkO8Z3k93+L85Os6ViHiGEVEFCQkLojjWfz6/0Ma4U854+fcp8/fbtW9jZ2WHy5MmwsLCAsrKy0P56enp1Ga/GlJSUcPLkSeq1xZKqLj4kJCSgqKgo0DyaTdX19/sS13v98fl8LFmyBFu3bkVxcTF4PB5u3rwJfX19mJubo3///nB3d2c7JuGQsLAw5OTkwMHBAQDw/PlzTJgwAUlJSTA3N8f+/fs5X2DS0dHBqFGjsGnTJraj1IiEhAQUFBQwevRo2NraVrt6J1c/Z0ndEHU+WRWunE/WxuPHjzF9+nRm1fL+/ftjyZIlsLRkv9ATGRmJmJgY+Pn5CTy+evVq+Pj4MAvBjR8/HgcOHBBalZ1Ujop57KGjlBBCqsClUQC10bp1a4GTRj6fDy8vL3h7ewvsx7Ui5NeGDBmCCxcuiHUxz9XVFVlZWSJ749na2kJTUxMbNmxgIVn1dHR0qr340NPTw5IlSzBjxow6SiVadf39vsT1KWVr167Ftm3b4OHhgSFDhqBPnz7MtuHDhyMkJISKeUTAqlWrYGNjw3y/YMECvHr1Ck5OTggJCYGXlxfnp21XjEAVJx8+fMD+/fsRHBxc7b5c/ZwFyn+PiIiISqc30/vNv7d3717Of/Z8q7y8PISEhCAoKAj3799Hjx49YGNjgzNnzmDEiBFYsWIFfHx8WM0YGBgo9PpHRUUxPfKmT5+Ohw8fIigoCD179sTChQtZSkpIzVExjxBCqjB16lS2I3yT+nLSOHfuXEyZMgUlJSWwtraGlpaW0O/F9dEOp0+frnSKs7m5Oby9vTlbzAsMDMSaNWvQpEkTjBkzBhoaGsjIyMDJkyfx/v17zJ49G/Hx8Zg1axakpaVhb2/PWtb61N9v9+7d8PDwwLJly4QKAK1bt+Zs3zDCnidPnqBr164AgMLCQkRERODAgQOwsbFBhw4dsHbtWs4X84yMjHD37l2xuXkjrjf7vnb16lUMHz4c7969E7mdinn/DTY/H7+XxMREBAUF4ejRoygpKcG4ceOwc+dO5gaUm5sbfH19ERAQwHox788//xQ6jvft2wdZWVlERkZCU1OTefzw4cNUzKsVPkCTPVlBxTxCCKmH7OzscPbsWejq6qJz584i97l//z5SU1M5PRLCyMgIALBx48ZKp15xebQDAKSlpVXa+6Z58+ZIS0ur40Q1l5KSgl69egk1ifbw8MCYMWOQkZGB8PBw2NraYvPmzfXyYoUNaWlp6Nu3r8htMjIy+PjxYx0nIlxXVFQEOTk5AMC1a9dQUlLC9Bpt164dXr9+zWa8SpV9sQJiQEAARo8eDRUVlUpbQnCpV6S43uz72vz586Gjo4Ndu3ahS5cukJGRYTsSEQP6+vq4e/cudHV14eHhgWnTpon8mx0yZAg8PT1ZSCgoMzMTrVq1EngsKioK/fv3FyjkWVpaipxJQQgXUTGPEELqoYMHD2L27Nm4f/9+pfs0btwYkyZNws6dOzFx4sQ6TFdz9WHkg5KSEh4/fswUJr/0+PFjTvexOnjwIPbv3y9y2/Tp02Fvb4+NGzfCxsYGJ0+erNtwNZSZmSk0bQzgdnPxZs2aISkpCYMGDRLaVnHxRMiXdHR0cOXKFRgZGSEsLAw9e/aEoqIigPK/gYqvuUZKSkqoJURF37+v8Xg8pq8V+e88fPgQv/32G3r27Ml2lB9KZmYmjhw5guTkZJFTm7nc1xUovxm5evVqDB06tMqZIPr6+nj27FkdJhOtcePGAjfC/v77b2RnZwvdOFNQUOD8TWJCKlAxjxBC6qGDBw/CwcGhyot+HR0dODo6Ijg4mLPFvPow8sHU1BSrVq2ClZUVNDQ0mMffvHmDNWvWYMiQISymq1peXh6ysrJEbnv79i3y8/MBlJ/8SkpK1mW0KpWVlWHlypUICgqqdOoYl0/WbWxs4OPjA319feZCg8fjISUlBf7+/nBycmI5IeGamTNnYtGiRQgNDcWdO3ewY8cOZtv169fRsWNHFtNVzsPDo160hBBnLVu2xKdPn9iO8UNJTk5Gv379UFJSgo8fP0JVVRU5OTkoLS2FkpISZ4vvXzp9+nSN9pORkal2cZi60L59e4SFhTGLcYSFhYHH4zEjmCs8e/ZM4FyNEC6jYh4hhNRDt2/fxty5c6vdz9TUFIcOHaqDRP9OWVkZHjx4gOzsbPTq1QuNGjViO1KN+fr6onfv3mjTpg2srKyYqbXh4eGQlZXFqlWr2I5YKSMjIyxfvhwdOnQQGLWRmJiIFStWMCPH/v77b06NdAsICMD27duxdOlSrFy5EitWrICEhAQOHToECQkJuLm5sR2xSl5eXrh27RoGDhzIXATZ2Njg5cuXMDQ05Hx+UvdcXFygqqqKhIQEzJs3D3Z2dsy2vLy8Ske7sa2yfqKk7nh6esLPzw+DBw+GgoIC23F+CIsXL0bv3r1x6tQpNGrUCOfOnUPXrl1x4MABeHp6IjQ0lO2I1bp27RpycnJgZWUFoHwBmzlz5jAraK9bt45TN/lcXV0xevRo5OTkQENDA/v370eXLl3w008/CewXERGBbt26sZRSTPEBlFHPPDbw+HzqVkgIIfVNgwYNcOnSJfTv37/K/a5cuYLBgwdz+q789u3b4e3tjaysLPB4PNy8eRP6+vqwtraGiYkJ5s2bx3bEaqWmpsLDwwNRUVHIzs6GqqoqzMzM4O3tzYk71pV59uwZTE1NkZqaipYtW0JdXR2ZmZl48eIFdHV1ERUVBV1dXWzatAkNGjTA7Nmz2Y4MAOjSpQvs7e0xf/58SEtLIzExEfr6+vj8+TPMzMxgZGTE+SJCaWkpDh8+jMjISGRmZkJFRQVDhw7F5MmTISVF92JJ/ePo6Ah3d3eRI8qfP38Ob29v7N27l4Vk9c+XxV4AiI+PR15eHvr16yfU94zH49VotV5Sc1paWggMDMTw4cMhJSWFP/74A7169QIArFu3DufPn0dMTAzLKas2YMAAmJqaMv3wHB0dcfLkSZiamuL8+fNwc3Pj3MIpW7Zsgb+/P3JycmBgYIDAwEC0adOG2Z6RkYHOnTtjzZo1NAK+FhQlVNC3gQXbMb6b7E4PkZiYyHYMkaiYRwgh9VCzZs2wfv16TJ48ucr9Dh8+jMWLF3N2EYZdu3bB2dkZjo6OMDMzw7hx45jCjL+/P06fPo24uDi2Y36zsrIyvHv3TmTTaK74/Pkz9u3bhxs3biA9PR1aWlro27cv7O3tIS0tzXY8kRo1aoSIiAgYGRlBRkYGMTExzN33sLAwzJ07Fy9evGA5Zc18uUAAUH5hTdMSSX0kISGBhIQEGBgYCG27desWDAwMOD09Xpzo6OjU+H2Ex+Ph6dOn3znRj6Vx48aIiIjAgAEDoKSkhCNHjmDo0KEAgOjoaIwYMYJpY8FVampq2L9/PywtLfH582eoqKggICAAjo6OCAgIQFBQEB4+fMh2TFIHqJjHHrq1Swgh9VD//v0RHBxcbTFv//791Y7eY9PGjRuxcOFCrFu3Tugirn379tiwYQNLyaqmrKyMixcvQl9fH0B5U/eRI0ciICAAenp6zH43b96EoaEhpy9QpaWl4eTkJFZ3qRUVFZmG4k2bNkVycjJTzCspKUFOTg6b8UTKyMjAtGnTMH78eGbUTGlpqdDKkvLy8khJSaGePgQSEhK1KsiIw+IRlf0+GRkZzGq95N9LTU1lvs7KyoK8vDxkZWXZC/SD0dHRQUZGBoDy1aaPHz/OFPPCw8PRpEkTFtPVTH5+PjMt+48//sDHjx+ZKbf6+vpic8OMEHFGxTxCCKmH5s+fj/79+8PV1RXr1q0TKgh8/vwZixcvRnR0NK5cucJSyuo9e/YM5ubmIrc1atSo0sUN2Pbu3TuBC+eysjKEh4dzfmpnfdGjRw88ePAA5ubmMDc3h6enJ+Tk5CAlJYUVK1YwRVYu+fXXX3H79m2cOHFC4HE+n48ZM2agadOm4PP5OHbsGAIDA5mpTeTHVR8WjwgNDRXoD+bp6QlVVVWBfQoLC3H58mVabfU/VFZWBh8fH2zevBkfPnyApKQkhg8fjj179ohFIUncDRkyBFFRUbCxscGCBQswYcIEXLlyBVJSUnj06BFWrFjBdsRqNWvWDHfv3sWAAQNw7tw5dO7cGerq6gCA3NxcNGzYkOWEhNR/VMwjhJB6qF+/fvD398fChQtx6NAhmJmZMb3Znj9/zvRu8/f3Z1bL5CJVVVWBEQRfSk5ORrNmzeo20A+muLgYa9euxZEjR/DixQuh3opcHe0zf/58ZlqYt7c3bt++zYxS1dbWxrZt29iMJ9L58+cxY8YModFHPB4PM2fOZAqQampqTJN08mOrDzcHXrx4gcuXLwMoP9bv3LmDBg0aCOzToEEDGBoaYu3atWxErJd27NgBHx8fGBsbo3fv3nj69ClCQ0OhoKCAffv2sR2v3lu7di3zeTpu3DjIycnh2LFjKCgogIuLC2bMmMFywupNnDgRy5YtQ2xsLCIiIuDt7c1su337tkAvOvID4JdVvw/5z1ExjxBC6qn58+dDX18f69atQ2hoKAoLCwEAcnJyMDY2hpubGwYMGMByyqpZWVkxFxwVxUgej4esrCxs2rQJ1tbW7Aas5xYvXozt27dj2LBhGD16tNBFNlcNGTKE+VpTUxN//PEHnjx5goKCAnTo0IGTvf6Sk5Ph4+Mj9PjXrY3btm2L5OTkuopFyHfl4uICFxcXAICuri5OnTpFK0nWgV27dmHGjBkICgpiHgsKCsKcOXMQFBQkNJqf/LcaNGgg8Hk6fPhwDB8+nMVEtefi4gI5OTlcv34dbm5uWLBgAbPt7t27sLGxYTEdIT8GKuYRQkg9NnDgQAwcOBBlZWXIysoCAKioqEBSUpLlZDWzatUqxMTEoHPnzujTpw94PB7mzZuHR48eQV1dHR4eHmxHrNdOnDgBb29vsZjy86UDBw7A0tISKioqAMoLwK1btwYA5OTkIDw8XGg1R7YVFRVBXl5e4DFJSUmkp6cLTDuUlZVl+gES8qXi4mKcO3cOycnJQscIj8fj3MqSX3v27BnbEX4YT58+xS+//CLw2Pjx4+Hs7Iznz5/TqKrvLCUlBenp6TAyMhLaFh8fDy0tLU7+NygtLYWvr6/A9GwrKyvMmzdP4Lzy1KlT7IUk5AdCxTxCCPkBSEhIML1MxImqqioSExMREBCAyMhItGrVCiUlJZgzZw5cXV2Z5stclJaWxkz1rFjgIi0tTaAf0atXr9iIVmP5+fno168f2zFqzcHBAdevX2eKeV969uwZHBwcOFfMU1dXx9OnT4UWpPl6oYtnz55BTU2tLqMRMfD69Wv0798fqamp4PF4zIjOL3vqcb2YVyE3Nxd///23yKL1wIEDWUhU/3y5eEGFxo0bAwDy8vLYiPRDmT9/Pjp27CiymBceHo4HDx4gPDychWRVCwwMFDk929XVlaZnE8ICKuYRQgjhtMaNG8Pd3V1sLkQrjB07Vuixr6cF8/l8TjewHz58OOLj42FiYsJ2lFr5emrqlz5+/AgpKe6d/vTv3x8hISHVFhkPHDjArMxLSIXFixdDTU0N8fHxaNmyJW7cuAE1NTXs3bsXx44dw4ULF9iOWK2ioiI4Ojrit99+q/RvmMsrf4ubL284AZXfdAIgsAo7+fcSExMxa9YskdsGDhyI4ODgOk5UMzQ9m4jCB8Avq/y8i3w/3DubJYQQQv5PT08PoaGhInsoJSUlYcSIEQIXI1xRX+5Qz507F3Z2dpCQkICFhQWUlZWF9uHKRd6dO3dw+/Zt5vszZ84gKSlJYJ/CwkIcPXqUk9OX5s2bh/79+2PRokXw8/MTKjiWlJRgyZIliI2NZRYMIKTC5cuX8csvv6Bp06YAykdj6+jowMfHB6WlpZg3bx7CwsJYTlk1X19fxMbGIjg4GLa2tti+fTtkZWWxf/9+pKenY/PmzWxHrFdE3XAChG86AVRE/a/l5eVBVlZW5DZpaWm8f/++jhPVDE3PJoRbqJhHCCGEs1JTU4VWUK1QVFSE58+f13Gimpk6dSrbEf4TFVNsvby8BFaq+xJXLvLCwsKYjDweD6tXrxa5n4qKCvbs2VOX0WqkX79+WL9+PZYsWYKDBw9iyJAhaNmyJYDyFT+joqKQlZWFtWvXiuXUZ/J9ZWdno2nTppCQkECjRo2Qm5vLbDMxMeHkCs5fO3nyJDw8PDBhwgTY2tqiT58+0NfXh4ODA2xsbHD+/HkMGzaM7Zj1Qn254SSu9PT0cOnSJZiZmQlti46Oho6OTt2HqgGank0It1AxjxBCCKdVNg01MTFRaCoQ+W/t3buX09OAvzR//nzY29uDz+dDT08Pv//+O3r06CGwT4MGDaChocHZ32nhwoXMCtQnT55keobJyspi4MCBWLJkidhNeSZ1o3nz5swiR61atcKFCxdgamoKAPjjjz8qHQXEJS9evECnTp0gKSkJaWlpfPz4kdnm6OgIBwcHGp33H6kvN5zElZ2dHdzd3dGyZUtMnz4dDRo0wKdPn7B7924EBATAy8uL7YiVounZhHAHFfMIIYRwyqZNm7Bp0yYA5YW84cOHC/VhKSwsRE5ODiZMmMBGxB+Gvb19pdtKS0s5NRVIUVERioqKAMoXidDS0hLL/j2DBg3CoEGDUFpaiuzsbADitQI1YcegQYMQFxcHa2trzJw5Ez///DPu3LkDaWlpREZGYubMmWxHrJaKigry8/MBAC1atMDdu3cxYMAAAEBWVhYKCwvZjEfIf2bRokW4efMm5s6dCxcXFygrKyMnJwdlZWUYM2YMli5dynbEStH0bCKEzwf4ZWyn+CFRMY8QQgin6OnpYfDgwQCA4OBg9OrVS2j1zgYNGqBjx46YPn06GxHrNWVlZVy8eBH6+voAyheTGDlyJAICAgTusicmJsLQ0JCTJ+va2trM15mZmSJXxayYwspVkpKSYrkCNWHHqlWrkJOTAwBwdnZGSUkJjh07hoKCAixZsgQeHh4sJ6xe37598eeff2LYsGEYM2YM3N3dkZeXBykpKfj7+wut9EyIuJKUlMSJEycQHR2NqKgoZGdnQ1VVFWZmZjA2NmY7XqVoejYh3MLjV7XkGyGEEMIiBwcHeHh4QFdXl+0oPwwJCQkkJCTAwMAAQPmddWlpaSQmJjIFPgC4ceMGZ4t5Hz58gIuLC44dO1Zpz0Uu5ibkR5aYmIgXL15g9OjRyMvLg729PU6fPo3S0lL07dsXR48e5XwRnhBCfjQKPGX0lRLu/1hf5HR7jMTERLZjiEQj8wghhHAW3QUm3+Lnn3/GyZMnMW3aNHTp0gUNGjRgOxIhpBq9evVCr169AJQ31T958iQ+ffqET58+CTXdJ4QQQn50VMwjhBDCWT4+PlVu5/F4cHd3r6M0RFycP38eGzZswM8//8x2FEK+G0dHR7i7u0NXVxeOjo5V7svj8Ti5inN0dHSt9qcFYIi4kpSUxPXr12FgYAAJCYkqF2Li8XgoKSmpw3SEEHFExTxCCCGcVdWKbhUnwlTMI6K0a9eO7QiEfFcxMTFwcXEBUF4Uq644wEWmpqZMtso6//B4PPD5fPB4PJoeT8SWh4cHmjdvznzN1b9JQr4Fv4w6t7GBinmEEEI4q6xMeHWsnJwchIeHw9/fH6dOnar7UD+AtLQ0PH36FMA/veXS0tLQpEkTZp9Xr16xEa1GJkyYgDNnzsDU1JTtKIR8N8+ePWO+Tk1NZS/Iv9S4cWOMGTMGY8aMQaNGjdiOQ8h34enpyXxd1Y1KQgipKVoAgxBCiFjatGkToqKiEBERwXaUekXU9J+KUTGiHuPiSJkzZ85g/vz5MDIygoWFBZSVlYX2oel6pL4oLi7G0qVLMWnSJPTu3ZvtOLUSHx+P4OBgnDhxAnw+H6NGjcLUqVPp75PUa19Okf/a8+fP4e3tjb1797KQjJDaU+Apo4/EELZjfDe5PZ5UuwDGy5cv4erqiqioKPD5fJiamiIgIKBGizYVFRXB3d0dBw8exLt379C9e3esW7cOAwcOrPa5VMwjhBAilqKjozFixAjk5+ezHaVeCQ4OrtX+U6dO/U5Jvp2EhITIx2m6HqmvGjZsiPPnz9fo5J+LioqK8PvvvyMkJAQXL16ElpYWJk+eDDs7O3To0IHteIT8p75eNf5Lt27dgoGBAX1GEbHxoxfzCgoK0K1bNzRo0ACrVq0Cj8fDypUrUVBQgHv37lU74nzy5Mk4e/YsNmzYAD09PWzfvh3nzp3D9evX0b179yqfS9NsCSGEiKXw8HCoqamxHaPe4WJxrrZiYmLYjkBInerRowfu378vtsU8WVlZTJo0CZMmTUJ6ejoOHz6MAwcOYP369XB2dsa2bdvYjkjIf6qynnkZGRmQk5Or4zSE/Et84bY4P4pdu3bh6dOnSE5ORuvWrQEAXbt2RZs2bRAUFIQFCxZU+ty7d+/i8OHD2Lt3LxwcHAAARkZG6NSpEzw8PHD69Okq/7+pmEcIIYSzRK3QWFxcjKSkJNy/fx/e3t4spCJcZ2RkxHYEQuqUv78/Jk6cCG1tbVhaWop1c30VFRXo6OhAR0cHf/31F3Jzc9mORMi/FhoaitDQUOZ7T09PqKqqCuxTWFiIy5cvo2fPnnUdjxDyjU6fPo2+ffsyhTwA0NXVxU8//YSwsLAqi3mnT5+GtLQ0xo8fzzwmJSWFCRMmwM/PD58+fUKDBg0qfT4V8wghhHCWqBUaZWVloa2tjfnz59eLUWTk+8nKykJCQgKys7MxfPhwKCsro6ioCDIyMpVOxSVEHNnY2OD9+/cYOXIkpKWloaamJvDeyePx8Pz5cxYTVu/q1asICQnB8ePH8enTJ4wcORJnz57FkCH1d/oW+XG8ePECly9fBlD+93jnzh2hi/QGDRrA0NAQa9euZSMiIeQb/PXXXxg5cqTQ4506dcLx48erfa6uri4aNmwo9Nzi4mI8fvwYnTp1qvT5VMwjhBDCWeK8QiNhD5/Px5IlS7B161YUFxeDx+Ph5s2bUFZWxsiRI9G/f3+4u7uzHZOQ/8zgwYPFcjTe48ePERISgoMHDyI1NRUDBw7EL7/8AhsbG8jLy7Mdj5D/jIuLC1xcXACUj9o5deoUunXrxnIqQsi/lZOTAyUlJaHHlZWVqx1ZXtVzK7ZXhYp5hBBCCKlX1q5di23btsHDwwNDhgxBnz59mG3Dhw9HSEgIFfNIvbJ//362I3yTtm3bQkFBAaNHj8bu3buhra0NAMjMzERmZqbQ/np6enUdkZD/3LNnz9iOQMh/xtDcAFlZ9feYLiwsRK9evZjvnZyc4OTkxGKif1AxjxBCCKe9e/cOmzZtwvXr15GWloZmzZrB0NAQ8+fPR5MmTdiORzho9+7d8PDwwLJly4RWBGzdujWePHnCUjJCyNc+fPiA/fv312glbVrhk4ir+Ph46OvrQ15eHvHx8dXuL66L2ZAfz/nz59mOwColJSWRI/AqG3X39XNFtcCoGJFXMUKvMlTMI4QQwll3796Fqakp3r9/j759+6Jjx4548+YN1qxZg19//RWXLl1Cly5d2I5JOCYtLQ19+/YVuU1GRgYfP36s40SEfH9//vknfH19ER8fj3fv3uGPP/6Avr4+li9fjoEDB2Lo0KFsRxSyb98+tiMQUieMjY2RkJAAAwMDGBsbVzotns/ng8fjUeGaEDHRqVMn/PXXX0KPP3jwAB07dqz2uaGhoSgoKBDom/fgwQPIyMgILKohChXzCCGEcNa8efOgoqKCxMREZvoVUN5Lb+jQoZg7dy5iY2PZC0g4qVmzZkhKSsKgQYOEtt29exe6urospCLk+7ly5QpMTU2hp6eHSZMmYdu2bcw2CQkJBAYGcrKYR4sYkR9FTEwMc2EfExPDchpCyH9lxIgRWLRoEZ4+fcq0gkhNTcXVq1fh5+dX5XOHDx8OT09PHD9+nPk8LCkpwbFjx2BmZlblSrYAwOPz+fz/5tcghBBC/lsNGzZEcHAwbGxshLYdO3YMDg4OKCgoYCEZ4bKlS5di7969OHXqFPr27QtpaWncunULjRo1gomJCZycnODh4cF2TEL+M/3794eKigpOnTqF0tJSyMjIIDExEfr6+vj9998xf/58vHjxgu2YhBBCSL3y8eNHdOvWDXJycli1ahV4PB7c3d2Rl5eHe/fuMYs5PX/+HK1atYKHh4fAOeiECRMQGRmJDRs2QFdXFzt27EB4eDiuXbsGfX39Kv+/Jb7rb0YIIYT8CyoqKpXelZKVlYWKikodJyLiwMvLC+3bt8fAgQPRpk0bAICNjQ26dOmCNm3awM3NjeWEhPy3bt++DWdnZ/B4PKHpe6qqqnj79i1LyQghhJD6q1GjRoiOjkbbtm1ha2uLyZMnQ1dXF9HR0QKrsvP5fJSWlqKsrEzg+fv27YODgwNWrlwJS0tLvHz5EufPn6+2kAfQyDxCCCEctmbNGpw7dw5RUVGQlZVlHi8sLISZmRksLS2pMENEKi0txeHDhxEZGYnMzEyoqKhg6NChmDx5MqSkqMsIqV+UlZWxe/dujB49GqWlpZCWlmZG5h07dgwuLi7IyMhgOyYhPywTE5Ma78vj8XDp0qXvmIYQUh/Q2SwhhBDOKigowPPnz9GyZUtYWFhAQ0MDb968QUREBOTk5PDx40dmqDqPx4O3tzfLiQlXSEpKwtbWFra2tmxHIeS769+/PwICAjBy5EjmsYoRenv27KlVIYEQ8t8rKyurdNGLr9FYG0JITdDIPEIIIZwlIVHzbhC0+hupzNdTGoDaHVuEcN3du3fx008/QUdHB2PHjoWvry/mzp2Lu3fv4tatW7h58ybatWvHdkxCCCGE/EfoTJYQQghnlZWV1fgfFfJIhcLCQri5uaFVq1Zo0KABpKWlBf7JyMiwHZGQ/1S3bt0QHx8PDQ0NrF69Gnw+n1nRNi4ujgp5hBBCSD1DI/MIIYQQUq84ODjg0KFDGD58ONq3by+yeOfp6clCMkK+v6KiIuTk5KBJkyZo2LAh23EIISKkp6fD398fcXFxyMnJgbKyMgYNGoQFCxZAU1OT7XiEEDFAxTxCCCGcx+fzkZ6ejqKiIqFtenp6LCQiXKaiogJPT0/MmzeP7SiE1AlHR0e4u7tDV1dXaNvz58/h7e2NvXv3spCMEPK1lJQUDBgwALm5ufjpp5+gqamJjIwMXLt2DUpKSrh8+TKzEjshhFSGinmEEEI4Kzs7Gz///DNCQ0NRUlIich+aXku+1rRpUwQHB2PIkCFsRyGkTkhISCAhIQEGBgZC227dugUDAwN6rySEI0aNGoWkpCRERUVBR0eHefz58+cwMzNDp06d8Pvvv7MXkBAiFmg1W0IIIZw1bdo0xMTEYM6cOZVOlyTka/b29jh69CgV88gPpbKVMjMyMiAnJ1fHaQghlYmJiUFgYKBAIQ8AtLW14eXlhdmzZ7MTjBAiVqiYRwghhLNiYmKwefNm2Nvbsx2FiBFfX184Ozvjf+3deXTNd+LG8edmkYgkJFGEEmEqmQ4nWoNYQhBRLYqMdkqtZxxlRjHaWqYhS7U1afQYS60V1K5ir6DGNsPQMoYxdewZmUQsiSRkkeT+/nDcX9MkUiT53hvv1zk5J/f7/bj3uZdz5Dz5LKGhoerRo4c8PDyKjRkxYoQByYDyEx8fr/j4eMvj6dOnq3bt2kXGZGdn69ChQ2rVqlVlxwNQiry8PLm5uZV4z83NTXl5eZWcCIAtoswDAFgtT09P1a1b1+gYsDHff/+9tm7dqtTUVO3du7fYfZPJRJkHm5eYmKhDhw5JevBv+p///KecnJyKjHFyclL79u31ySefGBERQAlatmypOXPmqGfPnrKzs7NcN5vNmj9/vlq2bGlcOAA2gz3zAABWa9asWTpw4IA2b95c6hIy4Kdefvll5ebm6tNPPy11ebaPj48ByYCK4evrq82bNysgIMDoKADKsGvXLvXq1UtNmzbVm2++KW9vb6WkpGjDhg06f/68duzYodDQUKNjArBylHkAAKv23nvvaceOHQoJCSm2XNJkMikyMtKgZLBWLi4u2rhxo1599VWjowAAUMyuXbv04Ycf6uTJkzKbzTKZTGrVqpWio6PVo0cPo+MBsAGUeQAAq7Vz506FhYUpNze3xPsmk4kTGlHMSy+9pKlTp2rAgAFGRwEqVVpams6fP6+cnJxi9zp16mRAIgA/dfPmTbm6usrZ2Vn37t1TWlqaPDw85OLiYnQ0ADaEMg8AYLX8/f1Vp04dzZs3T/7+/nJ0dDQ6EmxAQkKCPvjgA23dupXltHgm5OTkaMSIEVq/fr1K+9GeX3wAxikoKFB0dLRmz56tjIwM2dvbq3fv3lq6dKlq1apldDwANogDMAAAVisxMVF/+ctf1KJFC6OjwIZ89NFHSk1NVbNmzdSsWbMSl2cfOHDAoHRA+YuOjtb+/fu1fPlyDR48WPPmzZOzs7Pi4uKUnJys2bNnGx0ReKYtWLBAUVFRCg4OVuvWrXXp0iXFx8fL3d1dy5YtMzoeABvEzDwAgNXq0KGDRo4cqWHDhhkdBTYkODi4zANT/vrXv1ZSGqDi+fv7a/z48Ro5cqQcHR313Xff6eWXX5YkDRgwQPXr16fQAwzUsmVLtW3bVgsXLrRcW7hwof7whz/o7t27JR7UBACPQpkHALBa33//vYYOHaqFCxeqQ4cORscBAKvk4uKihIQEBQUFycnJSXv37lVQUJAk6ZtvvtHw4cOVkpJicErg2eXu7q5NmzYpJCTEci09PV2enp46d+6cXnjhBQPTAbBFLLMFAFitvn37KiMjQ506dVKNGjWK7StjMpl09epVY8IBgJXw8vJSVlaWJKlhw4Y6deqUpcy7efOmsrOzjYwHPPOysrLk7u5e5Jqbm5skKTMz04hIAGwcZR4AwGp169atzOWSQEkKCwt17NgxJSYmlniy55AhQwxIBVSMwMBAnTx5Uj179lRYWJjCw8OVmZkpBwcHxcbGqmPHjkZHBJ55SUlJunTpkuXxw0NpkpKSiv2yskmTJpUZDYANYpktAACoUs6ePau+ffvq4sWLJZ7saTKZONkTVcp3332nxMRE9e/fX5mZmRo2bJi2bt2qgoICBQYGau3atWrUqJHRMYFnlp2dXYm/nDSbzSVe5/8oAGWhzAMAAFVKcHCwEhMTFRMToxYtWsjJyanYGB8fHwOSAZUnNzdXubm5xZb2Aah8y5cvf6zxQ4cOraAkAKoKyjwAgFU7ffq0IiMjdeDAAaWlpcnDw0NdunRReHi4WrRoYXQ8WCF3d3fFxcWpf//+RkcBAAAAyh175gEArNbx48fVuXNnVa9eXX369FG9evWUkpKibdu2aceOHTp48KBatWpldExYmdq1a6tatWpGxwAq1L59+x5rfNeuXSsoCQAAqGzMzAMAWK2QkBBlZGTo22+/tZz6Jj04+S0kJEQ1a9bU7t27DUwIazRnzhzt3LlT27dvl729vdFxgArx4z24Svtx3mQyWfbkYg8uAACqDmbmAQCs1tGjR7Vy5coiRZ4kubm5adKkSewpgxLduHFD586d04svvqju3bvL09OzyH2TyaTIyEiD0gHlx83NTWFhYQoLC1ONGjWMjgMAACoJZR4AwGqVdMLb49zHs+mjjz6yfH/+/Pli9ynzUBXs379fy5cv18aNG7Vhwwb169dPQ4cOZTktAADPAJbZAgCsVkhIiO7cuaN9+/YVmZ139+5dde3alWW2AJ55OTk52rRpk1auXKm9e/fK29tbgwYN0pAhQ/TLX/7S6HgAAKACUOYBAKzWsWPHFBwcLGdnZ/Xq1Uve3t5KSUnRzp07de/ePe3fv1+tW7c2OiYAWIXk5GStXr1aK1as0JkzZzR69GjNnTvX6FgAAKCcscwWAGC12rRpo6NHjyoqKkoJCQm6ffu2PD091aVLF4WHh6tFixZGR4QV2759uw4cOGD5dxMcHKzXXnvN6FhAhfHy8lLjxo3VuHFj/fvf/1ZaWprRkQAAQAVgZh4AAKhSMjMz1atXLx06dEgODg7y8vLSrVu3VFBQoKCgIG3fvl2urq5GxwTKzd/+9jetXLlSGzZsUG5url5//XUNGTJE3bt3l52dndHxAABAOeN/dwCAVSksLNS2bdt05syZUsecPn1a27Ztq8RUsCVTp07ViRMntHLlSmVnZys5OVnZ2dlasWKFTpw4oalTpxodEXhqFy5c0PTp09W0aVN16tRJ586d02effaaUlBStWrVKPXr0oMgDAKCKYmYeAMCqrFixQmPGjNHp06fl6+tb4pgrV66oefPmWrx4sd56661KTghrV79+fU2aNEnjxo0rdm/27Nn685//rKSkJAOSAeXHzs5O7u7u6t+/vwYPHiwfH59Hjm/SpEklJQMAABWNMg8AYFVCQ0Pl5+enOXPmPHLcuHHjdO7cOe3atauSksFWODk5afv27erevXuxe3v27FHv3r2Vk5NjQDKg/Px41p3JZCpzfEFBQUXGAQAAlYgDMAAAVuXEiRMaO3ZsmeNCQkK0atWqSkgEW+Pr61tqmbdz585SZ3wCtmTZsmVGRwAAAAahzAMAWJXMzEx5eHiUOc7Dw0OZmZmVkAi2ZtSoUZo4caKysrI0aNAgeXt7KyUlRWvXrtWSJUs0a9YsoyMCT23o0KFGRwAAAAahzAMAWJXatWvr6tWr6tix4yPHJSYmqnbt2pWUCrZkwoQJunHjhmbNmqW4uDhJktlsVrVq1TR58uQS99IDAAAAbAV75gEArMqbb76ptLQ07d69+5HjQkND5eHhoXXr1lVSMtiKO3fuyMnJSdnZ2Tp69Khu374tT09PBQYG/qxZnwAAAIA1o8wDAFiVI0eOqGPHjnr33Xc1c+ZMVatWrcj9+/fv6/3339fcuXN1+PBhBQYGGpQU1ig/P1/Ozs6Kj49X7969jY4DAAAAlDuW2QIArEq7du0UGxuriRMnatWqVQoNDZWPj48k6erVq9qzZ49u3bql2NhYijwU4+DgoLp168re3t7oKAAAAECFYGYeAMAqHTx4UDNnztT+/fuVnZ0tSapevbqCg4M1efJkBQUFGZwQ1mrSpEk6f/68Nm3aZHQUAAAAoNxR5gEArFphYaFu3rwpSfLy8mLGFcr0xRdf6OOPP1a9evX0+uuvy9vbWyaTqciYESNGGJQOAAAAeDqUeQAAoEqxs7N75H2TyaSCgoJKSgMAAACUL/bMAwAAVcrly5eNjgAAAABUGGbmAQAAAAAAADbi0etQAAAAAAAAAFgNltkCAACb16RJE8XHxysgIEC+vr7FDrz4MZPJpIsXL1ZiOgAAAKD8UOYBAACb17lzZ7m7u1u+f1SZBwAAANgy9swDAAAAAAAAbAR75gEAgCrl1KlTRkcAAAAAKgxlHgAAqFJeeuklBQQEKDY2VsnJyUbHAQAAAMoVZR4AAKhS1q5dKx8fH02ZMkWNGjVSjx49tGrVKt27d8/oaAAAAMBTY888AABQJd28eVNr1qzRV199pePHj8vV1VX9+vXT4MGDFRISYnQ8AAAA4IlQ5gEAgCrv/PnzWrlypZYsWaLU1FTl5+cbHQkAAAB4IiyzBQAAVVp2draOHTumY8eOKTU1VQ4ODkZHAgAAAJ4YZR4AAKhyzGaz9uzZoyFDhqhu3boaPHiwsrKyNG/ePKWkpBgdDwAAAHhiLLMFAABVynvvvac1a9YoOTlZTZs21dtvv63BgwerSZMmRkcDAAAAnhplHgAAqFK8vLz0xhtvaPDgwWrfvr3RcQAAAIByRZkHAACqlLy8PFWrVs3oGAAAAECFoMwDAAAAAAAAbAQHYAAAgColLy9PkZGR8vf3l4uLi+zt7Yt8cZotAAAAbBk/zQIAgCrl/fff17x589SzZ0/1799fTk5ORkcCAAAAyg3LbAEAQJXSoEEDjRkzRn/605+MjgIAAACUO5bZAgCAKiUrK0vt2rUzOgYAAABQISjzAABAldK7d28dPHjQ6BgAAABAhWDPPAAAUKWMHTtWQ4YMkZ2dnV599VV5enoWG9OkSRMDkgEAAABPjz3zAABAlWJn9/8LD0wmU4ljCgoKKisOAAAAUK6YmQcAAKqUL7/8stQSDwAAALB1zMwDAAAAAAAAbAQHYAAAgGdGYWGhbt++bXQMAAAA4IlR5gEAAJvn6empEydOWB6bzWb16dNHly5dKjLu+PHjeu655yo7HgAAAFBuKPMAAIDNS09PV35+vuVxYWGhtm/frvT0dONCAQAAABWAMg8AAAAAAACwEZR5AAAAAAAAgI2gzAMAAAAAAABshIPRAQAAAMpDUlKS5cCLgoICy7VatWpZxly7ds2IaAAAAEC5MZnNZrPRIQAAAJ6GnZ2dTCZTkWtms7nUaw/LPgAAAMDWMDMPAADYvGXLlhkdAQAAAKgUzMwDAAAAAAAAbAQHYAAAAAAAAAA2gjIPAAAAAAAAsBGUeQAAAAAAAICNoMwDAACoZHFxcTKZTJYvNzc3BQQEaO7cucrPz6/Q175y5YpMJpPi4uIs14YNG6bGjRs/1vPs379fERERKiwsLNd8ERERxU4hLknjxo01bNiwJ37+8vqcH/5dXrlypVyeDwAAoCyUeQAAAAbZsGGDjhw5oq+//lpt2rTR2LFjFRUVVek5wsPDFR8f/1h/Zv/+/YqMjCz3Mg8AAACP5mB0AAAAgGdVy5Yt9Ytf/EKSFBoaqgsXLmj27NmlFnr379+Xg4PDz5q59jiaNm1ars8HAACAisPMPAAAACvRunVrZWRkKDU11bIcdv78+frggw9Uv359OTk5KT09XZK0adMmBQYGysXFRbVq1dKAAQOUmJhY5Pnu3bunMWPGyMvLS66ururTp4+uXbtW7HVLWmZ79+5dTZ48WU2bNpWTk5Pq1aunsLAwXb9+XREREYqMjJQkOTo6WpYL//h1J02aJF9fX1WrVk2+vr6aMWNGsVl8J0+eVFBQkJydndWgQQNFR0fLbDY/0Wd348YNjRo1Ss2aNZOLi4saNmyogQMHKikpqcTx//nPf9SlSxe5uLjI29tb06ZNK5bvxo0beuedd9SgQQM5OTnJ399fixYteqJ8AAAA5YWZeQAAAFbi8uXLsre3l6urq+7duydJmjFjhlq3bq1FixapoKBAzs7OWrBggUaPHq3hw4dr2rRpyszMVEREhDp37qx//etfcnNzkySNGjVK69at0/Tp09W6dWvt2bNHAwcOLDNHXl6eunfvrlOnTmny5MkKDAzUnTt3lJCQoLS0NP3ud7/TtWvXtHTpUh0+fFj29vaWP5ufn68ePXro7NmzCg8PV4sWLXT06FFFR0fr9u3bio2NlSTdvHlTXbt2Vb169bR8+XI5OTkpJiamWCH5c92+fVvOzs765JNP9Nxzz+l///ufYmNj1aFDB/3www9ydnYuMr5v374aMWKEpkyZooSEBEVHR8vOzk4RERGSpIyMDHXs2FHZ2dmKiIiQr6+vEhISNHr0aOXm5mrs2LFPlBMAAOBpUeYBAAAYpKCgQPn5+crMzNT69eu1adMm9e7dWy4uLpYxdevWVXx8vGXmW1ZWliZNmqThw4fryy+/tIxr06aN/Pz8tHTpUo0fP17nzp3T6tWrNWPGDE2ePFnSg6W8WVlZWrBgwSNzffXVVzpy5Ii2bNmiPn36WK7/5je/sXz//PPPS5Latm0rB4f//5FyzZo1Onz4sA4cOKBOnTpJkrp16yZJioyM1KRJk1SnTh19/vnnunv3rnbv3q2GDRtKkrp37y4fH5/H/yAl+fn5afbs2ZbHBQUF6tChgxo1aqRvvvlG/fr1KzJ+5MiRRT6XjIwMxcbGavz48apVq5Zmz56tq1ev6vTp03rhhRckSSEhIUpPT1dkZKRGjx5d5H0DAABUFpbZAgAAGMTf31+Ojo7y9PTUmDFjNGjQoCIFnfRgBtmPl7AeOXJEGRkZGjRokPLz8y1fDRs2lL+/vw4ePChJ+sc//qHCwkK98cYbRZ7vt7/9bZm5du/erXr16hUp8n6uXbt2ycfHR+3bty+SLzQ0VPfv39fRo0ct7yMwMNBS5ElSjRo11Lt378d+zYe++OILBQQEyNXVVQ4ODmrUqJEk6dy5c8XGlvS5ZGVl6cyZM5b30bZtW/n6+hZ5Hz169NCtW7d09uzZJ84JAADwNPh1IgAAgEHi4+P1/PPPy83NTT4+PsWWgkqSt7d3kcepqamSHswSK4mHh4ckKTk5WdKDmX0/9tPHJbl165YaNGhQ9hsoQWpqqq5evSpHR8dSn/thvubNmxe7/3PylWTOnDl699139cc//lExMTHy8PBQYWGhAgMDlZOTU+brPHz8cI+91NRUXbhwocz3AQAAUNko8wAAAAzSvHlzy2m2pfnpybVeXl6SpLi4OP3qV78qNv7hfnkPS8Dr16+rSZMmlvvXr18vM1ft2rUtM9Qel5eXl3x9fbV+/foS7z88aMPb27vELD8nX0nWrl2rbt26Wfbkkx7sQVia0j6XhyWml5eX6tSpU2Tp7o/5+fk9UU4AAICnRZkHAABgQ9q3by83NzdduHBBQ4cOLXVc27ZtZWdnp/Xr11v2hpMelF5lCQ0N1dq1a7Vt27ZSl706OTlJkrKzsy0FoiS98sor+vrrr+Xq6ip/f/9SX6Ndu3aKiYnRf//7X8tS27t372rbtm1l5ivJvXv35O7uXuTasmXLSh1f0ufi6uqqFi1aWN7HnDlz1KhRI9WpU+eJMgEAAFQEyjwAAAAb4u7urpiYGP3+97/XjRs31LNnT9WsWVNJSUk6cOCAgoODNXDgQPn5+WngwIGaNm2aCgsL1bp1a+3evVs7d+4s8zXefvttLV68WG+99ZamTJmitm3bKjMzUwkJCRo/frz8/f314osvSpJiY2PVs2dP2dvb69e//rUGDRqkZcuWqVu3bpo4caICAgKUl5enixcvauvWrdq8ebNcXFw0YcIEzZ8/X6GhoYqIiLCcZlu9evUn+lxeeeUVzZw5Ux9//LHatGmjffv2aePGjaWOX7x4seVzSUhI0JIlSxQREaGaNWtKkiZMmKB169YpKChIEyZMkJ+fn+7evasffvhBhw4d0pYtW54oJwAAwNOizAMAALAxo0aNUsOGDRUTE6PVq1crPz9fDRo0UFBQkFq2bGkZt3DhQrm6uuqzzz5TXl6eunbtqtWrV6tjx46PfH5HR0ft3r1bkZGRWrRokSIjI+Xl5aUOHTrI09NTktSrVy+NGTNG8+fPV1RUlMxms8xmsxwdHZWQkKBPP/1UixYt0uXLl1WjRg01bdpUr732mqpVqybpwVLeb7/9VuPGjdPQoUPl5eWld955R/n5+YqKinrsz2TatGlKT0/X559/rpycHHXu3FkJCQlFltL+2JYtWzR27FhFR0erZs2a+vDDDxUeHm65X7NmTf39739XVFSUZs6cqaSkJNWqVUt+fn4KCwt77HwAAADlxWQ2m81GhwAAAAAAAABQNjujAwAAAAAAAAD4eSjzAAAAAAAAABtBmQcAAAAAAADYCMo8AAAAAAAAwEZQ5gEAAAAAAAA2gjIPAAAAAAAAsBGUeQAAAAAAAICNoMwDAAAAAAAAbARlHgAAAAAAAGAj/g/UtTvNhNX/9wAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "if __name__ == \"__main__\":\n", + " from great_ai import query_ground_truth\n", + " from sklearn import metrics\n", + "\n", + " data = query_ground_truth(\"test\")\n", + "\n", + " X = [d.input for d in data]\n", + " y_actual = [d.feedback for d in data]\n", + "\n", + " y_predicted = [\n", + " d.output.labels[0].label\n", + " for d in predict_domain.process_batch(X, do_not_persist_traces=True)\n", + " ]\n", + " y_actual_aligned = [p if p in a else a[0] for p, a in zip(y_predicted, y_actual)]\n", + "\n", + " import matplotlib.pyplot as plt\n", + "\n", + " # Configure matplotlib to have nice, high-resolution charts\n", + " %matplotlib inline\n", + " plt.rcParams[\"figure.figsize\"] = (19, 18)\n", + " plt.rcParams[\"figure.facecolor\"] = \"white\"\n", + " plt.rcParams[\"font.size\"] = 16\n", + " plt.rcParams[\"axes.xmargin\"] = 0\n", + "\n", + " print(metrics.classification_report(y_actual_aligned, y_predicted))\n", + " metrics.ConfusionMatrixDisplay.from_predictions(\n", + " y_true=y_actual_aligned,\n", + " y_pred=y_predicted,\n", + " xticks_rotation=\"vertical\",\n", + " normalize=\"pred\",\n", + " values_format=\".2f\",\n", + " )\n", + "\n", + " plt.tight_layout()\n", + " plt.savefig(\"ss-confusion.png\", dpi=600)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.10.4 ('.env': venv)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.4" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "02dd6d3afbfa9fbbe1037d64ad9014965528a1ccad21929d6e72f466389a68ad" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/docs/examples/simple/ss-confusion.png b/docs/examples/simple/ss-confusion.png new file mode 100644 index 0000000..b47e42b Binary files /dev/null and b/docs/examples/simple/ss-confusion.png differ diff --git a/docs/examples/simple/ss-distribution.png b/docs/examples/simple/ss-distribution.png new file mode 100644 index 0000000..77c4f7e Binary files /dev/null and b/docs/examples/simple/ss-distribution.png differ diff --git a/docs/examples/simple/stacked-bars.ipynb b/docs/examples/simple/stacked-bars.ipynb new file mode 100644 index 0000000..5d0e296 --- /dev/null +++ b/docs/examples/simple/stacked-bars.ipynb @@ -0,0 +1,117 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[38;5;226mEnvironment variable ENVIRONMENT is not set, defaulting to development mode ‼️\u001b[0m\n", + "\u001b[38;5;226mCannot find credentials files, defaulting to using ParallelTinyDbDriver\u001b[0m\n", + "\u001b[38;5;226mThe selected tracing database (ParallelTinyDbDriver) is not recommended for production\u001b[0m\n", + "\u001b[38;5;226mCannot find credentials files, defaulting to using LargeFileLocal\u001b[0m\n", + "\u001b[38;5;39mGreatAI (v0.1.6): configured ✅\u001b[0m\n", + "\u001b[38;5;39m 🔩 tracing_database: ParallelTinyDbDriver\u001b[0m\n", + "\u001b[38;5;39m 🔩 large_file_implementation: LargeFileLocal\u001b[0m\n", + "\u001b[38;5;39m 🔩 is_production: False\u001b[0m\n", + "\u001b[38;5;39m 🔩 should_log_exception_stack: True\u001b[0m\n", + "\u001b[38;5;39m 🔩 prediction_cache_size: 512\u001b[0m\n", + "\u001b[38;5;39m 🔩 dashboard_table_size: 50\u001b[0m\n", + "\u001b[38;5;226mYou still need to check whether you follow all best practices before trusting your deployment.\u001b[0m\n", + "\u001b[38;5;226m> Find out more at https://se-ml.github.io/practices\u001b[0m\n" + ] + } + ], + "source": [ + "from great_ai import query_ground_truth\n", + "\n", + "data = query_ground_truth(\"train\")" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from collections import Counter\n", + "import matplotlib.pyplot as plt\n", + "from great_ai.utilities import unique\n", + "import numpy as np\n", + "import matplotlib.ticker as mtick\n", + "\n", + "\n", + "first = Counter(d.feedback[0] for d in data if len(d.feedback) > 0)\n", + "second = Counter(d.feedback[1] for d in data if len(d.feedback) > 1)\n", + "third = Counter(d.feedback[2] for d in data if len(d.feedback) > 2)\n", + "\n", + "domains = sorted(unique(domain for d in data for domain in d.feedback))\n", + "\n", + "first = [first[d] / len(data) for d in domains]\n", + "second = [second[d] / len(data) for d in domains]\n", + "third = [third[d] / len(data) for d in domains]\n", + "\n", + "# Configure matplotlib to have nice, high-resolution charts\n", + "%matplotlib inline\n", + "plt.rcParams[\"figure.facecolor\"] = \"white\"\n", + "plt.rcParams[\"font.size\"] = 20\n", + "plt.rcParams[\"figure.figsize\"] = (14, 10)\n", + "\n", + "fig, ax = plt.subplots()\n", + "\n", + "plt.xticks(rotation=90)\n", + "\n", + "ax.bar(domains, first, label=\"Primary domain\")\n", + "ax.bar(domains, second, label=\"Secondary domain\", bottom=first)\n", + "ax.bar(domains, third, label=\"Tertiary domain\", bottom=np.add(first, second))\n", + "ax.yaxis.set_major_formatter(mtick.PercentFormatter(1))\n", + "ax.legend()\n", + "ax.set_ylabel(\"Ratio of all publications\")\n", + "fig.tight_layout()\n", + "fig.savefig(\"ss-distribution.png\", dpi=500)\n", + "None" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.10.4 ('.env': venv)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.4" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "02dd6d3afbfa9fbbe1037d64ad9014965528a1ccad21929d6e72f466389a68ad" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/docs/examples/simple/train.ipynb b/docs/examples/simple/train.ipynb new file mode 100644 index 0000000..1ba1e87 --- /dev/null +++ b/docs/examples/simple/train.ipynb @@ -0,0 +1,895 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Optimise and train a model\n", + "\n", + "![position of this step in the lifecycle](/media/scope-train.svg)\n", + "> The blue boxes show the steps implemented in this notebook.\n", + "\n", + "In the first part, we have cleaned and transformed our training data. We can now access this data using `great_ai.LargeFile`. Locally, it will gives us the cached version, otherwise, the latest version is downloaded from S3 or GridFS. \n", + "\n", + "In this part, we hyperparameter-optimise and train a simple Naive Bayes classifier which we then export for deployment using `great_ai.save_model`.\n", + "\n", + "## Load data that has been extracted in [part 1](/examples/simple/data)" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[38;5;226mEnvironment variable ENVIRONMENT is not set, defaulting to development mode ‼️\u001b[0m\n", + "\u001b[38;5;226mCannot find credentials files, defaulting to using ParallelTinyDbDriver\u001b[0m\n", + "\u001b[38;5;226mThe selected tracing database (ParallelTinyDbDriver) is not recommended for production\u001b[0m\n", + "\u001b[38;5;226mCannot find credentials files, defaulting to using LargeFileLocal\u001b[0m\n", + "\u001b[38;5;39mGreatAI (v0.1.6): configured ✅\u001b[0m\n", + "\u001b[38;5;39m 🔩 tracing_database: ParallelTinyDbDriver\u001b[0m\n", + "\u001b[38;5;39m 🔩 large_file_implementation: LargeFileLocal\u001b[0m\n", + "\u001b[38;5;39m 🔩 is_production: False\u001b[0m\n", + "\u001b[38;5;39m 🔩 should_log_exception_stack: True\u001b[0m\n", + "\u001b[38;5;39m 🔩 prediction_cache_size: 512\u001b[0m\n", + "\u001b[38;5;39m 🔩 dashboard_table_size: 50\u001b[0m\n", + "\u001b[38;5;226mYou still need to check whether you follow all best practices before trusting your deployment.\u001b[0m\n", + "\u001b[38;5;226m> Find out more at https://se-ml.github.io/practices\u001b[0m\n" + ] + } + ], + "source": [ + "from great_ai import query_ground_truth\n", + "\n", + "data = query_ground_truth(\"train\")\n", + "X = [d.input for d in data for domain in d.feedback]\n", + "y = [domain for d in data for domain in d.feedback]" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from collections import Counter\n", + "import matplotlib.pyplot as plt\n", + "\n", + "domains, counts = zip(*Counter(y).most_common())\n", + "\n", + "# Configure matplotlib to have nice, high-resolution charts\n", + "%matplotlib inline\n", + "plt.rcParams[\"figure.figsize\"] = (20, 5)\n", + "plt.rcParams[\"figure.facecolor\"] = \"white\"\n", + "plt.rcParams[\"font.size\"] = 12\n", + "\n", + "plt.xticks(rotation=90)\n", + "plt.bar(domains, counts)\n", + "None" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Optimise and train Multinomial Naive Bayes classifier" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.naive_bayes import MultinomialNB\n", + "from sklearn.pipeline import Pipeline\n", + "from sklearn.feature_extraction.text import TfidfVectorizer\n", + "\n", + "\n", + "def create_pipeline() -> Pipeline:\n", + " return Pipeline(\n", + " steps=[\n", + " (\"vectorizer\", TfidfVectorizer(sublinear_tf=True)),\n", + " (\"classifier\", MultinomialNB()),\n", + " ]\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fitting 3 folds for each of 24 candidates, totalling 72 fits\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
mean_fit_timestd_fit_timemean_score_timestd_score_timeparam_classifier__alphaparam_classifier__fit_priorparam_vectorizer__max_dfparam_vectorizer__min_dfparamssplit0_test_scoresplit1_test_scoresplit2_test_scoremean_test_scorestd_test_scorerank_test_score
714.5494760.3616858.4768370.2223980.5False0.0520{'classifier__alpha': 0.5, 'classifier__fit_pr...0.5180610.5148420.5115990.5148340.0026381
1011.2352890.1304264.0928680.0825180.5False0.120{'classifier__alpha': 0.5, 'classifier__fit_pr...0.5138970.5156610.5078670.5124750.0033372
197.3836450.1381104.1307090.2500481False0.0520{'classifier__alpha': 1, 'classifier__fit_prio...0.4968250.5010450.4968540.4982410.0019833
1110.4351540.3051443.8821010.1288860.5False0.1100{'classifier__alpha': 0.5, 'classifier__fit_pr...0.4932470.4978140.5022450.4977690.0036744
813.6431930.3106964.1737070.1429800.5False0.05100{'classifier__alpha': 0.5, 'classifier__fit_pr...0.4896090.4952070.4981540.4943230.0035445
227.0483400.0500703.1729480.1524181False0.120{'classifier__alpha': 1, 'classifier__fit_prio...0.4874560.4938650.4911570.4908260.0026276
237.5646850.1460922.3741110.2850261False0.1100{'classifier__alpha': 1, 'classifier__fit_prio...0.4851600.4940390.4901270.4897760.0036337
207.1723530.2125993.7472190.1302171False0.05100{'classifier__alpha': 1, 'classifier__fit_prio...0.4813030.4900020.4882690.4865240.0037598
614.2763450.4565768.3188590.2687010.5False0.055{'classifier__alpha': 0.5, 'classifier__fit_pr...0.4824290.4877350.4848880.4850170.0021689
214.9023580.7376935.9750910.1711500.5True0.05100{'classifier__alpha': 0.5, 'classifier__fit_pr...0.4695980.4744900.4736370.4725750.00213410
912.6773490.1451434.3742040.1756740.5False0.15{'classifier__alpha': 0.5, 'classifier__fit_pr...0.4688720.4764510.4709210.4720820.00320111
513.4236860.4828728.0083240.4429750.5True0.1100{'classifier__alpha': 0.5, 'classifier__fit_pr...0.4657260.4745480.4718790.4707180.00369412
113.8191170.8383476.1611750.3365900.5True0.0520{'classifier__alpha': 0.5, 'classifier__fit_pr...0.4633950.4739820.4712620.4695460.00448913
413.2814760.5888228.3358520.2546270.5True0.120{'classifier__alpha': 0.5, 'classifier__fit_pr...0.4587340.4680530.4644180.4637350.00383514
147.2822470.4449403.5670940.0445191True0.05100{'classifier__alpha': 1, 'classifier__fit_prio...0.4381890.4501600.4461800.4448430.00497815
177.0987970.1962413.8386280.0911281True0.1100{'classifier__alpha': 1, 'classifier__fit_prio...0.4364880.4445030.4459000.4422970.00414716
187.4927910.2888893.8432240.0734381False0.055{'classifier__alpha': 1, 'classifier__fit_prio...0.4281960.4319450.4301600.4301000.00153117
217.2298260.0998233.6563320.0737801False0.15{'classifier__alpha': 1, 'classifier__fit_prio...0.4031300.4101700.4098010.4077000.00323518
137.1583700.1698183.7656320.0829241True0.0520{'classifier__alpha': 1, 'classifier__fit_prio...0.3992370.4128720.4079820.4066970.00564019
167.0646430.1195293.8109830.1258971True0.120{'classifier__alpha': 1, 'classifier__fit_prio...0.3880600.3992470.3963250.3945440.00473720
013.7496600.4651746.4078410.5491660.5True0.055{'classifier__alpha': 0.5, 'classifier__fit_pr...0.3848520.3864870.3867960.3860450.00085321
315.9541470.3180136.3373610.2616970.5True0.15{'classifier__alpha': 0.5, 'classifier__fit_pr...0.3697850.3756450.3758580.3737630.00281422
127.1201980.0504523.8339050.0695401True0.055{'classifier__alpha': 1, 'classifier__fit_prio...0.2777410.2805640.2853370.2812140.00313523
157.4977070.1830543.8707140.0628881True0.15{'classifier__alpha': 1, 'classifier__fit_prio...0.2555780.2633810.2661840.2617140.00448724
\n", + "
" + ], + "text/plain": [ + " mean_fit_time std_fit_time mean_score_time std_score_time \\\n", + "7 14.549476 0.361685 8.476837 0.222398 \n", + "10 11.235289 0.130426 4.092868 0.082518 \n", + "19 7.383645 0.138110 4.130709 0.250048 \n", + "11 10.435154 0.305144 3.882101 0.128886 \n", + "8 13.643193 0.310696 4.173707 0.142980 \n", + "22 7.048340 0.050070 3.172948 0.152418 \n", + "23 7.564685 0.146092 2.374111 0.285026 \n", + "20 7.172353 0.212599 3.747219 0.130217 \n", + "6 14.276345 0.456576 8.318859 0.268701 \n", + "2 14.902358 0.737693 5.975091 0.171150 \n", + "9 12.677349 0.145143 4.374204 0.175674 \n", + "5 13.423686 0.482872 8.008324 0.442975 \n", + "1 13.819117 0.838347 6.161175 0.336590 \n", + "4 13.281476 0.588822 8.335852 0.254627 \n", + "14 7.282247 0.444940 3.567094 0.044519 \n", + "17 7.098797 0.196241 3.838628 0.091128 \n", + "18 7.492791 0.288889 3.843224 0.073438 \n", + "21 7.229826 0.099823 3.656332 0.073780 \n", + "13 7.158370 0.169818 3.765632 0.082924 \n", + "16 7.064643 0.119529 3.810983 0.125897 \n", + "0 13.749660 0.465174 6.407841 0.549166 \n", + "3 15.954147 0.318013 6.337361 0.261697 \n", + "12 7.120198 0.050452 3.833905 0.069540 \n", + "15 7.497707 0.183054 3.870714 0.062888 \n", + "\n", + " param_classifier__alpha param_classifier__fit_prior \\\n", + "7 0.5 False \n", + "10 0.5 False \n", + "19 1 False \n", + "11 0.5 False \n", + "8 0.5 False \n", + "22 1 False \n", + "23 1 False \n", + "20 1 False \n", + "6 0.5 False \n", + "2 0.5 True \n", + "9 0.5 False \n", + "5 0.5 True \n", + "1 0.5 True \n", + "4 0.5 True \n", + "14 1 True \n", + "17 1 True \n", + "18 1 False \n", + "21 1 False \n", + "13 1 True \n", + "16 1 True \n", + "0 0.5 True \n", + "3 0.5 True \n", + "12 1 True \n", + "15 1 True \n", + "\n", + " param_vectorizer__max_df param_vectorizer__min_df \\\n", + "7 0.05 20 \n", + "10 0.1 20 \n", + "19 0.05 20 \n", + "11 0.1 100 \n", + "8 0.05 100 \n", + "22 0.1 20 \n", + "23 0.1 100 \n", + "20 0.05 100 \n", + "6 0.05 5 \n", + "2 0.05 100 \n", + "9 0.1 5 \n", + "5 0.1 100 \n", + "1 0.05 20 \n", + "4 0.1 20 \n", + "14 0.05 100 \n", + "17 0.1 100 \n", + "18 0.05 5 \n", + "21 0.1 5 \n", + "13 0.05 20 \n", + "16 0.1 20 \n", + "0 0.05 5 \n", + "3 0.1 5 \n", + "12 0.05 5 \n", + "15 0.1 5 \n", + "\n", + " params split0_test_score \\\n", + "7 {'classifier__alpha': 0.5, 'classifier__fit_pr... 0.518061 \n", + "10 {'classifier__alpha': 0.5, 'classifier__fit_pr... 0.513897 \n", + "19 {'classifier__alpha': 1, 'classifier__fit_prio... 0.496825 \n", + "11 {'classifier__alpha': 0.5, 'classifier__fit_pr... 0.493247 \n", + "8 {'classifier__alpha': 0.5, 'classifier__fit_pr... 0.489609 \n", + "22 {'classifier__alpha': 1, 'classifier__fit_prio... 0.487456 \n", + "23 {'classifier__alpha': 1, 'classifier__fit_prio... 0.485160 \n", + "20 {'classifier__alpha': 1, 'classifier__fit_prio... 0.481303 \n", + "6 {'classifier__alpha': 0.5, 'classifier__fit_pr... 0.482429 \n", + "2 {'classifier__alpha': 0.5, 'classifier__fit_pr... 0.469598 \n", + "9 {'classifier__alpha': 0.5, 'classifier__fit_pr... 0.468872 \n", + "5 {'classifier__alpha': 0.5, 'classifier__fit_pr... 0.465726 \n", + "1 {'classifier__alpha': 0.5, 'classifier__fit_pr... 0.463395 \n", + "4 {'classifier__alpha': 0.5, 'classifier__fit_pr... 0.458734 \n", + "14 {'classifier__alpha': 1, 'classifier__fit_prio... 0.438189 \n", + "17 {'classifier__alpha': 1, 'classifier__fit_prio... 0.436488 \n", + "18 {'classifier__alpha': 1, 'classifier__fit_prio... 0.428196 \n", + "21 {'classifier__alpha': 1, 'classifier__fit_prio... 0.403130 \n", + "13 {'classifier__alpha': 1, 'classifier__fit_prio... 0.399237 \n", + "16 {'classifier__alpha': 1, 'classifier__fit_prio... 0.388060 \n", + "0 {'classifier__alpha': 0.5, 'classifier__fit_pr... 0.384852 \n", + "3 {'classifier__alpha': 0.5, 'classifier__fit_pr... 0.369785 \n", + "12 {'classifier__alpha': 1, 'classifier__fit_prio... 0.277741 \n", + "15 {'classifier__alpha': 1, 'classifier__fit_prio... 0.255578 \n", + "\n", + " split1_test_score split2_test_score mean_test_score std_test_score \\\n", + "7 0.514842 0.511599 0.514834 0.002638 \n", + "10 0.515661 0.507867 0.512475 0.003337 \n", + "19 0.501045 0.496854 0.498241 0.001983 \n", + "11 0.497814 0.502245 0.497769 0.003674 \n", + "8 0.495207 0.498154 0.494323 0.003544 \n", + "22 0.493865 0.491157 0.490826 0.002627 \n", + "23 0.494039 0.490127 0.489776 0.003633 \n", + "20 0.490002 0.488269 0.486524 0.003759 \n", + "6 0.487735 0.484888 0.485017 0.002168 \n", + "2 0.474490 0.473637 0.472575 0.002134 \n", + "9 0.476451 0.470921 0.472082 0.003201 \n", + "5 0.474548 0.471879 0.470718 0.003694 \n", + "1 0.473982 0.471262 0.469546 0.004489 \n", + "4 0.468053 0.464418 0.463735 0.003835 \n", + "14 0.450160 0.446180 0.444843 0.004978 \n", + "17 0.444503 0.445900 0.442297 0.004147 \n", + "18 0.431945 0.430160 0.430100 0.001531 \n", + "21 0.410170 0.409801 0.407700 0.003235 \n", + "13 0.412872 0.407982 0.406697 0.005640 \n", + "16 0.399247 0.396325 0.394544 0.004737 \n", + "0 0.386487 0.386796 0.386045 0.000853 \n", + "3 0.375645 0.375858 0.373763 0.002814 \n", + "12 0.280564 0.285337 0.281214 0.003135 \n", + "15 0.263381 0.266184 0.261714 0.004487 \n", + "\n", + " rank_test_score \n", + "7 1 \n", + "10 2 \n", + "19 3 \n", + "11 4 \n", + "8 5 \n", + "22 6 \n", + "23 7 \n", + "20 8 \n", + "6 9 \n", + "2 10 \n", + "9 11 \n", + "5 12 \n", + "1 13 \n", + "4 14 \n", + "14 15 \n", + "17 16 \n", + "18 17 \n", + "21 18 \n", + "13 19 \n", + "16 20 \n", + "0 21 \n", + "3 22 \n", + "12 23 \n", + "15 24 " + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from sklearn.model_selection import GridSearchCV\n", + "import pandas as pd\n", + "\n", + "optimisation_pipeline = GridSearchCV(\n", + " create_pipeline(),\n", + " {\n", + " \"vectorizer__min_df\": [5, 20, 100],\n", + " \"vectorizer__max_df\": [0.05, 0.1],\n", + " \"classifier__alpha\": [0.5, 1],\n", + " \"classifier__fit_prior\": [True, False],\n", + " },\n", + " scoring=\"f1_macro\",\n", + " cv=3,\n", + " n_jobs=-1,\n", + " verbose=1,\n", + ")\n", + "optimisation_pipeline.fit(X, y)\n", + "\n", + "results = pd.DataFrame(optimisation_pipeline.cv_results_)\n", + "results.sort_values(\"rank_test_score\")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
Pipeline(steps=[('vectorizer',\n",
+       "                 TfidfVectorizer(max_df=0.05, min_df=20, sublinear_tf=True)),\n",
+       "                ('classifier', MultinomialNB(alpha=0.5, fit_prior=False))])
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ], + "text/plain": [ + "Pipeline(steps=[('vectorizer',\n", + " TfidfVectorizer(max_df=0.05, min_df=20, sublinear_tf=True)),\n", + " ('classifier', MultinomialNB(alpha=0.5, fit_prior=False))])" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from sklearn import set_config\n", + "\n", + "set_config(display=\"diagram\")\n", + "\n", + "classifier = create_pipeline()\n", + "classifier.set_params(**optimisation_pipeline.best_params_)\n", + "classifier.fit(X, y)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Export the model using GreatAI" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[38;5;39mFetching cached versions of small-domain-prediction\u001b[0m\n", + "\u001b[38;5;39mCopying file for small-domain-prediction-2\u001b[0m\n", + "\u001b[38;5;39mCompressing small-domain-prediction-2\u001b[0m\n", + "\u001b[38;5;39mModel small-domain-prediction uploaded with version 2\u001b[0m\n" + ] + }, + { + "data": { + "text/plain": [ + "'small-domain-prediction:2'" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from great_ai import save_model\n", + "\n", + "\n", + "save_model(classifier, key=\"small-domain-prediction\", keep_last_n=5)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Next: [Part 3](/examples/simple/deploy)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.10.4 ('.env': venv)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.4" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "02dd6d3afbfa9fbbe1037d64ad9014965528a1ccad21929d6e72f466389a68ad" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/docs/explanation.md b/docs/explanation.md new file mode 100644 index 0000000..f37ee5f --- /dev/null +++ b/docs/explanation.md @@ -0,0 +1,11 @@ +# Explanation + +A lot more details and discussion about the problem context and approaches of GreatAI, along with its evaluation, can be found in my thesis. + +
+ front page +
+ +
+[::fontawesome-solid-graduation-cap: Download](thesis/main.pdf){ .md-button .md-button--primary download="greatai_schmelczer.pdf" } +
diff --git a/docs/hello_world.py b/docs/hello_world.py deleted file mode 100644 index 1f6fd01..0000000 --- a/docs/hello_world.py +++ /dev/null @@ -1,6 +0,0 @@ -from great_ai import GreatAI - - -@GreatAI.create -def hello_world(name: str) -> str: - return f"Hello {name}!" diff --git a/docs/how-to-guides/call-remote.md b/docs/how-to-guides/call-remote.md new file mode 100644 index 0000000..7ba80e6 --- /dev/null +++ b/docs/how-to-guides/call-remote.md @@ -0,0 +1,91 @@ +# How to call remote GreatAI instances + +Microservices architecture (or [SOA](https://en.wikipedia.org/wiki/Service-oriented_architecture)) work well with ML applications. This is because their interfaces are usually very narrow, while the functionality provided is quite comprehensive. Hence, drawing the boundaries of responsibilities is more straightforward in the case of ML services than in the case of more traditional business applications. For this reason, it is common to have a tree of models (preferably wrapped in GreatAI instances) communicating with each other. + +Although regular HTTP POST requests could be sent to each service's `/predict` endpoint, `great-ai` comes with two convenience functions: [call_remote_great_ai][great_ai.call_remote_great_ai] and [call_remote_great_ai_async][great_ai.call_remote_great_ai_async] to wrap this request. These provide you with some level of robustness and deserialisation. + +!!! note "Inside notebooks" + The async variant, [call_remote_great_ai_async][great_ai.call_remote_great_ai_async], requires a running event loop while the synchronous variant disallows other running event-loops. Therefore, when running inside a Jupyter Notebook, always call [call_remote_great_ai_async][great_ai.call_remote_great_ai_async]. + +## Simple example + +Let's create two processes: a server and a client. + +### Server + +```python title="server.py" +from great_ai import GreatAI +from asyncio import sleep + +@GreatAI.create +async def slow_greeter(your_name): + await sleep(2) + return f'Hi {your_name}!' +``` +> Run this in development mode by executing `great-ai server.py` or `python3 -m great_ai server.py` if you're on Windows and [`great-ai` is not in your `PATH`](/how-to-guides/install). + +### Client + +```python title="client.py" +from great_ai import call_remote_great_ai + +names = ['Olivér', 'Balázs', 'András'] + +results = [ + call_remote_great_ai( + 'http://localhost:6060', + { + 'your_name': name + } + ).output #(1) + for name in names +] + +print(results) +``` + +1. Only return the outputs, so we don't clutter up the terminal. + +> Run this script as a regular Python script by executing `python3 client.py`. + +![screenshot of result](/media/remote-sync.png){ loading=lazy } + +As you can see, everything worked as expected. There is one way to improve it, though. +## An `async` example + +Let's send multiple requests simultaneously to speed up the overall execution time. To do this, we will use the [call_remote_great_ai_async][great_ai.call_remote_great_ai_async] function. + +??? note "Why is this possible?" + Note that in `server.py`, the inference function is declared `async`. This means that multiple "copies" of it can run at the same time in the same thread. Since there is no CPU bottleneck, the server has a quite large throughput (requests responded to per second), but its latency will stay around 2 seconds due to the async `sleep` command. + + If your great-ai server is not `async`, higher throughput can be achieved by running multiple instances of it, either manually or by running it with multiple `uvicorn` workers like this: `ENVIRONMENT=production great-ai server.py --worker_count 4` + +### Async client + +```python title="async-client.py" +from great_ai import call_remote_great_ai_async +import asyncio + +names = ['Olivér', 'Balázs', 'András'] + +async def main(): + futures = [ + call_remote_great_ai_async( + 'http://localhost:6060', + { + 'your_name': name + } + ) for name in names + ] + + results = await asyncio.gather(*futures) + print([r.output for r in results]) + +asyncio.run(main()) +``` + +> Replace `client.py` with this async client. Note that although async support is significantly more streamlined in recent Python versions, it still requires a bit more boilerplate than its synchronous counterpart. + +![screenshot of result](/media/remote-async.png){ loading=lazy } + +This also works and might be considerably quicker in some use cases. diff --git a/docs/how-to-guides/configure-service.md b/docs/how-to-guides/configure-service.md new file mode 100644 index 0000000..376f773 --- /dev/null +++ b/docs/how-to-guides/configure-service.md @@ -0,0 +1,102 @@ +# How to configure GreatAI + +GreatAI aims to provide reasonable defaults wherever possible. The current configuration is always prominently displayed (and updated) on the dashboard and in the command-line start-up banner. + +## Using [great_ai.configure][] + +You can override any of the default settings by calling [great_ai.configure][]. If you don't call `configure`, the default settings are applied on the first call to most `great-ai` functions. + +!!! warning + You must call [great_ai.configure][] before calling (or decorating with) any other `great-ai` function. However, importing other functions before calling [great_ai.configure][] is permitted. + +```python title="configure-demo.py" +from great_ai import configure, RouteConfig +import logging + +configure( + version='1.0.0', + log_level=logging.INFO, + seed=2, + should_log_exception_stack=False, + prediction_cache_size=0, #(1) + disable_se4ml_banner=True, + dashboard_table_size=200, + route_config=RouteConfig( #(2) + feedback_endpoints_enabled=False, + dashboard_enabled=False + ) +) +``` + +1. Completely disable caching. +2. The unspecified routes are enabled by default. + +## Using remote storage + +The only aspect that cannot be automated is choosing the backing storage for the database and file storage. + +Right now, you have 3 options for storing the models and large datasets: [LargeFileLocal][great_ai.large_file.LargeFileLocal], [LargeFileMongo][great_ai.large_file.LargeFileMongo], and [LargeFileS3][great_ai.large_file.LargeFileS3]. + +Without explicit configuration, [LargeFileLocal][great_ai.large_file.LargeFileLocal] is selected by default. This one still version-controls your files but it only stores them in a local path (which of course can be a remote volume attached by [NFS](https://en.wikipedia.org/wiki/Network_File_System){ target=_blank }, [HDFS](https://hadoop.apache.org/docs/r1.2.1/hdfs_design.html){ target=_blank }, etc.). + +!!! important + If your working directory contains a `mongo.ini` or `s3.ini` file, an attempt is made to auto-configure [LargeFileMongo][great_ai.large_file.LargeFileMongo] or [LargeFileS3][great_ai.large_file.LargeFileS3] respectively. + +To use [LargeFileMongo][great_ai.large_file.LargeFileMongo] or [LargeFileS3][great_ai.large_file.LargeFileS3] explicitly, configure them before calling any other `great-ai` function. + +### S3-compatible + +```toml title="s3.ini" +aws_region_name = eu-west-2 +aws_access_key_id = MY_AWS_ACCESS_KEY # ENV:MY_AWS_ACCESS_KEY would also work +aws_secret_access_key = MY_AWS_SECRET_KEY +large_files_bucket_name = bucket-for-models +``` + +```python title="use-s3.py" +from great_ai.large_file import LargeFileS3 +from great_ai import save_model + +LargeFileS3.configure_credentials_from_file('s3.ini') #(1) + +model = [4, 3] +save_model(model, 'my-model') +``` + +1. This line isn't strictly necessary because if `s3.ini` (or `mongo.ini`) is available in the current working directory, they are automatically used to configure their respective LargeFile implementations/databases. + +??? note "Departing from AWS" + With the `aws_endpoint_url` argument, it is possible to use any other S3-compatible service such as [Backblaze](https://www.backblaze.com/){ target=_blank }. In that case, it would be `aws_endpoint_url=https://s3.us-west-002.backblazeb2.com`. + +### GridFS + +[GridFS](https://www.mongodb.com/docs/manual/core/gridfs/#:~:text=GridFS%20is%20a%20specification%20for,chunk%20as%20a%20separate%20document.){ target=_blank } specifies how to store files in MongoDB. The official MongoDB server and many compatible implementations support it. + +```toml title="mongo.ini" +MONGO_CONNECTION_STRING=mongodb://localhost:27017 # this is the default value +# if `MONGO_CONNECTION_STRING` is specified, this default is overridden +MONGO_CONNECTION_STRING=ENV:MONGO_CONNECTION_STRING + +MONGO_DATABASE=my-database # it is automatically created if it doesn't exist +``` + +```python title="use-mongo.py" +from great_ai.large_file import LargeFileMongo +from great_ai import save_model + +LargeFileMongo.configure_credentials_from_file('mongo.ini') + +model = [4, 3] +save_model(model, 'my-model') +``` + +!!! note "Simplifying config files" + You can combine `mongo.ini` or `s3.ini` with your application's config file because the unneeded keys are ignored by the `configure_credentials_from_file` method. + +## Using a database + +By default, a thread-safe version of [TinyDB](https://tinydb.readthedocs.io/en/latest/){ target=_blank } is utilised for saving the prediction traces into a local file. Unfortunately, for most production needs, this method is not suitable. + +### MongoDB + +Currently, only MongoDB is supported as a production-ready `TracingDatabase`. In order to use it, you have to either place a file named `mongo.ini` in your working directory or explicitly call either [MongoDbDriver.configure_credentials_from_file][great_ai.MongoDbDriver] or [MongoDbDriver.configure_credentials][great_ai.MongoDbDriver.configure_credentials]. diff --git a/docs/how-to-guides/create-service.md b/docs/how-to-guides/create-service.md new file mode 100644 index 0000000..0a8734a --- /dev/null +++ b/docs/how-to-guides/create-service.md @@ -0,0 +1,120 @@ +# How to create a GreatAI service + +The core value of `great-ai` lies in its [GreatAI][great_ai.GreatAI] class. To take advantage of it, you need to create an instance wrapping your code. + +Let's say that you have the following greeter function: + +```python title="greeter.py" +def my_greeter_function(your_name): + return f'Hi {your_name}!' +``` + +You can simply decorate (wrap) this function using the [@GreatAI.create][great_ai.GreatAI.create] factory. + +```python title="greeter.py" +from great_ai import GreatAI + +@GreatAI.create +def greeter(your_name): + return f'Hi {your_name}!' +``` + +??? info "Why not simply use `@GreatAI?`" + The purpose of [@GreatAI.create][great_ai.GreatAI.create] is simply to provide you with type-checking through MyPy, Pylance, and similar libraries. However, the overloading support for `__new__` is lacking in MyPy. Thus, a static factory method is used instead. + +## With types + +Even though it's not required by GreatAI, [type annotating your codebase](https://realpython.com/python-type-checking/){ target=_blank } can save you from lots of trivial mistakes; that's why it's highly advised. Simply add the expected types to your function's signature. + +```python title="type_safe_greeter.py" +from great_ai import GreatAI + +@GreatAI.create +def type_safe_greeter(your_name: str) -> str: + return f'Hi {your_name}!' +``` + +This not only allows you to statically type-check your code, but by default, GreatAI will check it during runtime as well using [typeguard](https://github.com/agronholm/typeguard){ target=_blank }. + +## With async + +Asynchronous code can result in immense performance gains in some instances. For example, you might rely on a third-party service, do database access, or [call a remote GreatAI instance](/how-to-guides/call-remote). In these cases, you can make your function `async` without any other changes. + +```python title="async_greeter.py" +from great_ai import GreatAI +from asyncio import sleep + +@GreatAI.create +async def async_greeter(your_name: str) -> str: + await sleep(2) # simulate IO-bound operation + return f'Hi {your_name}!' +``` + +## With decorators + +GreatAI can decorate already decorated functions. The only restriction is that [@GreatAI.create][great_ai.GreatAI.create] must come last. There are two built-in decorators that you can use to customise your function, but you can use any third-party decorator as well. + +### Using `@use_model` + +If you have previously saved a model with [save_model][great_ai.save_model], you can inject it into your function by calling [@use_model][great_ai.use_model]. + +```python title="greeter_with_model.py" +from great_ai import GreatAI, use_model + +@GreatAI.create +@use_model('name_of_my_model', version='latest') #(1) +def type_safe_greeter(your_name: str, model) -> str: + return f'Hi {your_name}!' + +assert type_safe_greeter('Andras').output == 'Hi Andras' +``` + +1. By default, the parameter named `model` will be replaced by the loaded model. This behaviour can be customised by setting the `model_kwarg_name`. This way, even multiple models can be injected into a single function. + +!!! important + You must call [@use_model][great_ai.use_model] before [@GreatAI.create][great_ai.GreatAI.create]. Note that decorators are applied starting from the bottom-most one. Feel free to use [@use_model][great_ai.use_model] in other places of the codebase, and it works equally well outside GreatAI services. + +### Using `@parameter` + +If you wish to turn off logging or specify custom validation for your parameters, you can use the [@parameter][great_ai.parameter] decorator. + +!!! note + By default, all parameters that are not affected by an explicit [@parameter][great_ai.parameter] or [@use_model][great_ai.use_model] are automatically decorated with [@parameter][great_ai.parameter] when [@GreatAI.create][great_ai.GreatAI.create] is called. + +```python title="greeter_with_validation.py" +from great_ai import GreatAI, use_model + +@GreatAI.create +@parameter('your_name', disable_logging=True) +def type_safe_greeter(your_name: str, model) -> str: + return f'Hi {your_name}!' + +assert type_safe_greeter('Andras').output == 'Hi Andras' +``` + +!!! important + You must call [@parameter][great_ai.parameter] before [@GreatAI.create][great_ai.GreatAI.create]. Note that decorators are applied starting from the bottom-most one. Feel free to use [@parameter][great_ai.parameter] in other places of the codebase, and it works equally well outside GreatAI services. + +## Complex example + +The following example summarises the options you have when instantiating a GreatAI service. + +```python title="complex.py" +from great_ai import save_model, GreatAI, parameter, use_model, log_metric + +save_model(4, 'secret-number') #(1) + +@GreatAI.create +@parameter('positive_number', validate=lambda n: n > 0, disable_logging=True) +@use_model('secret-number', version='latest', model_kwarg_name='secret') +def add_number(positive_number: int, secret: int) -> int: + log_metric( + 'log directly into the returned Trace', + positive_number * 2 + ) + return positive_number + secret + +assert add_number(1).output == 5 +``` + +1. Refer to [the configuration page](/how-to-guides/configure-service) for specifying where to store your models. diff --git a/docs/how-to-guides/handle-training-data.md b/docs/how-to-guides/handle-training-data.md new file mode 100644 index 0000000..8400227 --- /dev/null +++ b/docs/how-to-guides/handle-training-data.md @@ -0,0 +1,69 @@ +# How to manage training data + +In order to simplify your training data management, `great-ai` provide two complementing approaches for inputting new data points. + +## Upload data + +At the start of your experiments' first iteration, after you've gathered suitable samples for training, you can call [great_ai.add_ground_truth][]. This automatically stores a timestamp and also allows you to assign tags to the data. Using these attributes, [great_ai.query_ground_truth][] can be called to get a filtered view of the training data. + +!!! important "Train-test-validation splits" + It is a best practice to lock away the test split of your data that is only used for the final quality assessment. This prevents you from accidentally training on it or inadvertently tuning the model to have the highest accuracy metrics on the test split. This, of course, may lead to dubious results; hence, care must be taken to avoid it. + + With [great_ai.add_ground_truth][], there is an option to tag the samples with `train`, `test`, and `validation` randomly, following a predefined distribution. This happens as soon as they're written in the database. Later, these can be queried by providing the name of the appropriate tags. + +The nice thing about this is that the 'input-expected output' pairs are stored as traces. Thus, they behave exactly like regular prediction traces. + +```python +from great_ai import add_ground_truth + +add_ground_truth( + [1, 2], + ['odd', 'even'], + tags='my_tag', + train_split_ratio=1, #(1) + test_split_ratio=1 +) +``` + +1. Note that the ratios don't have to add up to 1. They are just weights. There is also a `validation_split_ratio` which is 0 by default. + +```python +>>> from great_ai import query_ground_truth +>>> query_ground_truth('my_tag') +[Trace[str]({'created': '2022-07-12T18:36:12.825706', + 'exception': None, + 'feedback': 'odd', #(1) + 'logged_values': {'input': 1}, #(2) + 'models': [], + 'original_execution_time_ms': 0.0, + 'output': 'odd', + 'tags': ['ground_truth', 'test', 'my_tag'], #(3) + 'trace_id': '4fcf2ce6-a172-469d-94b2-874577655814'}), + Trace[str]({'created': '2022-07-12T18:36:12.825706', + 'exception': None, + 'feedback': 'even', + 'logged_values': {'input': 2}, + 'models': [], + 'original_execution_time_ms': 0.0, + 'output': 'even', + 'tags': ['ground_truth', 'train', 'my_tag'], + 'trace_id': 'abee0671-beb9-4284-8c3b-c65e5836ce38'})] +``` + +1. Expected output. This can also be accessed through the `.output` property. +2. The input value is stored here. +3. Notice how `ground_truth` is always included as a tag when using [great_ai.add_ground_truth][]. + +## Get feedback + +After the initial data gathering, end-to-end feedback can also be integrated into the dataset. + +The scaffolded REST API contains endpoints for managing traces and their feedbacks. + +![screenshot of swagger](/media/feedback.png){ loading=lazy } + +When [great_ai.query_ground_truth][] is executed, it implicitly filters for traces that have feedback. Therefore, both the `ground_truth` and the `online` traces that have received feedback are returned. No matter the origin of the data, it can be accessed using the same API. + +## Remove clutter + +Traces can be deleted either through the REST API or by calling [great_ai.delete_ground_truth][]. The latter provides the same interface as [great_ai.query_ground_truth][] except it deletes the matched points. diff --git a/docs/how-to-guides/install.md b/docs/how-to-guides/install.md new file mode 100644 index 0000000..fc00e4d --- /dev/null +++ b/docs/how-to-guides/install.md @@ -0,0 +1,53 @@ +# Installation guide + +Provided you already have [Python3](https://www.python.org/downloads/){ target=_blank } (and pip) installed, simply execute: + +```sh +pip install great-ai +``` +> Python 3.7 or later is required. + +This will work on all major operating systems. + +## Google Colab + +In order to use GreatAI in [Google Colab](https://colab.research.google.com){ target=_blank }, you need to downgrade `pyyaml` to a Colab compatible version. [See related StackOverflow question](https://stackoverflow.com/questions/69564817/typeerror-load-missing-1-required-positional-argument-loader-in-google-col){ target=_blank }. + +```sh +pip install great-ai pyyaml==5.4.1 +``` +> This will make GreatAI work in Colab. + +## Command-line tools + +After installation, `great-ai` and `large-file` are available as commands. The former is required for deploying your application, while the latter lets you manage models and datasets from your terminal. + +??? note "Snakes & kebabs" + The library is called `great-ai`; therefore, its command-line entry point is also called `great-ai`. However, Python module names cannot contain hyphens, that's why you have to `import great_ai` with an underscore. The `great-ai` CLI tool is also available as `python3 -m great_ai`. + + To help with the confusion, a CLI executable called `great_ai` (and `large_file`) are also installed. Thus, if you prefer, you can always refer to GreatAI using its underscored name variant (`great_ai`). + +!!! warning "Windows" + On Windows, you might encounter a similar warning from `pip`: + > `WARNING: The scripts great-ai.exe, great_ai.exe, large-file.exe and large_file.exe are installed in 'C:\Users\...\Scripts', which is not on PATH.` + + > `Consider adding this directory to PATH or, if you prefer to suppress this warning, use --no-warn-script-location.` + + This means that `great-ai.exe` and `large-file.exe` are not in your `PATH`. Either add their containing directory ('C:\Users\...\Scripts' in this case) to your `PATH` or use `python3 -m great_ai` and `python3 -m great_ai.large_file` instead of the exe-s. + +## Update + +If you wish to update to the latest version, execute: + +```sh +pip install --upgrade great-ai +``` + +## Bleeding edge + +You can also install the latest (usually unreleased) version from GitHub. + +```sh +pip install --upgrade git+https://github.com/schmelczer/great-ai.git +``` +> Python 3.7 or later is required. diff --git a/docs/how-to-guides/large-file.md b/docs/how-to-guides/large-file.md new file mode 100644 index 0000000..f7babef --- /dev/null +++ b/docs/how-to-guides/large-file.md @@ -0,0 +1,114 @@ +# How to use LargeFiles + +The functions [save_model][great_ai.use_model] and [@use_model][great_ai.use_model] wrap LargeFile instances. Hence, besides configuring [LargeFile](/reference/large-file), users have few reasons to use LargeFiles directly. + +## Motivation + +Often, especially when working with data-heavy applications, large files can proliferate in a repository. Version controlling them is an obvious next step. However, GitHub's git LFS implementation [doesn't support deleting](https://docs.github.com/en/repositories/working-with-files/managing-large-files/removing-files-from-git-large-file-storage#git-lfs-objects-in-your-repository) large files, making it easy for them to eat-up the LFS quota and explode the size of your repos. + +[DVC](https://dvc.org/) is a viable alternative; however, it requires users to learn to use one more CLI tool. + +??? note "Using LargeFile-s directly (usually not needed)" + LargeFile doesn't require users to learn too much new. It is a nearly exact copy of Python's built-in `open()` function, with which users are undoubtedly already familiar. + + ## Simple example + + ```python + from great_ai.large_file import LargeFileS3 + + LargeFileS3.configure_credentials({ + "aws_region_name": "your_region_like_eu-west-2", + "aws_access_key_id": "YOUR_ACCESS_KEY_ID", + "aws_secret_access_key": "YOUR_VERY_SECRET_ACCESS_KEY", + "large_files_bucket_name": "create_a_bucket_and_put_its_name_here", + }) + + # Creates a new version and deletes the older version + # leaving the three most recently used intact + with LargeFileS3("test.txt", "w", keep_last_n=3) as f: + for i in range(100000): + f.write('test\n') + + # The latest version is returned by default + # but an optional `version` keyword argument can be provided as well + with LargeFileS3("test.txt", "r") as f: #(1) + print(f.readlines()[0]) + ``` + + 1. The latest version is already in the local cache; no download is required. + + ### More details + + `LargeFile` behaves like an opened file (in the background, it is a temp file after all). Binary reads and writes are supported along with the [different keywords `open()` accepts](https://docs.python.org/3/library/functions.html#open){ target=_blank }. + + The local cache can be configured with these properties: + + ```python + LargeFileS3.cache_path = Path('.cache') + LargeFileS3.max_cache_size = "30 GB" + ``` + + #### I only need a path + + In case you only need a path to the (proxy of the) remote file, this pattern can be applied: + + ```python + path_to_model = LargeFileS3("folder-of-my-bert-model", version=31).get() + ``` + + > This will first download the file/folder into your local cache folder. Then, it returns a `Path` object to the local version. Which can be turned into a string with `str(path_to_model)`. + + The same approach works for uploads: + + ```python + LargeFileS3("folder-of-my-bert-model").push('path_to_local/folder_or_file') + ``` + + > This way, both regular files and folders can be handled. The uploaded file is called **folder-of-my-bert-model**, the local name is ignored. + + Lastly, all version of the remote object can be deleted by calling `LargeFileS3("my-file").delete()`. It will still reside in your local cache afterwards; its deletion will happen next time your local cache has to be pruned. + +## From the command-line + +The main reason for using the `large-file` or `python3 -m great_ai.large_file` commands is to upload or download models from the terminal. For example, when building a docker image, it is best practice to cache the referred models. + +### Setup + +Create an .ini file (or use *~/.aws/credentials*). It may look like this: + +```ini +aws_region_name = your_region_like_eu-west-2 +aws_access_key_id = YOUR_ACCESS_KEY_ID +aws_secret_access_key = YOUR_VERY_SECRET_ACCESS_KEY +large_files_bucket_name = my_large_files +``` + +### Upload some files + +```sh +large-file --backend s3 --secrets secrets.ini \ + --push my_first_file.json folder/my_second_file my_folder +``` + +> Only the filename is used as the S3 name; the rest of the path is ignored. + +!!! important "Using MongoDB" + The possible values for `--backend` are `s3`, `mongo`, and `local`. The latter doesn't need credentials. It only versions and stores your files in a local folder. MongoDB, on the other hand, requires a `mongo_connection_string` and a `mongo_database` to be specified. For storing large files, it uses the [GridFS](https://www.mongodb.com/docs/manual/core/gridfs){ target=_blank } specification. + +### Download some files to the local cache + +This can be useful when building a Docker image, for example. This way, the files can already reside inside the container and need not be downloaded later. + +```sh +large-file --backend s3 --secrets ~/.aws/credentials \ + --cache my_first_file.json:3 my_second_file my_folder:0 +``` + +> Versions may be specified by using `:`-s. + +### Delete remote files + +```sh +large-file --backend s3 --secrets ~/.aws/credentials \ + --delete my_first_file.json +``` diff --git a/docs/how-to-guides/use-service.md b/docs/how-to-guides/use-service.md new file mode 100644 index 0000000..cd8272d --- /dev/null +++ b/docs/how-to-guides/use-service.md @@ -0,0 +1,131 @@ +# How to perform prediction with GreatAI + +After [creating a GreatAI service](/how-to-guides/create-service) by wrapping your prediction function, and optionally [configuring it](/how-to-guides/configure-service), it's time to do some prediction. + +Let's take the following example: + +```python title="greeter.py" +from great_ai import GreatAI + +@GreatAI.create +def greeter(your_name: str) -> str: + return f'Hi {your_name}!' +``` + +## One-off prediction + +Even though `greeter` is now an instance of [GreatAI][great_ai.GreatAI], you can continue using it as a regular function. + +```python +>>> greeter('Bob') +Trace[str]({'created': '2022-07-11T14:31:46.183764', + 'exception': None, + 'feedback': None, + 'logged_values': {'arg:your_name:length': 3, 'arg:your_name:value': 'Bob'}, + 'models': [], + 'original_execution_time_ms': 0.0381, + 'output': 'Hi Bob!', + 'tags': ['greeter', 'online', 'development'], + 'trace_id': '7c284fd7-7f0d-4464-b5f8-3ef126df34af'}) +``` + +As you can see, the original return value is wrapped in a [Trace][great_ai.Trace] object (which is also persisted in your database of choice). You can access the original value under the `output` property. + +## Online prediction + +Likely, the main way you would like to expose your model is through an HTTP API. [@GreatAI.create][great_ai.GreatAI.create] scaffolds many REST API endpoints for your model and creates a [FastAPI](https://fastapi.tiangolo.com/){ target=_blank } app available under [GreatAI.app][great_ai.GreatAI]. This can be served using [uvicorn](https://www.uvicorn.org/){ target=_blank } or any other [ASGI server](https://asgi.readthedocs.io/en/latest/){ target=_blank }. + +Since most ML code lives in [Jupyter](https://jupyter.org/){ target=_blank } notebooks, therefore, deploying a notebook containing the inference function is supported. To achieve this, `uvicorn` is wrapped by the `great-ai` command-line utility, which — among others — takes care of feeding a notebook into `uvicorn`. It also supports auto-reloading. + +### In development + +```sh +great-ai greeter.py +``` + +!!! success + Your model is accessible at [localhost:6060](http:/127.0.0.1:6060){ target=_blank }. + +Some configuration options are also supported. + +```sh +great-ai greeter.py --port 8000 --host 127.0.0.1 --timeout_keep_alive 10 +``` +??? note "More options" + For more options (but no Notebook support), simply use [uvicorn](https://www.uvicorn.org/){ target=_blank } for starting your app (available at `greeter.app`). + +### In production + +There are three main approaches for deploying a GreatAI service. + +#### Manual deployment + +The app is run in *production-mode* if the value of the `ENVIRONMENT` environment variable is set to `production`. + +```sh +ENVIRONMENT=production great-ai greeter.py +``` + +Simply run `ENVIRONMENT=production great-ai deploy.ipynb` in the command-line of a production machine. +> This is the crudest approach; however, it might be fitting for some contexts. + +#### Containerised deployment + +Run the notebook directly in a container or create a service for it using your favourite container orchestrator. + +```sh +docker run -p 6060:6060 --volume `pwd`:/app --rm \ + schmelczera/great-ai deploy.ipynb +``` +> You can replace ``pwd`` with the path to your code's folder. + +#### Use a Platform-as-a-Service + +Similar to the previous approach, your code will run in a container. However, instead of manually managing it, you can just choose from a plethora of PaaS providers (such as [AWS ECS](https://aws.amazon.com/ecs/){ target=_blank }, [DO App platform](https://www.digitalocean.com/products/app-platform){ target=_blank }, [MLEM](https://mlem.ai/){ target=_blank }, [Streamlit](https://streamlit.io/){ target=_blank }) that take a Docker image as a source and handle the rest of the deployment. + +To this end, you can also create a custom Docker image. It is especially useful if you have third-party dependencies, such as [PyTorch](https://pytorch.org/){ target=_blank } or [TensorFlow](https://www.tensorflow.org/){ target=_blank }. + +```Dockerfile +FROM schmelczera/great-ai:latest + +# Remove this block if you don't have a requirements.txt +COPY requirements.txt ./ +RUN pip install --no-cache-dir --requirement requirements.txt + +# If you store your models in S3 or GridFS, it may be a +# good idea to cache them in the image so that you don't +# have to download it each time a container starts +RUN large-file --backend s3 --secrets s3.ini --cache my-domain-predictor + +# Add your application code to the image +COPY . . + +# The default ENTRYPOINT is great-ai; specify its argument using CMD +CMD ["deploy.ipynb"] +``` + +## Batch prediction + +Processing larger amounts of data on a single machine is made easy by the [GreatAI][great_ai.GreatAI]'s [process_batch][great_ai.GreatAI.process_batch] method. This relies on multiprocessing ([parallel_map][great_ai.utilities.parallel_map.parallel_map.parallel_map]) to take full advantage of all available CPU-cores. + +```python +>>> greeter.process_batch(['Alice', 'Bob']) +[Trace[str]({'created': '2022-07-11T14:36:37.119183', + 'exception': None, + 'feedback': None, + 'logged_values': {'arg:your_name:length': 5, 'arg:your_name:value': 'Alice'}, + 'models': [], + 'original_execution_time_ms': 0.1251, + 'output': 'Hi Alice!', + 'tags': ['greeter', 'online', 'development'], + 'trace_id': '90ffa15f-e839-41c4-8e7a-3211168bc138'}), + Trace[str]({'created': '2022-07-11T14:36:37.166659', + 'exception': None, + 'feedback': None, + 'logged_values': {'arg:your_name:length': 3, 'arg:your_name:value': 'Bob'}, + 'models': [], + 'original_execution_time_ms': 0.0571, + 'output': 'Hi Bob!', + 'tags': ['greeter', 'online', 'development'], + 'trace_id': 'f48e94c7-0815-48b3-a864-41349d3dae84'})] +``` diff --git a/docs/ideas.drawio b/docs/ideas.drawio deleted file mode 100644 index 380b835..0000000 --- a/docs/ideas.drawio +++ /dev/null @@ -1,230 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - \ No newline at end of file diff --git a/docs/index.md b/docs/index.md new file mode 100644 index 0000000..ac7075e --- /dev/null +++ b/docs/index.md @@ -0,0 +1,119 @@ +
+

Overview of GreatAI

+ +
+ +[![PyPI version](https://badge.fury.io/py/great-ai.svg)](https://badge.fury.io/py/great-ai) +[![Downloads](https://pepy.tech/badge/great-ai/month)](https://pepy.tech/project/great-ai) +[![Docker Pulls](https://img.shields.io/docker/pulls/schmelczera/great-ai)](https://hub.docker.com/repository/docker/schmelczera/great-ai) +[![Test](https://github.com/schmelczer/great-ai/actions/workflows/test.yml/badge.svg)](https://github.com/schmelczer/great-ai/actions/workflows/test.yml) +[![Sonar line coverage](https://sonar.scoutinscience.com/api/project_badges/measure?project=great-ai&metric=coverage)](https://sonar.scoutinscience.com/dashboard?id=great-ai) +[![Sonar LoC](https://sonar.scoutinscience.com/api/project_badges/measure?project=great-ai&metric=ncloc)](https://sonar.scoutinscience.com/dashboard?id=great-ai) + +Applying AI is becoming increasingly easier, but many case studies have shown that these applications are often deployed poorly. This may lead to suboptimal performance and to introducing [unintended biases](https://en.wikipedia.org/wiki/Weapons_of_Math_Destruction){ target=_blank }. GreatAI helps fix this by allowing you to ==easily transform your prototype AI code into production-ready software==. + +??? quote "Case studies" + "There is a need to consider and adapt well established SE practices which have been ignored or had a very narrow focus in ML literature." + — [John et al.](https://ieeexplore.ieee.org/abstract/document/9359253){ target=_blank } + + "Finally, we have found that existing tools to aid Machine Learning development do not address the specificities of different projects, and thus, are seldom adopted by teams." — [Haakman et al.](https://link.springer.com/article/10.1007/s10664-021-09993-1){ target=_blank } + + "Because a mature system might end up being (at most) 5% machine learning code and (at least) 95% glue code, it may be less costly to create a clean native solution rather than re-use a generic package." — [Sculley et al.](https://www.researchgate.net/profile/Todd-Phillips/publication/319769912_Hidden_Technical_Debt_in_Machine_Learning_Systems/links/61e716d68d338833e37a7fd6/Hidden-Technical-Debt-in-Machine-Learning-Systems.pdf){ target=_blank } + + "For example, practice 25 is very important for "Traceability", yet relatively weakly adopted. We expect that the results from this type of analysis can, in the future, provide useful guidance for practitioners in terms of aiding them to assess their rate of adoption for each practice and to create roadmaps for improving their processes. — [Serban et al.](https://dl.acm.org/doi/abs/10.1145/3382494.3410681?casa_token=uCFz0dtDR6gAAAAA:4_8OMJ-5njwopYkB1KSGAu9JfbNq4nfa8LRE0fj84ckjfo-GgtcYQivZTGxal3M4haoA8r_xwpw){ target=_blank } + +## Features + +- [x] Save prediction traces of each prediction, including arguments and model versions +- [x] Save feedback and merge it into a ground-truth database +- [x] Version and store models and data on shared infrastructure *(MongoDB GridFS, S3-compatible storage, shared volume)* +- [x] Automatically scaffolded custom REST API (and OpenAPI schema) for easy integration +- [x] Input validation +- [x] Sensible cache-policy +- [x] Graceful error handling +- [x] Seamless support for both synchronous and asynchronous inference methods +- [x] Easy integration with remote GreatAI instances +- [x] Built-in parallelisation (with support for multiprocessing, async, and mixed modes) for batch processing +- [x] Well-tested utilities for common NLP tasks (cleaning, language-tagging, sentence-segmentation, etc.) +- [x] A simple, unified configuration interface +- [x] Fully-typed API for [Pylance](https://github.com/microsoft/pylance-release){ target=_blank } and [MyPy](http://mypy-lang.org){ target=_blank } support +- [x] Auto-reload for development +- [x] Docker support for deployment +- [x] Deployable Jupyter Notebooks +- [x] Dashboard for online monitoring and analysing traces +- [x] Active support for Python 3.7, 3.8, 3.9, and 3.10 + +## Roadmap + +- [ ] Prometheus & Grafana integration +- [ ] Well-tested feature extraction code for non-NLP data +- [ ] Support for direct file input +- [ ] Support for PostgreSQL + +## Hello world + +```sh +pip install great-ai +``` + +```python title="demo.py" +from great_ai import GreatAI + +@GreatAI.create #(1) +def greeter(name: str) -> str: #(2) + return f"Hello {name}!" +``` + +1. `@GreatAI.create` wraps your `greeter` function with a `GreatAI` instance. The function will behave very similarly but: + 1. its return value becomes a `Trace[str]`, + 2. it gets a `process_batch` method for supporting parallel execution, + 3. and it can be deployed using the `great-ai` command-line tool. + +2. [Typing functions](https://docs.python.org/3/library/typing.html){ target=_blank } is recommended in general, however, not required for GreatAI to work. + +??? note + In practice, `greeter` could be an inference function of some AI/ML application. But it could also just wrap a black-box solution of some SaaS. Either way, it is [imperative to have continuous oversight](https://digital-strategy.ec.europa.eu/en/library/ethics-guidelines-trustworthy-ai){ target=_blank } of the services you provide and the data you process, especially in the context of AI/ML applications. + +```sh title="terminal" +great-ai demo.py +``` +> Navigate to [localhost:6060](http://127.0.0.1:6060) in your browser. + +![demo screen capture](media/demo.gif){ loading=lazy } + +!!! success + Your GreatAI service is ready for production use. Many of the [SE4ML best practices](https://se-ml.github.io){ target=_blank } are configured and implemented automatically. To have full control over your service and to understand what else you might need to do in your use case, continue reading this documentation. + +## Why is this GREAT? + +![scope of GreatAI](media/scope-simple.drawio.svg) + +GreatAI fits between the prototype and deployment phases of your (or your organisation's) AI development lifecycle. This is highlighted in blue in the diagram. Here, several best practices can be automatically implemented, aiming to achieve the following attributes: + +- **G**eneral: use any Python library without restriction +- **R**obust: have error-handling and well-tested utilities out-of-the-box +- **E**nd-to-end: utilise end-to-end feedback as a built-in, first-class concept +- **A**utomated: focus only on what actually requires your attention +- **T**rustworthy: deploy models that you and society can confidently trust + +## Why GreatAI? + +There are other existing solutions aiming to facilitate this phase. [Amazon SageMaker](https://aws.amazon.com/sagemaker){ target=_blank } and [Seldon Core](https://www.seldon.io/solutions/open-source-projects/core){ target=_blank } provide the most comprehensive suite of features. If you have the opportunity to use them, do that because they're great. + +However, research indicates that professionals rarely use them. This may be due to their inherent setup and operational complexity. ==GreatAI is designed to be as simple to use as possible.== Its straightforward, high-level API and sensible default configuration make it extremely easy to start using. Despite its relative simplicity over Seldon Core, it still implements many of the [SE4ML best practices](https://se-ml.github.io){ target=_blank }, and thus, can meaningfully improve your deployment without requiring prohibitively great effort. + + +
+[:fontawesome-brands-python: Find it on PyPI](https://pypi.org/project/great-ai){ .md-button .md-button--primary } + +[:fontawesome-brands-docker: Find it on DockerHub](https://hub.docker.com/repository/docker/schmelczera/great-ai){ .md-button .md-button--primary } + +[:fontawesome-solid-laptop-code: Check out the tutorial](/tutorial){ .md-button .md-button--primary } +
+ +## Production use + +GreatAI has been battle-tested on the core platform services of [ScoutinScience](https://www.scoutinscience.com/){ target=_blank }. + +[![ScoutinScience logo](media/scoutinscience.svg#only-light){ loading=lazy } +![ScoutinScience logo](media/scoutinscience-white.svg#only-dark){ loading=lazy }](https://www.scoutinscience.com/){ target=_blank } diff --git a/docs/media/annotator.png b/docs/media/annotator.png new file mode 100644 index 0000000..9bad80c Binary files /dev/null and b/docs/media/annotator.png differ diff --git a/docs/media/architecture.drawio.svg b/docs/media/architecture.drawio.svg new file mode 100644 index 0000000..15742a9 --- /dev/null +++ b/docs/media/architecture.drawio.svg @@ -0,0 +1,927 @@ + + + + + + + + + + + + + + + + + + + +
+
+
+ User +
+
+
+ + + User + + + + + + + +
+
+
+

+ + <<Interface>> + +
+ + TracingDatabaseDriver + +

+

+
+

+
+
+
+ + + <<Interface>>... + + + + + + + +
+
+
+ MongoDbDriver +
+
+
+ + + MongoDbDriver + + + + + + + +
+
+
+ ParallelTinyDbDriver +
+
+
+ + + ParallelTinyDbDriver + + + + + + + + + + + + + +
+
+
+ + + Context + + +
+
+
+ + + Context + + + + + + + +
+
+
+ configure() +
+
+
+ + + configure() + + + + + + + + +
+
+
+ Create +
+
+
+ + + Create + + + + + + + + + GreatAI + + + + + + app: WSGI implementing web service + + + + + + + create(function): GreatAI + + + + __call__(...): ... + + + + process_batch([...]): [...] + + + + + + + +
+
+
+ Use +
+
+
+ + + Use + + + + + + + + + TracingContext + + + + + + + create(function): GreatAI + + + + + + + + +
+
+
+ static +
+
+
+ + + static + + + + + + +
+
+
+ current per thread +
+ per task +
+
+
+ + + current per thread... + + + + + + + + +
+
+
+ Use +
+
+
+ + + Use + + + + + + + +
+
+
+ User-defined function +
+
+
+ + + User-defined function + + + + + + + + +
+
+
+ Call (optional) +
+
+
+ + + Call (optional) + + + + + + + + +
+
+
+ Create +
+
+
+ + + Create + + + + + + +
+
+
+ + Client project + +
+
+
+ + + Client project + + + + + + + + +
+
+
+ Use +
+
+
+ + + Use + + + + + + + +
+
+
+

+ + <<abstract>> + +
+ + LargeFileBase + +

+

+
+

+
+
+
+ + + <<abstract>>... + + + + + + + +
+
+
+ LargeFileLocal +
+
+
+ + + LargeFileLocal + + + + + + + + + +
+
+
+ LargeFileS3 +
+
+
+ + + LargeFileS3 + + + + + + + +
+
+
+ LargeFileMongoDb +
+
+
+ + + LargeFileMongoDb + + + + + + + + + + + + + +
+
+
+

+ + <<implicit interface>> + +
+ + GreatAiBehaviourModifiers + +

+

+
+

+
+
+
+ + + <<implicit interface>>... + + + + + + + +
+
+
+ AsyncLruCache +
+
+
+ + + AsyncLruCache + + + + + + + +
+
+
+ InvocationTracer +
+
+
+ + + InvocationTracer + + + + + + + +
+
+
+ UseModel +
+
+
+ + + UseModel + + + + + + + +
+
+
+ MetricExporter +
+
+
+ + + MetricExporter + + + + + + + +
+
+
+ ParameterDecorator +
+
+
+ + + ParameterDecorator + + + + + + + + + + + + + + + + + + + +
+
+
+ 1 +
+
+
+ + + 1 + + + + + + + + + +
+
+
+ TracesAPI +
+
+
+ + + TracesAPI + + + + + + + +
+
+
+ MetadataAPI +
+
+
+ + + MetadataAPI + + + + + + + +
+
+
+ FeedbackAPI +
+
+
+ + + FeedbackAPI + + + + + + + +
+
+
+ Dashboard +
+
+
+ + + Dashboard + + + + + + + +
+
+
+ Documentation +
+
+
+ + + Documentation + + + + + + + +
+
+
+ views +
+
+
+ + + views + + + + + + + +
+
+
+ + GroundTruthAPI + +
+
+
+ + + GroundTruthAPI + + + + + + + + +
+
+
+ Use +
+
+
+ + + Use + + + + + + + + +
+
+
+ Use +
+
+
+ + + Use + + + + + + + +
+
+
+ utilities +
+
+
+ + + utilities + + + + + + + + +
+
+
+ Use +
+
+
+ + + Use + + + + + + + + + + +
+
+
+ + + FunctionMetadata + + +
+
+
+ + + FunctionMetadata + + + + + + + + + +
+
+
+ RemoteGreatAI +
+
+
+ + + RemoteGreatAI + + + + + + + + + + + + +
+
+
+ Use +
+
+
+ + + Use + + + + + + + + +
+
+
+ Use +
+
+
+ + + Use + + + + + + + + +
+
+
+ Use +
+
+
+ + + Use + + + + + + + + +
+
+
+ Use +
+
+
+ + + Use + + + + + + + + +
+
+
+ Use +
+
+
+ + + Use + + + + + + + + + Viewer does not support full SVG 1.1 + + + + \ No newline at end of file diff --git a/docs/media/demo.gif b/docs/media/demo.gif new file mode 100644 index 0000000..ee3bf8c Binary files /dev/null and b/docs/media/demo.gif differ diff --git a/docs/media/demo.mp4 b/docs/media/demo.mp4 new file mode 100644 index 0000000..506384e Binary files /dev/null and b/docs/media/demo.mp4 differ diff --git a/docs/media/design-cycle.drawio.png b/docs/media/design-cycle.drawio.png new file mode 100644 index 0000000..bcef26f Binary files /dev/null and b/docs/media/design-cycle.drawio.png differ diff --git a/docs/media/favicon.ico b/docs/media/favicon.ico new file mode 100644 index 0000000..d0a6efa Binary files /dev/null and b/docs/media/favicon.ico differ diff --git a/docs/media/feedback.png b/docs/media/feedback.png new file mode 100644 index 0000000..900816f Binary files /dev/null and b/docs/media/feedback.png differ diff --git a/docs/media/logo.png b/docs/media/logo.png new file mode 100644 index 0000000..b5dbe98 Binary files /dev/null and b/docs/media/logo.png differ diff --git a/docs/media/og-image.png b/docs/media/og-image.png new file mode 100644 index 0000000..da71b20 Binary files /dev/null and b/docs/media/og-image.png differ diff --git a/docs/media/remote-async.png b/docs/media/remote-async.png new file mode 100644 index 0000000..bf67859 Binary files /dev/null and b/docs/media/remote-async.png differ diff --git a/docs/media/remote-sync.png b/docs/media/remote-sync.png new file mode 100644 index 0000000..2c864b3 Binary files /dev/null and b/docs/media/remote-sync.png differ diff --git a/docs/media/scibert-confusion.png b/docs/media/scibert-confusion.png new file mode 100644 index 0000000..1926d89 Binary files /dev/null and b/docs/media/scibert-confusion.png differ diff --git a/docs/scope-data.drawio.svg b/docs/media/scope-data.drawio.svg similarity index 83% rename from docs/scope-data.drawio.svg rename to docs/media/scope-data.drawio.svg index 9766712..30c7708 100644 --- a/docs/scope-data.drawio.svg +++ b/docs/media/scope-data.drawio.svg @@ -1,4 +1,4 @@ - + @@ -18,7 +18,7 @@ - + Preprocessed data @@ -50,13 +50,13 @@ - +
-
-
+
+
Exploration & @@ -70,21 +70,21 @@
- + Exploration &... - - + +
-
-
+
+
Trained models  & prototype inference code @@ -92,7 +92,7 @@
- + Trained models  & protot... @@ -151,13 +151,13 @@ - +
-
-
+
+
Transforming into
@@ -169,7 +169,7 @@
- + Transforming into... @@ -178,22 +178,22 @@ - - + +
-
-
+
+
- Artifact combining the model with deplyoment best-practices + Artifact combining the model with deplyoment best practices
- + Artifact combining the mod... diff --git a/docs/media/scope-data.svg b/docs/media/scope-data.svg new file mode 100644 index 0000000..915a314 --- /dev/null +++ b/docs/media/scope-data.svg @@ -0,0 +1 @@ +
Preprocessed data
Preprocessed data
Data acquisition
(Data Engineering)
Data acquisition...
Exploration &
 model building
(Data Science)
Exploration &...
Trained models  & prototype inference code
Trained models  & protot...
Deploy with standard
 organisational methods
 (SysAdmin, Ops, DevOps)
Deploy with standard...
Use an AI deployment
SaaS/PaaS
(MLEM, Akkio, etc.) 
Use an AI deployment...
Transforming into
 production-ready service
(MLOps)
Transforming into...
Artifact combining the model with deplyoment best practices
Artifact combining the mod...Viewer does not support full SVG 1.1 \ No newline at end of file diff --git a/docs/media/scope-deploy.svg b/docs/media/scope-deploy.svg new file mode 100644 index 0000000..cae18bb --- /dev/null +++ b/docs/media/scope-deploy.svg @@ -0,0 +1 @@ +
Preprocessed data
Preprocessed data
Data acquisition
(Data Engineering)
Data acquisition...
Exploration &
 model building
(Data Science)
Exploration &...
Trained models  & prototype inference code
Trained models  & protot...
Deploy with standard
 organisational methods
 (SysAdmin, Ops, DevOps)
Deploy with standard...
Use an AI deployment
SaaS/PaaS
(MLEM, Akkio, etc.) 
Use an AI deployment...
Transforming into
 production-ready service
(MLOps)
Transforming into...
Artifact combining the model with deplyoment best practices
Artifact combining the mod...Viewer does not support full SVG 1.1 \ No newline at end of file diff --git a/docs/media/scope-simple.drawio.svg b/docs/media/scope-simple.drawio.svg new file mode 100644 index 0000000..d50fd56 --- /dev/null +++ b/docs/media/scope-simple.drawio.svg @@ -0,0 +1,125 @@ + + + + + + + + + +
+
+
+ + + Data acquisition + + +
+ + (Data Engineering) + +
+
+
+ + + Data acquisition... + + + + + + + + + +
+
+
+ + + + Exploration & +
+ model building + + +
+ + (Data Science) + + +
+
+
+ + + Exploration &... + + + + + + + +
+
+
+ + Deploy with standard +
+ organisational methods + +
+ + (SysAdmin, DevOps, +
+ or deployment SaaS) + +
+
+
+ + + Deploy with standard... + + + + + + + +
+
+
+ + Transforming into +
+ production-ready service + +
+ + (MLOps) + +
+
+
+ + + Transforming into... + + + + + + + + + + + Viewer does not support full SVG 1.1 + + + + \ No newline at end of file diff --git a/docs/media/scope-train.svg b/docs/media/scope-train.svg new file mode 100644 index 0000000..5f77e78 --- /dev/null +++ b/docs/media/scope-train.svg @@ -0,0 +1 @@ +
Preprocessed data
Preprocessed data
Data acquisition
(Data Engineering)
Data acquisition...
Exploration &
 model building
(Data Science)
Exploration &...
Trained models  & prototype inference code
Trained models  & protot...
Deploy with standard
 organisational methods
 (SysAdmin, Ops, DevOps)
Deploy with standard...
Use an AI deployment
SaaS/PaaS
(MLEM, Akkio, etc.) 
Use an AI deployment...
Transforming into
 production-ready service
(MLOps)
Transforming into...
Artifact combining the model with deplyoment best practices
Artifact combining the mod...Viewer does not support full SVG 1.1 \ No newline at end of file diff --git a/docs/media/scope.svg b/docs/media/scope.svg new file mode 100644 index 0000000..0de1ec5 --- /dev/null +++ b/docs/media/scope.svg @@ -0,0 +1 @@ +
Preprocessed data
Preprocessed data
Data acquisition
(Data Engineering)
Data acquisition...
Exploration &
 model building
(Data Science)
Exploration &...
Trained models  & prototype inference code
Trained models  & protot...
Deploy with standard
 organisational methods
 (SysAdmin, Ops, DevOps)
Deploy with standard...
Use an AI deployment
SaaS/PaaS
(MLEM, Akkio, etc.) 
Use an AI deployment...
Transforming into
 production-ready service
(MLOps)
Transforming into...
Artifact combining the model with deplyoment best practices
Artifact combining the mod...Viewer does not support full SVG 1.1 \ No newline at end of file diff --git a/docs/media/scoutinscience-white.svg b/docs/media/scoutinscience-white.svg new file mode 100644 index 0000000..626ed27 --- /dev/null +++ b/docs/media/scoutinscience-white.svg @@ -0,0 +1,122 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/docs/media/scoutinscience.svg b/docs/media/scoutinscience.svg new file mode 100644 index 0000000..2f40d52 --- /dev/null +++ b/docs/media/scoutinscience.svg @@ -0,0 +1,121 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/docs/media/thesis-frontpage.png b/docs/media/thesis-frontpage.png new file mode 100644 index 0000000..577e713 Binary files /dev/null and b/docs/media/thesis-frontpage.png differ diff --git a/docs/open_s3.md b/docs/open_s3.md deleted file mode 100644 index 04708e7..0000000 --- a/docs/open_s3.md +++ /dev/null @@ -1,118 +0,0 @@ -# [open(S3)](https://pypi.org/project/open-large/) - -Storing, versioning, and downloading files from S3 made as easy as using `open()` in Python. Caching included. - -## Motivation - -Oftentimes, especially when working with data-heavy applications, large files can proliferate in a repository. Version controlling them is an obvious next step, however, GitHub's git LFS implementation [doesn't support the deletion](https://docs.github.com/en/repositories/working-with-files/managing-large-files/removing-files-from-git-large-file-storage#git-lfs-objects-in-your-repository) of large files, making it easy for them to eat-up the LFS quota and explode the size of your repos. - -## Solution - -``` -pip install open-large -``` - -### Simple example - -```python -from large_file import LargeFileS3 - -LargeFileS3.configure_credentials({ - "aws_region_name": "your_region_like_eu-west-2", - "aws_access_key_id": "YOUR_ACCESS_KEY_ID", - "aws_secret_access_key": "YOUR_VERY_SECRET_ACCESS_KEY", - "large_files_bucket_name": "create_a_bucket_and_put_its_name_here", -}) - -# Creates a new version and deletes the older version leaving the 3 most recently used intact -with LargeFileS3("test.txt", "w", keep_last_n=3) as f: - for i in range(100000): - f.write('test\n') - -# By default the latest version is returned -# but an optional `version` keyword argument can be provided as well -with LargeFileS3("test.txt", "r") as f: - print(f.readlines()[0]) -``` - -> Automatically creates a file, writes to it, uploads it to S3, and then queries the most recent version of it. -> In this case, the latest version is already in the local cache, no download is required. - -### More details - -`LargeFile` behaves like an opened file (in the background it is a temp file after all). Binary reading and writing is supported along with the [different keywords](https://docs.python.org/3/library/functions.html#open) `open()` accepts. - -The local cache can be configured with these properties: - -```python -LargeFile.cache_path = Path('.cache') -LargeFile.max_cache_size = "30 GB" -``` - -#### I only need a path - -In case you only need a path to the "remote" file, this pattern can be applied: - -```python -path_to_model = LargeFile("folder-of-my-bert-model", version=31).get() -``` - -> This will first download the file/folder into your local cache folder. Then, it returns a `Path` object to the local version. Which can be turned into a string with `str(path_to_model)`. - -The same approach works for uploads: - -```python -LargeFile("folder-of-my-bert-model").push('path_to_local/folder_or_file') -``` - -> This way, both regular files and folders can be handled. The uploaded file is called **folder-of-my-bert-model**, the local name is ignored. - -Lastly, all version of the remote object can be deleted by calling `LargeFile("my-file").delete()`. It will still reside in your local cache afterwards, its deletion will happen next time your local cache has to be pruned. - -### Command-line example - -The package can be used as a module from the command-line to give you more flexibility. - -#### Setup - -Create an .ini file (or use _~/.aws/credentials_). It may look like this: - -```ini -aws_region_name = your_region_like_eu-west-2 -aws_access_key_id = YOUR_ACCESS_KEY_ID -aws_secret_access_key = YOUR_VERY_SECRET_ACCESS_KEY -large_files_bucket_name = my_large_files -endpoint_url = this is optional, for backblaze, use this: https://s3.us-west-002.backblazeb2.com -``` - -> Just like in [example secrets](example_secrets.ini). - -#### Print the expected options - -```sh -python3 -m large_file --help -``` - -#### Upload some files - -```sh -python3 -m large_file --backend s3 --secrets secrets.ini --push my_first_file.json folder/my_second_file my_folder -``` - -> Only the filename is used as the S3 name, the rest of the path is ignored. - -#### Download some files to the local cache - -This can be useful when building a Docker image for example. This way, the files can already reside inside the container and need not be downloaded later. - -```sh -python3 -m large_file --backend s3 -secrets ~/.aws/credentials --cache my_first_file.json:3 my_second_file my_folder:0 -``` - -> Versions may be specified by using `:`-s. - -#### Delete remote files - -```sh -python3 -m large_file --backend s3 --secrets ~/.aws/credentials --delete my_first_file.json -``` diff --git a/docs/overrides/main.html b/docs/overrides/main.html new file mode 100644 index 0000000..4b15dba --- /dev/null +++ b/docs/overrides/main.html @@ -0,0 +1,27 @@ +{% extends "base.html" %} + +{% block extrahead %} + + + + + + + + +{% endblock %} + +{% block content %} + +{% if page.nb_url %} + + {% include ".icons/material/download.svg" %} + +{% endif %} + +{{ super() }} +{% endblock content %} diff --git a/docs/reference/index.md b/docs/reference/index.md new file mode 100644 index 0000000..027e574 --- /dev/null +++ b/docs/reference/index.md @@ -0,0 +1,70 @@ +# GreatAI reference + +```python +from great_ai import * +``` + +## Core + +::: great_ai.GreatAI + options: + filters: ['!__init__'] + show_root_heading: true + +::: great_ai.configure + options: + show_root_heading: true + +::: great_ai.save_model + options: + show_root_heading: true + +::: great_ai.use_model + options: + show_root_heading: true + +::: great_ai.parameter + options: + show_root_heading: true + +::: great_ai.log_metric + options: + show_root_heading: true + +## Remote calls + +::: great_ai.call_remote_great_ai + options: + show_root_heading: true + +::: great_ai.call_remote_great_ai_async + options: + show_root_heading: true + +## Ground-truth + +::: great_ai.add_ground_truth + options: + show_root_heading: true + +::: great_ai.query_ground_truth + options: + show_root_heading: true + +::: great_ai.delete_ground_truth + options: + show_root_heading: true + +## Tracing databases + +::: great_ai.TracingDatabaseDriver + options: + show_root_heading: true + +::: great_ai.MongoDbDriver + options: + show_root_heading: true + +::: great_ai.ParallelTinyDbDriver + options: + show_root_heading: true diff --git a/docs/reference/large-file.md b/docs/reference/large-file.md new file mode 100644 index 0000000..37b5706 --- /dev/null +++ b/docs/reference/large-file.md @@ -0,0 +1,23 @@ +# LargeFile + +```python +from great_ai.large_file import * +``` + +For more details about using LargeFiles, check out the [how to guide](/how-to-guides/large-file/). + +::: great_ai.large_file.LargeFileLocal + options: + show_root_heading: true + +::: great_ai.large_file.LargeFileS3 + options: + show_root_heading: true + +::: great_ai.large_file.LargeFileMongo + options: + show_root_heading: true + +::: great_ai.large_file.LargeFileBase + options: + show_root_heading: true diff --git a/docs/reference/utilities.md b/docs/reference/utilities.md new file mode 100644 index 0000000..b1e3fb5 --- /dev/null +++ b/docs/reference/utilities.md @@ -0,0 +1,45 @@ +# Utilities + +```python +from great_ai.utilities import * +``` + +## NLP tools + +Well-tested tools that can be used in production with confidence. The toolbox of feature-extraction functions is expected to grow to cover other domains as well. + +::: great_ai.utilities.clean +::: great_ai.utilities.get_sentences +::: great_ai.utilities.language.predict_language +::: great_ai.utilities.language.english_name_of_language +::: great_ai.utilities.language.is_english +::: great_ai.utilities.evaluate_ranking.evaluate_ranking + +## Parallel processing + +Multiprocessing and multithreading-based parallelism with support for `async` functions. Its main purpose is to implement [great_ai.GreatAI.process_batch][], however, the parallel processing functions are also convenient for covering other types of mapping needs with a friendlier API than [joblib](https://joblib.readthedocs.io/en/latest/parallel.html){ target=_blank } or [multiprocess](https://pypi.org/project/multiprocess/){ target=_blank }. + +::: great_ai.utilities.simple_parallel_map + options: + show_root_heading: true +::: great_ai.utilities.parallel_map.parallel_map +::: great_ai.utilities.threaded_parallel_map + options: + show_root_heading: true + +## Composable parallel processing + +Because both [threaded_parallel_map][great_ai.utilities.parallel_map.threaded_parallel_map.threaded_parallel_map] and [parallel_map][great_ai.utilities.parallel_map.parallel_map.parallel_map] have a streaming interface, it is easy to compose them and end up with, for example, a process for each CPU core with its own thread-pool or event-loop. Longer pipelines are also easy to imagine. The chunking methods help in these compositions. + +::: great_ai.utilities.chunk +::: great_ai.utilities.unchunk + +## Operations + +::: great_ai.utilities.ConfigFile + options: + show_root_heading: true + +::: great_ai.utilities.get_logger + options: + show_root_heading: true diff --git a/docs/reference/views.md b/docs/reference/views.md new file mode 100644 index 0000000..5cfc6ef --- /dev/null +++ b/docs/reference/views.md @@ -0,0 +1,25 @@ +# View models + +::: great_ai.Trace + options: + show_root_heading: true + +::: great_ai.RouteConfig + options: + show_root_heading: true + +::: great_ai.ClassificationOutput + options: + show_root_heading: true + +::: great_ai.MultiLabelClassificationOutput + options: + show_root_heading: true + +::: great_ai.RegressionOutput + options: + show_root_heading: true + +::: great_ai.SequenceLabelingOutput + options: + show_root_heading: true diff --git a/docs/remote-test/remote.ipynb b/docs/remote-test/remote.ipynb deleted file mode 100644 index 90d509c..0000000 --- a/docs/remote-test/remote.ipynb +++ /dev/null @@ -1,90 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Trace(trace_id='07719c28-e248-43f8-a652-608c49ad5a17', created='2022-06-26T07:55:30.587753', original_execution_time_ms=178.268, logged_values={'arg:text:value': 'I love chemical compounds and nuclear fission.', 'arg:text:length': 46, 'arg:target_confidence:value': 50}, models=[Model(key='small-domain-prediction', version=0)], exception=None, output={'labels': [{'label': 'Physics', 'confidence': 28.0, 'explanation': ['nuclear', 'chemical', 'fission', 'compounds', 'love']}, {'label': 'Chemistry', 'confidence': 22.0, 'explanation': ['chemical', 'compounds', 'nuclear', 'fission', 'love']}]}, feedback=None, tags=['predict_domain', 'online', 'development'])" - ] - }, - "execution_count": 1, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from great_ai import call_remote_great_ai_async\n", - "\n", - "\n", - "await call_remote_great_ai_async(\n", - " \"http://localhost:6060\", {\"text\": \"I love chemical compounds and nuclear fission.\"}\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "<_UnixSelectorEventLoop running=True closed=False debug=False>\n" - ] - }, - { - "ename": "Exception", - "evalue": "Already running in an event loop, you have to call call_remote_great_ai_async.", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mException\u001b[0m Traceback (most recent call last)", - "\u001b[1;32m/data/projects/great_ai/docs/remote-test/remote.ipynb Cell 1'\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mgreat_ai\u001b[39;00m \u001b[39mimport\u001b[39;00m call_remote_great_ai\n\u001b[0;32m----> 4\u001b[0m call_remote_great_ai(\u001b[39m'\u001b[39;49m\u001b[39mhttp://localhost:6060\u001b[39;49m\u001b[39m'\u001b[39;49m, {\n\u001b[1;32m 5\u001b[0m \u001b[39m'\u001b[39;49m\u001b[39mtext\u001b[39;49m\u001b[39m'\u001b[39;49m: \u001b[39m'\u001b[39;49m\u001b[39mI love chemical compounds and nuclear fission.\u001b[39;49m\u001b[39m'\u001b[39;49m\n\u001b[1;32m 6\u001b[0m })\n", - "File \u001b[0;32m/data/projects/great_ai/src/great_ai/great_ai/remote/call_remote_great_ai.py:17\u001b[0m, in \u001b[0;36mcall_remote_great_ai\u001b[0;34m(base_uri, data, retry_count)\u001b[0m\n\u001b[1;32m 15\u001b[0m \u001b[39mtry\u001b[39;00m:\n\u001b[1;32m 16\u001b[0m \u001b[39mprint\u001b[39m(asyncio\u001b[39m.\u001b[39mget_running_loop())\n\u001b[0;32m---> 17\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mException\u001b[39;00m(\u001b[39mf\u001b[39m\u001b[39m'\u001b[39m\u001b[39mAlready running in an event loop, you have to call \u001b[39m\u001b[39m{\u001b[39;00mcall_remote_great_ai_async\u001b[39m.\u001b[39m\u001b[39m__name__\u001b[39m\u001b[39m}\u001b[39;00m\u001b[39m.\u001b[39m\u001b[39m'\u001b[39m)\n\u001b[1;32m 18\u001b[0m \u001b[39mexcept\u001b[39;00m \u001b[39mRuntimeError\u001b[39;00m:\n\u001b[1;32m 19\u001b[0m \u001b[39mpass\u001b[39;00m\n", - "\u001b[0;31mException\u001b[0m: Already running in an event loop, you have to call call_remote_great_ai_async." - ] - } - ], - "source": [ - "from great_ai import call_remote_great_ai\n", - "\n", - "\n", - "call_remote_great_ai(\n", - " \"http://localhost:6060\", {\"text\": \"I love chemical compounds and nuclear fission.\"}\n", - ")" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3.10.4 ('.env': venv)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.4" - }, - "orig_nbformat": 4, - "vscode": { - "interpreter": { - "hash": "d88b0dd276e3f918f7798b7e97af2e3c2f843817b9e5b55a9df0a682ffd80f44" - } - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/docs/simple-mag/confusion-matrix.png b/docs/simple-mag/confusion-matrix.png deleted file mode 100644 index b152adf..0000000 Binary files a/docs/simple-mag/confusion-matrix.png and /dev/null differ diff --git a/docs/simple-mag/mag-distribution.png b/docs/simple-mag/mag-distribution.png deleted file mode 100644 index a724ab1..0000000 Binary files a/docs/simple-mag/mag-distribution.png and /dev/null differ diff --git a/docs/simple-mag/train.ipynb b/docs/simple-mag/train.ipynb deleted file mode 100644 index 55d403d..0000000 --- a/docs/simple-mag/train.ipynb +++ /dev/null @@ -1,1814 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Train a field of study (domain) classification of sentences on the [MAG](https://github.com/allenai/scibert/tree/master/data/text_classification/mag) dataset\n", - "\n", - "[SciBERT achieves an F1-score of 0.6571 on this dataset.](https://paperswithcode.com/sota/sentence-classification-on-paper-field) \n", - "This notebook shows that better results can be achieved without even using transformers." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\u001b[38;5;39m2022-06-20 14:33:17,570 | INFO | Starting parallel map (concurrency: 12, chunk size: 700)\u001b[0m\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "e6f76bf83615422cb4352dcb3af48a26", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - " 0%| | 0/84000 [00:00 Tuple[str, str]:\n", - " data_point = json.loads(line)\n", - "\n", - " return (clean(data_point[\"text\"], convert_to_ascii=True), data_point[\"label\"])\n", - "\n", - "\n", - "with open(\"mag/train.txt\", encoding=\"utf-8\") as f:\n", - " training_data = parallel_map(preprocess, f.readlines())\n", - "\n", - "X_train = [d[0] for d in training_data]\n", - "y_train = [d[1] for d in training_data]\n", - "\n", - "\n", - "with open(\"mag/test.txt\", encoding=\"utf-8\") as f:\n", - " test_data = parallel_map(preprocess, f.readlines())\n", - "\n", - "X_test = [d[0] for d in test_data]\n", - "y_test = [d[1] for d in test_data]" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.plotly.v1+json": { - "config": { - "plotlyServerURL": "https://plot.ly" - }, - "data": [ - { - "alignmentgroup": "True", - "hovertemplate": "domain=%{x}
count=%{y}", - "legendgroup": "", - "marker": { - "color": "#636efa", - "pattern": { - "shape": "" - } - }, - "name": "", - "offsetgroup": "", - "orientation": "v", - "showlegend": false, - "textposition": "auto", - "type": "bar", - "x": [ - "geography", - "politics", - "economics", - "business", - "sociology", - "medicine", - "psychology" - ], - "xaxis": "x", - "y": [ - 12145, - 12051, - 11995, - 11990, - 11977, - 11928, - 11914 - ], - "yaxis": "y" - } - ], - "layout": { - "barmode": "relative", - "height": 400, - "legend": { - "tracegroupgap": 0 - }, - "margin": { - "t": 60 - }, - "template": { - "data": { - "bar": [ - { - "error_x": { - "color": "#2a3f5f" - }, - "error_y": { - "color": "#2a3f5f" - }, - "marker": { - "line": { - "color": "#E5ECF6", - "width": 0.5 - }, - "pattern": { - "fillmode": "overlay", - "size": 10, - "solidity": 0.2 - } - }, - "type": "bar" - } - ], - "barpolar": [ - { - "marker": { - "line": { - "color": "#E5ECF6", - "width": 0.5 - }, - "pattern": { - "fillmode": "overlay", - "size": 10, - "solidity": 0.2 - } - }, - "type": "barpolar" - } - ], - "carpet": [ - { - "aaxis": { - "endlinecolor": "#2a3f5f", - "gridcolor": "white", - "linecolor": "white", - "minorgridcolor": "white", - "startlinecolor": "#2a3f5f" - }, - "baxis": { - "endlinecolor": "#2a3f5f", - "gridcolor": "white", - "linecolor": "white", - "minorgridcolor": "white", - "startlinecolor": "#2a3f5f" - }, - "type": "carpet" - } - ], - "choropleth": [ - { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - }, - "type": "choropleth" - } - ], - "contour": [ - { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - }, - "colorscale": [ - [ - 0, - "#0d0887" - ], - [ - 0.1111111111111111, - "#46039f" - ], - [ - 0.2222222222222222, - "#7201a8" - ], - [ - 0.3333333333333333, - "#9c179e" - ], - [ - 0.4444444444444444, - "#bd3786" - ], - [ - 0.5555555555555556, - "#d8576b" - ], - [ - 0.6666666666666666, - "#ed7953" - ], - [ - 0.7777777777777778, - "#fb9f3a" - ], - [ - 0.8888888888888888, - "#fdca26" - ], - [ - 1, - "#f0f921" - ] - ], - "type": "contour" - } - ], - "contourcarpet": [ - { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - }, - "type": "contourcarpet" - } - ], - "heatmap": [ - { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - }, - "colorscale": [ - [ - 0, - "#0d0887" - ], - [ - 0.1111111111111111, - "#46039f" - ], - [ - 0.2222222222222222, - "#7201a8" - ], - [ - 0.3333333333333333, - "#9c179e" - ], - [ - 0.4444444444444444, - "#bd3786" - ], - [ - 0.5555555555555556, - "#d8576b" - ], - [ - 0.6666666666666666, - "#ed7953" - ], - [ - 0.7777777777777778, - "#fb9f3a" - ], - [ - 0.8888888888888888, - "#fdca26" - ], - [ - 1, - "#f0f921" - ] - ], - "type": "heatmap" - } - ], - "heatmapgl": [ - { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - }, - "colorscale": [ - [ - 0, - "#0d0887" - ], - [ - 0.1111111111111111, - "#46039f" - ], - [ - 0.2222222222222222, - "#7201a8" - ], - [ - 0.3333333333333333, - "#9c179e" - ], - [ - 0.4444444444444444, - "#bd3786" - ], - [ - 0.5555555555555556, - "#d8576b" - ], - [ - 0.6666666666666666, - "#ed7953" - ], - [ - 0.7777777777777778, - "#fb9f3a" - ], - [ - 0.8888888888888888, - "#fdca26" - ], - [ - 1, - "#f0f921" - ] - ], - "type": "heatmapgl" - } - ], - "histogram": [ - { - "marker": { - "pattern": { - "fillmode": "overlay", - "size": 10, - "solidity": 0.2 - } - }, - "type": "histogram" - } - ], - "histogram2d": [ - { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - }, - "colorscale": [ - [ - 0, - "#0d0887" - ], - [ - 0.1111111111111111, - "#46039f" - ], - [ - 0.2222222222222222, - "#7201a8" - ], - [ - 0.3333333333333333, - "#9c179e" - ], - [ - 0.4444444444444444, - "#bd3786" - ], - [ - 0.5555555555555556, - "#d8576b" - ], - [ - 0.6666666666666666, - "#ed7953" - ], - [ - 0.7777777777777778, - "#fb9f3a" - ], - [ - 0.8888888888888888, - "#fdca26" - ], - [ - 1, - "#f0f921" - ] - ], - "type": "histogram2d" - } - ], - "histogram2dcontour": [ - { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - }, - "colorscale": [ - [ - 0, - "#0d0887" - ], - [ - 0.1111111111111111, - "#46039f" - ], - [ - 0.2222222222222222, - "#7201a8" - ], - [ - 0.3333333333333333, - "#9c179e" - ], - [ - 0.4444444444444444, - "#bd3786" - ], - [ - 0.5555555555555556, - "#d8576b" - ], - [ - 0.6666666666666666, - "#ed7953" - ], - [ - 0.7777777777777778, - "#fb9f3a" - ], - [ - 0.8888888888888888, - "#fdca26" - ], - [ - 1, - "#f0f921" - ] - ], - "type": "histogram2dcontour" - } - ], - "mesh3d": [ - { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - }, - "type": "mesh3d" - } - ], - "parcoords": [ - { - "line": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "parcoords" - } - ], - "pie": [ - { - "automargin": true, - "type": "pie" - } - ], - "scatter": [ - { - "fillpattern": { - "fillmode": "overlay", - "size": 10, - "solidity": 0.2 - }, - "type": "scatter" - } - ], - "scatter3d": [ - { - "line": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "marker": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "scatter3d" - } - ], - "scattercarpet": [ - { - "marker": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "scattercarpet" - } - ], - "scattergeo": [ - { - "marker": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "scattergeo" - } - ], - "scattergl": [ - { - "marker": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "scattergl" - } - ], - "scattermapbox": [ - { - "marker": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "scattermapbox" - } - ], - "scatterpolar": [ - { - "marker": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "scatterpolar" - } - ], - "scatterpolargl": [ - { - "marker": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "scatterpolargl" - } - ], - "scatterternary": [ - { - "marker": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "scatterternary" - } - ], - "surface": [ - { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - }, - "colorscale": [ - [ - 0, - "#0d0887" - ], - [ - 0.1111111111111111, - "#46039f" - ], - [ - 0.2222222222222222, - "#7201a8" - ], - [ - 0.3333333333333333, - "#9c179e" - ], - [ - 0.4444444444444444, - "#bd3786" - ], - [ - 0.5555555555555556, - "#d8576b" - ], - [ - 0.6666666666666666, - "#ed7953" - ], - [ - 0.7777777777777778, - "#fb9f3a" - ], - [ - 0.8888888888888888, - "#fdca26" - ], - [ - 1, - "#f0f921" - ] - ], - "type": "surface" - } - ], - "table": [ - { - "cells": { - "fill": { - "color": "#EBF0F8" - }, - "line": { - "color": "white" - } - }, - "header": { - "fill": { - "color": "#C8D4E3" - }, - "line": { - "color": "white" - } - }, - "type": "table" - } - ] - }, - "layout": { - "annotationdefaults": { - "arrowcolor": "#2a3f5f", - "arrowhead": 0, - "arrowwidth": 1 - }, - "autotypenumbers": "strict", - "coloraxis": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "colorscale": { - "diverging": [ - [ - 0, - "#8e0152" - ], - [ - 0.1, - "#c51b7d" - ], - [ - 0.2, - "#de77ae" - ], - [ - 0.3, - "#f1b6da" - ], - [ - 0.4, - "#fde0ef" - ], - [ - 0.5, - "#f7f7f7" - ], - [ - 0.6, - "#e6f5d0" - ], - [ - 0.7, - "#b8e186" - ], - [ - 0.8, - "#7fbc41" - ], - [ - 0.9, - "#4d9221" - ], - [ - 1, - "#276419" - ] - ], - "sequential": [ - [ - 0, - "#0d0887" - ], - [ - 0.1111111111111111, - "#46039f" - ], - [ - 0.2222222222222222, - "#7201a8" - ], - [ - 0.3333333333333333, - "#9c179e" - ], - [ - 0.4444444444444444, - "#bd3786" - ], - [ - 0.5555555555555556, - "#d8576b" - ], - [ - 0.6666666666666666, - "#ed7953" - ], - [ - 0.7777777777777778, - "#fb9f3a" - ], - [ - 0.8888888888888888, - "#fdca26" - ], - [ - 1, - "#f0f921" - ] - ], - "sequentialminus": [ - [ - 0, - "#0d0887" - ], - [ - 0.1111111111111111, - "#46039f" - ], - [ - 0.2222222222222222, - "#7201a8" - ], - [ - 0.3333333333333333, - "#9c179e" - ], - [ - 0.4444444444444444, - "#bd3786" - ], - [ - 0.5555555555555556, - "#d8576b" - ], - [ - 0.6666666666666666, - "#ed7953" - ], - [ - 0.7777777777777778, - "#fb9f3a" - ], - [ - 0.8888888888888888, - "#fdca26" - ], - [ - 1, - "#f0f921" - ] - ] - }, - "colorway": [ - "#636efa", - "#EF553B", - "#00cc96", - "#ab63fa", - "#FFA15A", - "#19d3f3", - "#FF6692", - "#B6E880", - "#FF97FF", - "#FECB52" - ], - "font": { - "color": "#2a3f5f" - }, - "geo": { - "bgcolor": "white", - "lakecolor": "white", - "landcolor": "#E5ECF6", - "showlakes": true, - "showland": true, - "subunitcolor": "white" - }, - "hoverlabel": { - "align": "left" - }, - "hovermode": "closest", - "mapbox": { - "style": "light" - }, - "paper_bgcolor": "white", - "plot_bgcolor": "#E5ECF6", - "polar": { - "angularaxis": { - "gridcolor": "white", - "linecolor": "white", - "ticks": "" - }, - "bgcolor": "#E5ECF6", - "radialaxis": { - "gridcolor": "white", - "linecolor": "white", - "ticks": "" - } - }, - "scene": { - "xaxis": { - "backgroundcolor": "#E5ECF6", - "gridcolor": "white", - "gridwidth": 2, - "linecolor": "white", - "showbackground": true, - "ticks": "", - "zerolinecolor": "white" - }, - "yaxis": { - "backgroundcolor": "#E5ECF6", - "gridcolor": "white", - "gridwidth": 2, - "linecolor": "white", - "showbackground": true, - "ticks": "", - "zerolinecolor": "white" - }, - "zaxis": { - "backgroundcolor": "#E5ECF6", - "gridcolor": "white", - "gridwidth": 2, - "linecolor": "white", - "showbackground": true, - "ticks": "", - "zerolinecolor": "white" - } - }, - "shapedefaults": { - "line": { - "color": "#2a3f5f" - } - }, - "ternary": { - "aaxis": { - "gridcolor": "white", - "linecolor": "white", - "ticks": "" - }, - "baxis": { - "gridcolor": "white", - "linecolor": "white", - "ticks": "" - }, - "bgcolor": "#E5ECF6", - "caxis": { - "gridcolor": "white", - "linecolor": "white", - "ticks": "" - } - }, - "title": { - "x": 0.05 - }, - "xaxis": { - "automargin": true, - "gridcolor": "white", - "linecolor": "white", - "ticks": "", - "title": { - "standoff": 15 - }, - "zerolinecolor": "white", - "zerolinewidth": 2 - }, - "yaxis": { - "automargin": true, - "gridcolor": "white", - "linecolor": "white", - "ticks": "", - "title": { - "standoff": 15 - }, - "zerolinecolor": "white", - "zerolinewidth": 2 - } - } - }, - "width": 1200, - "xaxis": { - "anchor": "y", - "domain": [ - 0, - 1 - ], - "title": { - "text": "domain" - } - }, - "yaxis": { - "anchor": "x", - "domain": [ - 0, - 1 - ], - "title": { - "text": "count" - } - } - } - } - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import pandas as pd\n", - "from collections import Counter\n", - "import plotly.express as px\n", - "\n", - "\n", - "df = pd.DataFrame(Counter(y_train).most_common(), columns=[\"domain\", \"count\"])\n", - "px.bar(df, \"domain\", \"count\", width=1200, height=400).show()" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "from sklearn.naive_bayes import MultinomialNB\n", - "from sklearn.pipeline import Pipeline\n", - "from sklearn.feature_extraction.text import TfidfVectorizer\n", - "\n", - "\n", - "def create_pipeline() -> Pipeline:\n", - " return Pipeline(\n", - " steps=[\n", - " (\"vectorizer\", TfidfVectorizer(sublinear_tf=True)),\n", - " (\"classifier\", MultinomialNB()),\n", - " ]\n", - " )" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Fitting 3 folds for each of 24 candidates, totalling 72 fits\n" - ] - }, - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
mean_fit_timestd_fit_timemean_score_timestd_score_timeparam_classifier__alphaparam_classifier__fit_priorparam_vectorizer__max_dfparam_vectorizer__min_dfparamssplit0_test_scoresplit1_test_scoresplit2_test_scoremean_test_scorestd_test_scorerank_test_score
121.1720140.0333180.6257730.0137201True0.055{'classifier__alpha': 1, 'classifier__fit_prio...0.6772830.6703980.6656710.6711180.0047681
151.2012310.0167280.6135680.0137201True0.15{'classifier__alpha': 1, 'classifier__fit_prio...0.6769700.6702440.6661230.6711120.0044702
181.2112700.0366360.6707540.0768571False0.055{'classifier__alpha': 1, 'classifier__fit_prio...0.6756780.6693210.6653050.6701010.0042713
211.1657630.0612060.5496460.0467761False0.15{'classifier__alpha': 1, 'classifier__fit_prio...0.6755690.6694820.6652250.6700920.0042454
31.2776030.1277850.6501350.0230380.5True0.15{'classifier__alpha': 0.5, 'classifier__fit_pr...0.6752250.6689120.6656520.6699300.0039745
01.1180550.0589780.6222840.0142300.5True0.055{'classifier__alpha': 0.5, 'classifier__fit_pr...0.6752640.6687810.6653940.6698130.0040956
91.1661920.0442320.6193510.0248240.5False0.15{'classifier__alpha': 0.5, 'classifier__fit_pr...0.6741990.6680050.6644560.6688870.0040267
61.2333770.0637150.6664180.0616640.5False0.055{'classifier__alpha': 0.5, 'classifier__fit_pr...0.6739960.6680480.6645720.6688720.0038918
131.2451470.0895280.6458360.0062791True0.0520{'classifier__alpha': 1, 'classifier__fit_prio...0.6564590.6474330.6448640.6495850.0049729
161.1453620.0711490.6375400.0288541True0.120{'classifier__alpha': 1, 'classifier__fit_prio...0.6561960.6469600.6454360.6495300.00475410
41.1796630.0468080.5986990.0359730.5True0.120{'classifier__alpha': 0.5, 'classifier__fit_pr...0.6544240.6446900.6449910.6480350.00451911
11.0977730.0058710.5965140.0258990.5True0.0520{'classifier__alpha': 0.5, 'classifier__fit_pr...0.6546220.6449010.6444250.6479830.00469912
191.1615820.0400110.5868310.0061441False0.0520{'classifier__alpha': 1, 'classifier__fit_prio...0.6551250.6455860.6431660.6479590.00516313
221.1062770.0608090.3719860.0141141False0.120{'classifier__alpha': 1, 'classifier__fit_prio...0.6542540.6454090.6435140.6477260.00468014
71.2177130.0447870.5878960.0246130.5False0.0520{'classifier__alpha': 0.5, 'classifier__fit_pr...0.6527270.6436910.6427490.6463890.00449815
101.1766540.0459710.6280050.0823750.5False0.120{'classifier__alpha': 0.5, 'classifier__fit_pr...0.6522900.6429750.6434210.6462290.00429016
141.2073080.0809230.6102840.0391571True0.05100{'classifier__alpha': 1, 'classifier__fit_prio...0.5870970.5774110.5801700.5815600.00407517
171.2014980.0351610.5742340.0192471True0.1100{'classifier__alpha': 1, 'classifier__fit_prio...0.5857130.5771970.5807630.5812240.00349218
21.1579470.0968410.5864620.0109520.5True0.05100{'classifier__alpha': 0.5, 'classifier__fit_pr...0.5863460.5769870.5798520.5810620.00391519
51.1505110.0278070.5628700.0137240.5True0.1100{'classifier__alpha': 0.5, 'classifier__fit_pr...0.5856340.5762170.5803200.5807230.00385520
201.2370300.0068050.5295910.0644491False0.05100{'classifier__alpha': 1, 'classifier__fit_prio...0.5810960.5728330.5762800.5767360.00338921
81.1039370.0465130.5693670.0110010.5False0.05100{'classifier__alpha': 0.5, 'classifier__fit_pr...0.5808410.5723910.5757310.5763210.00347522
231.0802520.0405970.3266270.0029051False0.1100{'classifier__alpha': 1, 'classifier__fit_prio...0.5797690.5723730.5766990.5762800.00303423
111.2756010.0879710.5800250.0349140.5False0.1100{'classifier__alpha': 0.5, 'classifier__fit_pr...0.5797430.5716070.5763520.5759010.00333724
\n", - "
" - ], - "text/plain": [ - " mean_fit_time std_fit_time mean_score_time std_score_time \\\n", - "12 1.172014 0.033318 0.625773 0.013720 \n", - "15 1.201231 0.016728 0.613568 0.013720 \n", - "18 1.211270 0.036636 0.670754 0.076857 \n", - "21 1.165763 0.061206 0.549646 0.046776 \n", - "3 1.277603 0.127785 0.650135 0.023038 \n", - "0 1.118055 0.058978 0.622284 0.014230 \n", - "9 1.166192 0.044232 0.619351 0.024824 \n", - "6 1.233377 0.063715 0.666418 0.061664 \n", - "13 1.245147 0.089528 0.645836 0.006279 \n", - "16 1.145362 0.071149 0.637540 0.028854 \n", - "4 1.179663 0.046808 0.598699 0.035973 \n", - "1 1.097773 0.005871 0.596514 0.025899 \n", - "19 1.161582 0.040011 0.586831 0.006144 \n", - "22 1.106277 0.060809 0.371986 0.014114 \n", - "7 1.217713 0.044787 0.587896 0.024613 \n", - "10 1.176654 0.045971 0.628005 0.082375 \n", - "14 1.207308 0.080923 0.610284 0.039157 \n", - "17 1.201498 0.035161 0.574234 0.019247 \n", - "2 1.157947 0.096841 0.586462 0.010952 \n", - "5 1.150511 0.027807 0.562870 0.013724 \n", - "20 1.237030 0.006805 0.529591 0.064449 \n", - "8 1.103937 0.046513 0.569367 0.011001 \n", - "23 1.080252 0.040597 0.326627 0.002905 \n", - "11 1.275601 0.087971 0.580025 0.034914 \n", - "\n", - " param_classifier__alpha param_classifier__fit_prior \\\n", - "12 1 True \n", - "15 1 True \n", - "18 1 False \n", - "21 1 False \n", - "3 0.5 True \n", - "0 0.5 True \n", - "9 0.5 False \n", - "6 0.5 False \n", - "13 1 True \n", - "16 1 True \n", - "4 0.5 True \n", - "1 0.5 True \n", - "19 1 False \n", - "22 1 False \n", - "7 0.5 False \n", - "10 0.5 False \n", - "14 1 True \n", - "17 1 True \n", - "2 0.5 True \n", - "5 0.5 True \n", - "20 1 False \n", - "8 0.5 False \n", - "23 1 False \n", - "11 0.5 False \n", - "\n", - " param_vectorizer__max_df param_vectorizer__min_df \\\n", - "12 0.05 5 \n", - "15 0.1 5 \n", - "18 0.05 5 \n", - "21 0.1 5 \n", - "3 0.1 5 \n", - "0 0.05 5 \n", - "9 0.1 5 \n", - "6 0.05 5 \n", - "13 0.05 20 \n", - "16 0.1 20 \n", - "4 0.1 20 \n", - "1 0.05 20 \n", - "19 0.05 20 \n", - "22 0.1 20 \n", - "7 0.05 20 \n", - "10 0.1 20 \n", - "14 0.05 100 \n", - "17 0.1 100 \n", - "2 0.05 100 \n", - "5 0.1 100 \n", - "20 0.05 100 \n", - "8 0.05 100 \n", - "23 0.1 100 \n", - "11 0.1 100 \n", - "\n", - " params split0_test_score \\\n", - "12 {'classifier__alpha': 1, 'classifier__fit_prio... 0.677283 \n", - "15 {'classifier__alpha': 1, 'classifier__fit_prio... 0.676970 \n", - "18 {'classifier__alpha': 1, 'classifier__fit_prio... 0.675678 \n", - "21 {'classifier__alpha': 1, 'classifier__fit_prio... 0.675569 \n", - "3 {'classifier__alpha': 0.5, 'classifier__fit_pr... 0.675225 \n", - "0 {'classifier__alpha': 0.5, 'classifier__fit_pr... 0.675264 \n", - "9 {'classifier__alpha': 0.5, 'classifier__fit_pr... 0.674199 \n", - "6 {'classifier__alpha': 0.5, 'classifier__fit_pr... 0.673996 \n", - "13 {'classifier__alpha': 1, 'classifier__fit_prio... 0.656459 \n", - "16 {'classifier__alpha': 1, 'classifier__fit_prio... 0.656196 \n", - "4 {'classifier__alpha': 0.5, 'classifier__fit_pr... 0.654424 \n", - "1 {'classifier__alpha': 0.5, 'classifier__fit_pr... 0.654622 \n", - "19 {'classifier__alpha': 1, 'classifier__fit_prio... 0.655125 \n", - "22 {'classifier__alpha': 1, 'classifier__fit_prio... 0.654254 \n", - "7 {'classifier__alpha': 0.5, 'classifier__fit_pr... 0.652727 \n", - "10 {'classifier__alpha': 0.5, 'classifier__fit_pr... 0.652290 \n", - "14 {'classifier__alpha': 1, 'classifier__fit_prio... 0.587097 \n", - "17 {'classifier__alpha': 1, 'classifier__fit_prio... 0.585713 \n", - "2 {'classifier__alpha': 0.5, 'classifier__fit_pr... 0.586346 \n", - "5 {'classifier__alpha': 0.5, 'classifier__fit_pr... 0.585634 \n", - "20 {'classifier__alpha': 1, 'classifier__fit_prio... 0.581096 \n", - "8 {'classifier__alpha': 0.5, 'classifier__fit_pr... 0.580841 \n", - "23 {'classifier__alpha': 1, 'classifier__fit_prio... 0.579769 \n", - "11 {'classifier__alpha': 0.5, 'classifier__fit_pr... 0.579743 \n", - "\n", - " split1_test_score split2_test_score mean_test_score std_test_score \\\n", - "12 0.670398 0.665671 0.671118 0.004768 \n", - "15 0.670244 0.666123 0.671112 0.004470 \n", - "18 0.669321 0.665305 0.670101 0.004271 \n", - "21 0.669482 0.665225 0.670092 0.004245 \n", - "3 0.668912 0.665652 0.669930 0.003974 \n", - "0 0.668781 0.665394 0.669813 0.004095 \n", - "9 0.668005 0.664456 0.668887 0.004026 \n", - "6 0.668048 0.664572 0.668872 0.003891 \n", - "13 0.647433 0.644864 0.649585 0.004972 \n", - "16 0.646960 0.645436 0.649530 0.004754 \n", - "4 0.644690 0.644991 0.648035 0.004519 \n", - "1 0.644901 0.644425 0.647983 0.004699 \n", - "19 0.645586 0.643166 0.647959 0.005163 \n", - "22 0.645409 0.643514 0.647726 0.004680 \n", - "7 0.643691 0.642749 0.646389 0.004498 \n", - "10 0.642975 0.643421 0.646229 0.004290 \n", - "14 0.577411 0.580170 0.581560 0.004075 \n", - "17 0.577197 0.580763 0.581224 0.003492 \n", - "2 0.576987 0.579852 0.581062 0.003915 \n", - "5 0.576217 0.580320 0.580723 0.003855 \n", - "20 0.572833 0.576280 0.576736 0.003389 \n", - "8 0.572391 0.575731 0.576321 0.003475 \n", - "23 0.572373 0.576699 0.576280 0.003034 \n", - "11 0.571607 0.576352 0.575901 0.003337 \n", - "\n", - " rank_test_score \n", - "12 1 \n", - "15 2 \n", - "18 3 \n", - "21 4 \n", - "3 5 \n", - "0 6 \n", - "9 7 \n", - "6 8 \n", - "13 9 \n", - "16 10 \n", - "4 11 \n", - "1 12 \n", - "19 13 \n", - "22 14 \n", - "7 15 \n", - "10 16 \n", - "14 17 \n", - "17 18 \n", - "2 19 \n", - "5 20 \n", - "20 21 \n", - "8 22 \n", - "23 23 \n", - "11 24 " - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from sklearn.model_selection import GridSearchCV\n", - "\n", - "optimisation_pipeline = GridSearchCV(\n", - " create_pipeline(),\n", - " {\n", - " \"vectorizer__min_df\": [5, 20, 100],\n", - " \"vectorizer__max_df\": [0.05, 0.1],\n", - " \"classifier__alpha\": [0.5, 1],\n", - " \"classifier__fit_prior\": [True, False],\n", - " },\n", - " scoring=\"f1_macro\",\n", - " cv=3,\n", - " n_jobs=-1,\n", - " verbose=1,\n", - ")\n", - "optimisation_pipeline.fit(X_train, y_train)\n", - "\n", - "results = pd.DataFrame(optimisation_pipeline.cv_results_)\n", - "results.sort_values(\"rank_test_score\")" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
Pipeline(steps=[('vectorizer',\n",
-       "                 TfidfVectorizer(max_df=0.05, min_df=5, sublinear_tf=True)),\n",
-       "                ('classifier', MultinomialNB(alpha=1))])
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" - ], - "text/plain": [ - "Pipeline(steps=[('vectorizer',\n", - " TfidfVectorizer(max_df=0.05, min_df=5, sublinear_tf=True)),\n", - " ('classifier', MultinomialNB(alpha=1))])" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from sklearn import set_config\n", - "\n", - "set_config(display=\"diagram\")\n", - "\n", - "classifier = create_pipeline()\n", - "classifier.set_params(**optimisation_pipeline.best_params_)\n", - "classifier.fit(X_train, y_train)" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " precision recall f1-score support\n", - "\n", - " business 0.6412 0.7258 0.6808 3198\n", - " economics 0.6635 0.7146 0.6881 3189\n", - " geography 0.7461 0.6791 0.7111 3207\n", - " medicine 0.8806 0.9021 0.8912 3187\n", - " politics 0.5563 0.5895 0.5724 3169\n", - " psychology 0.7654 0.6811 0.7208 3252\n", - " sociology 0.5165 0.4698 0.4921 3197\n", - "\n", - " accuracy 0.6803 22399\n", - " macro avg 0.6814 0.6803 0.6795 22399\n", - "weighted avg 0.6817 0.6803 0.6796 22399\n", - "\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "from sklearn import metrics\n", - "import matplotlib.pyplot as plt\n", - "\n", - "y_predicted = classifier.predict(X_test)\n", - "\n", - "%matplotlib inline\n", - "plt.rcParams[\"figure.figsize\"] = (30, 15)\n", - "plt.rcParams[\"figure.facecolor\"] = \"white\"\n", - "plt.rcParams[\"font.size\"] = 12\n", - "plt.rcParams[\"axes.xmargin\"] = 0\n", - "\n", - "print(metrics.classification_report(y_test, y_predicted, digits=4))\n", - "metrics.ConfusionMatrixDisplay.from_predictions(\n", - " y_true=y_test,\n", - " y_pred=y_predicted,\n", - " xticks_rotation=\"vertical\",\n", - " normalize=\"pred\",\n", - " values_format=\".2f\",\n", - ")\n", - "None" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3.10.4 ('.env': venv)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.4" - }, - "orig_nbformat": 4, - "vscode": { - "interpreter": { - "hash": "02dd6d3afbfa9fbbe1037d64ad9014965528a1ccad21929d6e72f466389a68ad" - } - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/docs/surveys/Best practices assessment.csv b/docs/surveys/Best practices assessment.csv new file mode 100644 index 0000000..afb7896 --- /dev/null +++ b/docs/surveys/Best practices assessment.csv @@ -0,0 +1,11 @@ +"How many years of software engineering experience do you have?","How many years of data science experience do you have?","Write reusable scripts for data cleaning and merging","Make datasets available on shared infrastructure","Use versioning for data, model, configurations and training scripts","Continuously monitor the behaviour of deployed models","Log production predictions with the model’s version and input data","Store models in a single format for ease of use","Equip with web interface, package image, provide REST API","Provide simple API for serving batch and real-time requests","Integration with existing data infrastructure","Querying, visualising and understanding metrics and event logging","Allow experimentation with the inference code","Keep the model’s API and documentation together","Parallelise feature extraction","Cache predictions","Async support for top-down chaining models" +"3","1","Strongly agree","Agree","Strongly agree","Neither agree nor disagree","Strongly agree","Strongly agree","Strongly agree","Strongly agree","Strongly agree","Strongly agree","Strongly agree","Strongly agree","Strongly agree","Neither agree nor disagree","Strongly agree" +"6","2","Neither agree nor disagree","Agree","Neither agree nor disagree","Agree","Agree","Neither agree nor disagree","Disagree","Strongly disagree","Disagree","Strongly disagree","Disagree","Strongly disagree","Disagree","Strongly agree","Strongly disagree" +"1","5","Strongly disagree","Disagree","Disagree","Strongly disagree","Disagree","Strongly disagree","Strongly disagree","Neither agree nor disagree","Strongly disagree","Disagree","Neither agree nor disagree","Agree","Strongly disagree","Strongly disagree","Disagree" +"3","3","Agree","Agree","Disagree","Neither agree nor disagree","Agree","Not applicable","Not applicable","Neither agree nor disagree","Agree","Disagree","Agree","Strongly agree","Not applicable","Neither agree nor disagree","Agree" +"1","7","Neither agree nor disagree","Disagree","Neither agree nor disagree","Disagree","Strongly disagree","Not applicable","Not applicable","Disagree","Strongly disagree","Disagree","Disagree","Neither agree nor disagree","Strongly disagree","Strongly agree","Not applicable" +"6","0","Strongly agree","Strongly agree","Agree","Neither agree nor disagree","Agree","Strongly agree","Agree","Strongly agree","Agree","Strongly agree","Disagree","Strongly agree","Agree","Strongly agree","Not applicable" +"2","2","Disagree","Neither agree nor disagree","Agree","Strongly agree","Neither agree nor disagree","Disagree","Strongly agree","Disagree","Disagree","Agree","Neither agree nor disagree","Neither agree nor disagree","Not applicable","Disagree","Strongly agree" +"1","2","Disagree","Neither agree nor disagree","Disagree","Agree","Disagree","Strongly disagree","Strongly agree","Strongly agree","Strongly disagree","Disagree","Agree","Strongly disagree","Not applicable","Strongly disagree","Strongly disagree" +"0","1","Strongly disagree","Disagree","Strongly disagree","Disagree","Strongly disagree","Disagree","Agree","Strongly disagree","Disagree","Strongly disagree","Disagree","Strongly disagree","Disagree","Disagree","Strongly disagree" +"7","1","Strongly agree","Strongly agree","Agree","Strongly agree","Agree","Agree","Strongly agree","Strongly disagree","Strongly agree","Not applicable","Agree","Agree","Strongly agree","Strongly agree","Agree" \ No newline at end of file diff --git a/docs/surveys/Technology acceptance model questionnaire.csv b/docs/surveys/Technology acceptance model questionnaire.csv new file mode 100644 index 0000000..27537b5 --- /dev/null +++ b/docs/surveys/Technology acceptance model questionnaire.csv @@ -0,0 +1,11 @@ +"I believe the use of GreatAI improves the quality of AI deployments.","I believe the use of GreatAI would increase my productivity.","I believe the use of GreatAI can lead to robust and trustworthy deployments.","Overall, I found GreatAI useful when working with AI.","I found the GreatAI easy to learn.","I found it is easy to employ GreatAI in practice.","I found it is easy to integrate GreatAI into an existing project.","Overall, I found GreatAI easy to use.","Assuming GreatAI is applicable to my task, I predict that I will use it on a regular basis in the future.","Overall, I intend to use the GreatAI in my personal or professional projects." +"7","7","7","7","7","7","7","7","7","7" +"7","7","6","7","5","6","7","6","7","7" +"4","4","5","6","6","5","4","4","5","4" +"6","7","6","7","7","6","7","6","7","6" +"7","7","6","7","4","5","5","5","6","6" +"6","6","6","6","6","6","6","6","6","6" +"6","6","6","4","5","7","6","6","7","7" +"7","6","6","6","4","5","3","5","5","6" +"4","5","5","5","7","2","3","3","3","3" +"7","7","7","7","5","6","5","6","7","7" \ No newline at end of file diff --git a/docs/surveys/best-practices.png b/docs/surveys/best-practices.png new file mode 100644 index 0000000..4f69066 Binary files /dev/null and b/docs/surveys/best-practices.png differ diff --git a/docs/surveys/surveys.ipynb b/docs/surveys/surveys.ipynb new file mode 100644 index 0000000..17bd06a --- /dev/null +++ b/docs/surveys/surveys.ipynb @@ -0,0 +1,1297 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
How many years of software engineering experience do you have?How many years of data science experience do you have?Write reusable scripts for data cleaning and mergingMake datasets available on shared infrastructureUse versioning for data, model, configurations and training scriptsContinuously monitor the behaviour of deployed modelsLog production predictions with the model’s version and input dataStore models in a single format for ease of useEquip with web interface, package image, provide REST APIProvide simple API for serving batch and real-time requestsIntegration with existing data infrastructureQuerying, visualising and understanding metrics and event loggingAllow experimentation with the inference codeKeep the model’s API and documentation togetherParallelise feature extractionCache predictionsAsync support for top-down chaining models
031Strongly agreeAgreeStrongly agreeNeither agree nor disagreeStrongly agreeStrongly agreeStrongly agreeStrongly agreeStrongly agreeStrongly agreeStrongly agreeStrongly agreeStrongly agreeNeither agree nor disagreeStrongly agree
162Neither agree nor disagreeAgreeNeither agree nor disagreeAgreeAgreeNeither agree nor disagreeDisagreeStrongly disagreeDisagreeStrongly disagreeDisagreeStrongly disagreeDisagreeStrongly agreeStrongly disagree
215Strongly disagreeDisagreeDisagreeStrongly disagreeDisagreeStrongly disagreeStrongly disagreeNeither agree nor disagreeStrongly disagreeDisagreeNeither agree nor disagreeAgreeStrongly disagreeStrongly disagreeDisagree
333AgreeAgreeDisagreeNeither agree nor disagreeAgreeNot applicableNot applicableNeither agree nor disagreeAgreeDisagreeAgreeStrongly agreeNot applicableNeither agree nor disagreeAgree
417Neither agree nor disagreeDisagreeNeither agree nor disagreeDisagreeStrongly disagreeNot applicableNot applicableDisagreeStrongly disagreeDisagreeDisagreeNeither agree nor disagreeStrongly disagreeStrongly agreeNot applicable
560Strongly agreeStrongly agreeAgreeNeither agree nor disagreeAgreeStrongly agreeAgreeStrongly agreeAgreeStrongly agreeDisagreeStrongly agreeAgreeStrongly agreeNot applicable
622DisagreeNeither agree nor disagreeAgreeStrongly agreeNeither agree nor disagreeDisagreeStrongly agreeDisagreeDisagreeAgreeNeither agree nor disagreeNeither agree nor disagreeNot applicableDisagreeStrongly agree
712DisagreeNeither agree nor disagreeDisagreeAgreeDisagreeStrongly disagreeStrongly agreeStrongly agreeStrongly disagreeDisagreeAgreeStrongly disagreeNot applicableStrongly disagreeStrongly disagree
801Strongly disagreeDisagreeStrongly disagreeDisagreeStrongly disagreeDisagreeAgreeStrongly disagreeDisagreeStrongly disagreeDisagreeStrongly disagreeDisagreeDisagreeStrongly disagree
971Strongly agreeStrongly agreeAgreeStrongly agreeAgreeAgreeStrongly agreeStrongly disagreeStrongly agreeNot applicableAgreeAgreeStrongly agreeStrongly agreeAgree
\n", + "
" + ], + "text/plain": [ + " How many years of software engineering experience do you have? \\\n", + "0 3 \n", + "1 6 \n", + "2 1 \n", + "3 3 \n", + "4 1 \n", + "5 6 \n", + "6 2 \n", + "7 1 \n", + "8 0 \n", + "9 7 \n", + "\n", + " How many years of data science experience do you have? \\\n", + "0 1 \n", + "1 2 \n", + "2 5 \n", + "3 3 \n", + "4 7 \n", + "5 0 \n", + "6 2 \n", + "7 2 \n", + "8 1 \n", + "9 1 \n", + "\n", + " Write reusable scripts for data cleaning and merging \\\n", + "0 Strongly agree \n", + "1 Neither agree nor disagree \n", + "2 Strongly disagree \n", + "3 Agree \n", + "4 Neither agree nor disagree \n", + "5 Strongly agree \n", + "6 Disagree \n", + "7 Disagree \n", + "8 Strongly disagree \n", + "9 Strongly agree \n", + "\n", + " Make datasets available on shared infrastructure \\\n", + "0 Agree \n", + "1 Agree \n", + "2 Disagree \n", + "3 Agree \n", + "4 Disagree \n", + "5 Strongly agree \n", + "6 Neither agree nor disagree \n", + "7 Neither agree nor disagree \n", + "8 Disagree \n", + "9 Strongly agree \n", + "\n", + " Use versioning for data, model, configurations and training scripts \\\n", + "0 Strongly agree \n", + "1 Neither agree nor disagree \n", + "2 Disagree \n", + "3 Disagree \n", + "4 Neither agree nor disagree \n", + "5 Agree \n", + "6 Agree \n", + "7 Disagree \n", + "8 Strongly disagree \n", + "9 Agree \n", + "\n", + " Continuously monitor the behaviour of deployed models \\\n", + "0 Neither agree nor disagree \n", + "1 Agree \n", + "2 Strongly disagree \n", + "3 Neither agree nor disagree \n", + "4 Disagree \n", + "5 Neither agree nor disagree \n", + "6 Strongly agree \n", + "7 Agree \n", + "8 Disagree \n", + "9 Strongly agree \n", + "\n", + " Log production predictions with the model’s version and input data \\\n", + "0 Strongly agree \n", + "1 Agree \n", + "2 Disagree \n", + "3 Agree \n", + "4 Strongly disagree \n", + "5 Agree \n", + "6 Neither agree nor disagree \n", + "7 Disagree \n", + "8 Strongly disagree \n", + "9 Agree \n", + "\n", + " Store models in a single format for ease of use \\\n", + "0 Strongly agree \n", + "1 Neither agree nor disagree \n", + "2 Strongly disagree \n", + "3 Not applicable \n", + "4 Not applicable \n", + "5 Strongly agree \n", + "6 Disagree \n", + "7 Strongly disagree \n", + "8 Disagree \n", + "9 Agree \n", + "\n", + " Equip with web interface, package image, provide REST API \\\n", + "0 Strongly agree \n", + "1 Disagree \n", + "2 Strongly disagree \n", + "3 Not applicable \n", + "4 Not applicable \n", + "5 Agree \n", + "6 Strongly agree \n", + "7 Strongly agree \n", + "8 Agree \n", + "9 Strongly agree \n", + "\n", + " Provide simple API for serving batch and real-time requests \\\n", + "0 Strongly agree \n", + "1 Strongly disagree \n", + "2 Neither agree nor disagree \n", + "3 Neither agree nor disagree \n", + "4 Disagree \n", + "5 Strongly agree \n", + "6 Disagree \n", + "7 Strongly agree \n", + "8 Strongly disagree \n", + "9 Strongly disagree \n", + "\n", + " Integration with existing data infrastructure \\\n", + "0 Strongly agree \n", + "1 Disagree \n", + "2 Strongly disagree \n", + "3 Agree \n", + "4 Strongly disagree \n", + "5 Agree \n", + "6 Disagree \n", + "7 Strongly disagree \n", + "8 Disagree \n", + "9 Strongly agree \n", + "\n", + " Querying, visualising and understanding metrics and event logging \\\n", + "0 Strongly agree \n", + "1 Strongly disagree \n", + "2 Disagree \n", + "3 Disagree \n", + "4 Disagree \n", + "5 Strongly agree \n", + "6 Agree \n", + "7 Disagree \n", + "8 Strongly disagree \n", + "9 Not applicable \n", + "\n", + " Allow experimentation with the inference code \\\n", + "0 Strongly agree \n", + "1 Disagree \n", + "2 Neither agree nor disagree \n", + "3 Agree \n", + "4 Disagree \n", + "5 Disagree \n", + "6 Neither agree nor disagree \n", + "7 Agree \n", + "8 Disagree \n", + "9 Agree \n", + "\n", + " Keep the model’s API and documentation together \\\n", + "0 Strongly agree \n", + "1 Strongly disagree \n", + "2 Agree \n", + "3 Strongly agree \n", + "4 Neither agree nor disagree \n", + "5 Strongly agree \n", + "6 Neither agree nor disagree \n", + "7 Strongly disagree \n", + "8 Strongly disagree \n", + "9 Agree \n", + "\n", + " Parallelise feature extraction Cache predictions \\\n", + "0 Strongly agree Neither agree nor disagree \n", + "1 Disagree Strongly agree \n", + "2 Strongly disagree Strongly disagree \n", + "3 Not applicable Neither agree nor disagree \n", + "4 Strongly disagree Strongly agree \n", + "5 Agree Strongly agree \n", + "6 Not applicable Disagree \n", + "7 Not applicable Strongly disagree \n", + "8 Disagree Disagree \n", + "9 Strongly agree Strongly agree \n", + "\n", + " Async support for top-down chaining models \n", + "0 Strongly agree \n", + "1 Strongly disagree \n", + "2 Disagree \n", + "3 Agree \n", + "4 Not applicable \n", + "5 Not applicable \n", + "6 Strongly agree \n", + "7 Strongly disagree \n", + "8 Strongly disagree \n", + "9 Agree " + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import pandas as pd\n", + "\n", + "best_practices = pd.read_csv(\"Best practices assessment.csv\")\n", + "best_practices" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(2.5, 2.0)" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "m = {\n", + " \"Strongly agree\": 4 / 4,\n", + " \"Agree\": 3 / 4,\n", + " \"Neither agree nor disagree\": 2 / 4,\n", + " \"Disagree\": 1 / 4,\n", + " \"Strongly disagree\": 0 / 4,\n", + "}\n", + "\n", + "best_practices_dicts = [v.to_dict() for _, v in best_practices.iterrows()]\n", + "\n", + "best_practice_score_ds = []\n", + "best_practice_score_se = []\n", + "\n", + "for d in best_practices_dicts:\n", + " ds_experience = int(d[\"How many years of data science experience do you have?\"])\n", + " del d[\"How many years of data science experience do you have?\"]\n", + "\n", + " se_experience = int(\n", + " d[\"How many years of software engineering experience do you have?\"]\n", + " )\n", + " del d[\"How many years of software engineering experience do you have?\"]\n", + "\n", + " scores = [m[v] for v in d.values() if v != \"Not applicable\"]\n", + " score = sum(scores) / len(scores)\n", + " best_practice_score_ds.append((ds_experience, score))\n", + " best_practice_score_se.append((se_experience, score))\n", + "\n", + "best_practices[\n", + " \"How many years of software engineering experience do you have?\"\n", + "].median(), best_practices[\n", + " \"How many years of data science experience do you have?\"\n", + "].median()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(-0.5440527060340572, 0.10399880919437814)" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "from scipy import stats\n", + "\n", + "best_practice_score_ds = sorted(best_practice_score_ds)\n", + "plt.scatter(\n", + " [x for x, y in best_practice_score_ds], [y for x, y in best_practice_score_ds]\n", + ")\n", + "stats.pearsonr(\n", + " [x for x, y in best_practice_score_ds], [y for x, y in best_practice_score_ds]\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.5157738095238095\n" + ] + }, + { + "data": { + "text/plain": [ + "(0.6722543326178704, 0.03321124881554773)" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import re\n", + "\n", + "best_practice_score_se = sorted(best_practice_score_se)\n", + "\n", + "%matplotlib inline\n", + "plt.rcParams[\"figure.facecolor\"] = \"white\"\n", + "plt.rcParams[\"font.size\"] = 24\n", + "plt.rcParams[\"figure.figsize\"] = (14, 10)\n", + "\n", + "X = [x for x, y in best_practice_score_se]\n", + "Y = [y for x, y in best_practice_score_se]\n", + "\n", + "print(sum(Y) / len(Y))\n", + "sc = plt.scatter(X, Y, c=\"black\", s=[x * 50 for x, y in best_practice_score_ds])\n", + "plt.ylabel(\"Ratio of implemented deployment best practices\")\n", + "plt.xlabel(\"Years of professional software engineering experience\")\n", + "\n", + "\n", + "def best_fit(X, Y):\n", + " xbar = sum(X) / len(X)\n", + " ybar = sum(Y) / len(Y)\n", + " n = len(X)\n", + "\n", + " numer = sum([xi * yi for xi, yi in zip(X, Y)]) - n * xbar * ybar\n", + " denum = sum([xi**2 for xi in X]) - n * xbar**2\n", + "\n", + " b = numer / denum\n", + " a = ybar - b * xbar\n", + " return a, b\n", + "\n", + "\n", + "a, b = best_fit(X, Y)\n", + "yfit = [a + b * xi for xi in X]\n", + "plt.plot(X, yfit, \"b\", label=\"Best fit\")\n", + "plt.legend(\n", + " sc.legend_elements(\"sizes\", num=5)[0],\n", + " [\n", + " re.sub(r\"[^\\d]*(\\d+)[^\\d]*\", lambda v: f\"{int(v.group(1)) // 40} years (DS)\", t)\n", + " for t in sc.legend_elements(\"sizes\", num=5)[1]\n", + " ],\n", + ")\n", + "plt.tight_layout()\n", + "\n", + "plt.savefig(\"best-practices\", dpi=150)\n", + "\n", + "stats.pearsonr(\n", + " [x for x, y in best_practice_score_se], [y for x, y in best_practice_score_se]\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
I believe the use of GreatAI improves the quality of AI deployments.I believe the use of GreatAI would increase my productivity.I believe the use of GreatAI can lead to robust and trustworthy deployments.Overall, I found GreatAI useful when working with AI.I found the GreatAI easy to learn.I found it is easy to employ GreatAI in practice.I found it is easy to integrate GreatAI into an existing project.Overall, I found GreatAI easy to use.Assuming GreatAI is applicable to my task, I predict that I will use it on a regular basis in the future.Overall, I intend to use the GreatAI in my personal or professional projects.
07777777777
17767567677
24456654454
36767767676
47767455566
56666666666
66664576677
77666453556
84555723333
97777565677
\n", + "
" + ], + "text/plain": [ + " I believe the use of GreatAI improves the quality of AI deployments. \\\n", + "0 7 \n", + "1 7 \n", + "2 4 \n", + "3 6 \n", + "4 7 \n", + "5 6 \n", + "6 6 \n", + "7 7 \n", + "8 4 \n", + "9 7 \n", + "\n", + " I believe the use of GreatAI would increase my productivity. \\\n", + "0 7 \n", + "1 7 \n", + "2 4 \n", + "3 7 \n", + "4 7 \n", + "5 6 \n", + "6 6 \n", + "7 6 \n", + "8 5 \n", + "9 7 \n", + "\n", + " I believe the use of GreatAI can lead to robust and trustworthy deployments. \\\n", + "0 7 \n", + "1 6 \n", + "2 5 \n", + "3 6 \n", + "4 6 \n", + "5 6 \n", + "6 6 \n", + "7 6 \n", + "8 5 \n", + "9 7 \n", + "\n", + " Overall, I found GreatAI useful when working with AI. \\\n", + "0 7 \n", + "1 7 \n", + "2 6 \n", + "3 7 \n", + "4 7 \n", + "5 6 \n", + "6 4 \n", + "7 6 \n", + "8 5 \n", + "9 7 \n", + "\n", + " I found the GreatAI easy to learn. \\\n", + "0 7 \n", + "1 5 \n", + "2 6 \n", + "3 7 \n", + "4 4 \n", + "5 6 \n", + "6 5 \n", + "7 4 \n", + "8 7 \n", + "9 5 \n", + "\n", + " I found it is easy to employ GreatAI in practice. \\\n", + "0 7 \n", + "1 6 \n", + "2 5 \n", + "3 6 \n", + "4 5 \n", + "5 6 \n", + "6 7 \n", + "7 5 \n", + "8 2 \n", + "9 6 \n", + "\n", + " I found it is easy to integrate GreatAI into an existing project. \\\n", + "0 7 \n", + "1 7 \n", + "2 4 \n", + "3 7 \n", + "4 5 \n", + "5 6 \n", + "6 6 \n", + "7 3 \n", + "8 3 \n", + "9 5 \n", + "\n", + " Overall, I found GreatAI easy to use. \\\n", + "0 7 \n", + "1 6 \n", + "2 4 \n", + "3 6 \n", + "4 5 \n", + "5 6 \n", + "6 6 \n", + "7 5 \n", + "8 3 \n", + "9 6 \n", + "\n", + " Assuming GreatAI is applicable to my task, I predict that I will use it on a regular basis in the future. \\\n", + "0 7 \n", + "1 7 \n", + "2 5 \n", + "3 7 \n", + "4 6 \n", + "5 6 \n", + "6 7 \n", + "7 5 \n", + "8 3 \n", + "9 7 \n", + "\n", + " Overall, I intend to use the GreatAI in my personal or professional projects. \n", + "0 7 \n", + "1 7 \n", + "2 4 \n", + "3 6 \n", + "4 6 \n", + "5 6 \n", + "6 7 \n", + "7 6 \n", + "8 3 \n", + "9 7 " + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tam = pd.read_csv(\"Technology acceptance model questionnaire.csv\")\n", + "tam" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(0.8813771517996869, array([0.688, 0.967]))" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import pingouin\n", + "\n", + "pu = [\n", + " \"I believe the use of GreatAI improves the quality of AI deployments.\",\n", + " \"I believe the use of GreatAI would increase my productivity.\",\n", + " \"I believe the use of GreatAI can lead to robust and trustworthy deployments.\",\n", + " \"Overall, I found GreatAI useful when working with AI.\",\n", + "]\n", + "pingouin.cronbach_alpha(tam[pu])" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(0.7729220222793487, array([0.403, 0.937]))" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "peou = [\n", + " \"I found the GreatAI easy to learn.\",\n", + " \"I found it is easy to employ GreatAI in practice.\",\n", + " \"I found it is easy to integrate GreatAI into an existing project.\",\n", + " \"Overall, I found GreatAI easy to use.\",\n", + "]\n", + "pingouin.cronbach_alpha(tam[peou])" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(0.9538950715421304, array([0.814, 0.989]))" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "itu = [\n", + " \"Assuming GreatAI is applicable to my task, I predict that I will use it on a regular basis in the future.\",\n", + " \"Overall, I intend to use the GreatAI in my personal or professional projects.\",\n", + "]\n", + "pingouin.cronbach_alpha(tam[itu])" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
pupeouitu
07.007.007.0
16.756.007.0
24.754.754.5
36.506.506.5
46.754.756.0
56.006.006.0
65.506.007.0
76.254.255.5
84.753.753.0
97.005.507.0
\n", + "
" + ], + "text/plain": [ + " pu peou itu\n", + "0 7.00 7.00 7.0\n", + "1 6.75 6.00 7.0\n", + "2 4.75 4.75 4.5\n", + "3 6.50 6.50 6.5\n", + "4 6.75 4.75 6.0\n", + "5 6.00 6.00 6.0\n", + "6 5.50 6.00 7.0\n", + "7 6.25 4.25 5.5\n", + "8 4.75 3.75 3.0\n", + "9 7.00 5.50 7.0" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tam[\"pu\"] = tam[pu].mean(1)\n", + "tam[\"peou\"] = tam[peou].mean(1)\n", + "tam[\"itu\"] = tam[itu].mean(1)\n", + "tam[[\"pu\", \"peou\", \"itu\"]]" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "pu 6.125\n", + "peou 5.450\n", + "itu 5.950\n", + "dtype: float64" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tam[[\"pu\", \"peou\", \"itu\"]].mean()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "pu 6.375\n", + "peou 5.750\n", + "itu 6.250\n", + "dtype: float64" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tam[[\"pu\", \"peou\", \"itu\"]].median()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "pu 0.859990\n", + "peou 1.039498\n", + "itu 1.321825\n", + "dtype: float64" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tam[[\"pu\", \"peou\", \"itu\"]].std()" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(0.5515422017785757, 0.09838124227663879)" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "stats.pearsonr(tam[\"peou\"], tam[\"pu\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(0.8066270322592023, 0.004809023073123024)" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "stats.pearsonr(tam[\"peou\"], tam[\"itu\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(0.7880605510627579, 0.006774486564715021)" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "stats.pearsonr(tam[\"pu\"], tam[\"itu\"])" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.10.4 ('.env': venv)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.4" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "02dd6d3afbfa9fbbe1037d64ad9014965528a1ccad21929d6e72f466389a68ad" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/docs/thesis/chapters/0_abstract.tex b/docs/thesis/chapters/0_abstract.tex index 864fd4f..a76c581 100644 --- a/docs/thesis/chapters/0_abstract.tex +++ b/docs/thesis/chapters/0_abstract.tex @@ -1,16 +1,18 @@ \begin{abstract} \absdiv{Background} -Despite its long-standing history, artificial intelligence (AI) has only recently started enjoying widespread industry awareness and adoption; partly thanks to the prevalence of accessible frameworks exposing state-of-the-art models through simple API-s. In order to achieve robust production deployments, the successful integration of AI components demands strong engineering methods. Concerningly, a tendency seems to be unfolding: even though industry professionals already have access to frameworks for deploying AI correctly and responsibly, case-studies and developer surveys have found that a large fraction of deployments do not follow best practices. -\absdiv{Objective} -This thesis sets out to investigate the reasons behind the asymmetry between the adoption of accessible AI libraries and existing reusable solutions to robust deployments. A software framework called \textit{GreatAI} is designed which aims to facilitate \underline{G}eneral \underline{R}obust \underline{E}nd-to-end \underline{A}utomated \underline{T}rustworthy AI deployments while attempting to overcome the practical drawbacks of its predecessors. -\absdiv{Method} -The utility of \textit{GreatAI} is validated using the principles of design science methodology through iteratively designing its API and implementation along with the text mining pipeline of a commercial product. Subsequently, interviews are conducted with practitioners for validating the generalisability of the design. -\absdiv{Results} -To do. -\absdiv{Conclusions} -To do. +Despite its long-standing history, artificial intelligence (AI) has only recently started enjoying widespread industry awareness and adoption, partly thanks to the prevalence of libraries that accessibly expose state-of-the-art models. However, the transition from prototypes to production-ready AI applications is still a source of struggle across the industry. Even though professionals already have access to frameworks for deploying AI, case studies and developer surveys have found that many deployments do not follow best practices. -\keywords{SE4ML \and AI engineering \and Trustworthy AI \and Deployment \and Text mining} +\absdiv{Objective} +This thesis investigates the causes of and presents a possible solution to the asymmetry between the adoption of libraries for \textit{applying} and those for \textit{deploying} AI. The potential solution is validated through designing a software framework called \textit{GreatAI}, which aims to facilitate \underline{G}eneral \underline{R}obust \underline{E}nd-to-end \underline{A}utomated \underline{T}rustworthy deployments while attempting to overcome the practical drawbacks of earlier similar tools, e.g., \textit{Seldon Core}, \textit{AWS SageMaker}, and \textit{TensorFlow Extended}. + +\absdiv{Methods} +\textit{GreatAI} serves as a proxy for exploring the proposed design decisions; moreover, its initial focus is limited to the domain of natural language processing (NLP). Its design is created by applying the principles of design science methodology through iteratively shaping it in two case studies of a commercial NLP pipeline. Subsequently, interviews are conducted with ten practitioners to assess its applicability and generalisability. + +\absdiv{Results} +\textit{GreatAI} helps implement 33 best practices through an accessible interface. These target the transition between the prototype and production phases of the AI development lifecycle. Feedback from professional data scientists and software engineers showed that ease of use and functionality are equally important in deciding to adopt deployment technologies, and the proposed framework was rated positively in both dimensions. + +\absdiv{Conclusions} +Increasing the overall maturity of industrial AI deployments by devising APIs with ease of adoption in mind is proved to be feasible. While \textit{GreatAI} mainly focuses on NLP, the results show that the development and deployment of trustworthy AI services, in general, can be assisted by frameworks prioritising easy adoption while still streamlining the implementation of various best practices. \end{abstract} diff --git a/docs/thesis/chapters/1_introduction.tex b/docs/thesis/chapters/1_introduction.tex index 3231d1e..cf9c659 100644 --- a/docs/thesis/chapters/1_introduction.tex +++ b/docs/thesis/chapters/1_introduction.tex @@ -1,56 +1,34 @@ \chapter{Introduction} -Artificial intelligence (AI) techniques have recently started enjoying widespread industry awareness and adoption; the use of AI is increasingly prevalent in all sectors \cite{wirtz2019artificial,bosch2021engineering}. The reasons behind this are manifold \cite{jordan2015machine}, to name a few: recent breakthroughs in deep-learning, increased public awareness, abundance of available data, access to powerful low-cost commodity hardware, education, but most interestingly, the rise of high-level libraries making ready-to-use state-of-the-art (SOTA) models easily available. The latter practically abolishes the barrier of entry for applying AI --- and with that --- can help use-cases in many areas. +Artificial intelligence (AI) techniques have recently started enjoying widespread industry awareness and adoption; the use of AI is increasingly prevalent in all sectors \cite{wirtz2019artificial,bosch2021engineering}. The reasons behind this are manifold \cite{jordan2015machine}, to name a few: recent breakthroughs in deep learning (DL), increased public awareness, an abundance of available data, access to powerful low-cost commodity hardware, education, but most interestingly, the rise of high-level libraries making ready-to-use state-of-the-art (SOTA) models easily available. The latter radically lowers the barrier of entry for applying AI --- and with that --- can help use cases in various areas. -However, the successful integration of AI components into production-ready applications demands strong engineering methods in order to achieve robust deployments \cite{serban2020adoption}. That is why it is as important as ever to also focus on the quality and robustness of deployed models and software. For instance, the lack of a proper overview of the data transformation steps may lead to suboptimal performance and to introducing unintended biases which may contribute to the ever-increasing negative externality of misused AI \cite{o2016weapons}. +However, to achieve robust deployments, the successful integration of AI components into production-ready applications demands strong engineering methods \cite{serban2020adoption}. That is why it is as essential as ever to also focus on the quality of deployed models and software. For instance, the lack of a proper overview of data transformation steps may lead to suboptimal performance and to introducing unintended biases, which might contribute to the ever-increasing negative externality of misused AI \cite{o2016weapons}. -Concerningly, a peculiar tendency seems to be unfolding: even though industry professionals already have access to numerous frameworks for deploying AI correctly and responsibly, case-studies and developer surveys have found that a considerable fraction of deployments do not follow best practices \cite{serban2020adoption,haakman2021ai,amershi2019software,de2019understanding,sculley2015hidden}. Utilising state-of-the-art machine-learning (ML) models has become reasonably simple; applying them properly is as difficult and nuanced as ever. +Concerningly, a peculiar tendency seems to be unfolding: even though industry professionals already have access to numerous frameworks for deploying AI correctly and responsibly, case studies and developer surveys have found that a considerable fraction of deployments does not follow best practices \cite{serban2020adoption,haakman2021ai,amershi2019software,de2019understanding,sculley2015hidden}. Utilising state-of-the-art machine learning (ML) models has become reasonably simple; applying them correctly is as intricate and nuanced as ever. -This thesis sets out to investigate the reasons behind the apparent asymmetry between the adoption of accessible AI libraries and existing reusable solutions for robust AI deployments. It is hypothesised that the primary reason for the underwhelming adoption rate of best practices is the short supply or professionals equally proficient in the domains of both data science and software engineering. Nevertheless, even without their presence, practitioners could rely on frameworks for automated mature deployment processes. However, the barrier of entry for using such existing libraries is too high, especially when compared with the complexity of AI-libraries. +This thesis sets out to investigate the reasons behind the apparent asymmetry between industry adoption of accessible AI-libraries and existing reusable solutions for robust AI deployments. It is hypothesised that the primary reason for the underwhelming adoption rate of best practices is the short supply of professionals equally proficient in the domains of both data science and software engineering. Nevertheless, even without their presence, practitioners could rely on frameworks to achieve some level of automation and maturity in their deployment processes. However, the barrier of entry for using such existing libraries is too high, especially when compared with the simplicity of AI-libraries. -Therefore, a software framework --- called \textit{GreatAI} --- is designed and its design is presented in this thesis. The principal motivation behind the construction of \textit{GreatAI} is to facilitate the responsible and robust deployment of algorithms and models by designing an accessible API in an attempt to overcome the practical drawbacks of other, similar frameworks. Its name stands for its main aim: to assist easily creating \underline{G}eneral \underline{R}obust \underline{E}nd-to-end \underline{A}utomated, and \underline{T}rustworthy AI deployments. +Therefore, we design a software framework called \href{https://github.com/schmelczer/great-ai}{\textit{GreatAI}} and present it in this thesis. The principal motivation behind the construction of \textit{GreatAI} is to facilitate the responsible and robust deployment of algorithms and models by designing a more accessible API in an attempt to overcome the practical drawbacks of other similar frameworks. Its name stands for its main aim: to assist easily creating \underline{G}eneral \underline{R}obust \underline{E}nd-to-end \underline{A}utomated, and \underline{T}rustworthy AI deployments. -The utility of \textit{GreatAI} is validated using the principles of design science methodology \cite{wieringa2014design} through iteratively designing its API and implementation along with the text mining pipeline for a commercial product in collaboration with ScoutinScience B.V. The goal of the aforementioned software suite is to evaluate technical transfer opportunities in scientific publications. Subsequently, interviews are conducted with practitioners for validating the generalisability of the design. +The utility of \textit{GreatAI} is examined and refined using the principles of design science methodology \cite{wieringa2014design} through iteratively designing its API and implementation in two case studies concerning the natural language processing (NLP) pipeline of a commercial product in collaboration with \href{https://scoutinscience.com/}{ScoutinScience B.V.} The goal of the aforementioned software suite is to evaluate technology-transfer opportunities in scientific publications. Subsequently, interviews are conducted with practitioners to validate the broader applicability and generalisability of the design. + +The choice of case study subject is no coincidence; while working on the ScoutinScience Platform for the last two years, my colleagues and I have increasingly noticed the same recurring challenges in deploying and operating AI/ML pipelines. This has motivated me to pursue a general solution. Considering that the company's predominant field is NLP, the case studies, and hence, the prototype of \textit{GreatAI} will also focus primarily on deploying NLP models. Nonetheless, the motivation for creating a general solution for all AI/ML contexts remains and will be taken into account every step of the way. \section{Research questions} -I hypothesise that facilitating the adoption of AI deployment best practices is viable by finding less complex framework designs which are easier to adopt in order to decrease the negative externality of misused AI. This paper is set out to investigate this hypothesis by answering the following research questions. +We hypothesise that facilitating the adoption of AI deployment best practices is viable by finding less complex framework\footnote{The terms \textit{framework} and \textit{library} will be used interchangeably in this work stemming from their vague and often holistic differentiation.} designs that are easier to adopt in order to decrease the negative externality of misused AI. This paper investigates the hypothesis by answering the following research questions. \begin{rqlist} - \item Does the complexity of AI deployment frameworks hinder industrial projects? - \item What is an effective way of decreasing the complexity of existing frameworks? - \item Does \textit{GreatAI}'s design improve the efficiency of working with AI while also introducing best practices? - \item Can the design of \textit{GreatAI} decrease the barrier of entry for applying best practices in other contexts? + \item To what extent does the complexity of deploying AI hinder industrial applications? + \item What API design techniques can be effectively applied in order to decrease the complexity of correctly deploying AI services? + \item To what extent can \textit{GreatAI} automatically implement AI deployment best practices? + \item How suitable is the design of \textit{GreatAI} for helping to apply best practices in other contexts? \end{rqlist} -In this case, complexity is used to refer to the difficulty faced by professionals (data scientists and software engineers alike) when integrating libraries with their solutions. This could also be described as the barrier of entry or steepness of the learning curve. If the aforementioned hypothesis is correct, the adoption of best practices can be efficiently increased by decreasing this complexity. +In this case, complexity refers to the difficulty faced by professionals (Data Scientists and Software Engineers alike) when integrating third-party libraries with their solutions. This could also be described as the barrier of entry or steepness of the learning curve. If the aforementioned hypothesis is correct, the adoption of best practices can be efficiently increased by decreasing this complexity. AI deployment best practices entail the technical steps that ought to be taken to achieve robust, end-to-end, automated, and trustworthy deployments. These are detailed in Section \ref{section:requirements}. -AI deployment best practices entail the technical steps that ought to be taken in order to achieve robust, end-to-end, automated, and trustworthy deployments. These are detailed in Section \ref{section:requirements}. - -The existence question regarding the problem itself (\textbf{RQ1}) is answered by reviewing the literature of the more than 30 published case-studies. \textbf{RQ2} and \textbf{RQ3} are closely connected, the design and evaluation phases utilised to answer them follow an iterative process. They are examined in Chapter \ref{chapter:design} and Chapter \ref{chapter:case} respectively. The final evaluation step is to ascertain the capability of the framework design to generalise beyond a single subdomain and problem context. This question, \textbf{RQ4}, is investigated through interviews with industry professionals in Chapter \ref{chapter:interviews}. - -\section{Requirements} \label{section:requirements} - -The best practices (which will be referenced throughout the thesis) with which the \textit{GreatAI} design is concerned are a subset of those compiled by Serban et al. \cite{serban2020adoption}. The core requirements --- sets of covered best practices --- for a software solution that has the potential of improving our problem context are presented in the following along with some explanation and clarification of each of them. - -\paragraph{General} Albeit not explicitly in the list of best practices, compatibility is vital in encouraging adoption. Large projects oftentimes end up depending on numerous packages, each of which may impose some restrictions on the code: since these all have to be satisfied simultaneously, this can result in severe constraints on the application. - -The open-source scene of data-related libraries is vibrant. To take the example of data validation, there are at least 4 popular choices which offer varying but similar features: \href{https://github.com/SeldonIO/alibi-detect}{Alibi detect}, \href{https://github.com/PAIR-code/facets}{Facets}, \href{https://github.com/great-expectations/great_expectations}{Great Expectations}, and Data Linter \cite{hynes2017data}. The responsibility of choosing the most fitting solution falls on the user, thus, they should not be limited in this by \textit{GreatAI}. - -The programming language (PL) of the library should be its only non-general property. Fortunately, the de facto PL for data science is Python, hence, implementing the library in it should not significantly limit its applicability. - -\paragraph{Robustness} in software development can be achieved by preparing the application to gracefully handle errors, even unexpected ones \cite{bishop1998robust}. Errors can and will happen in practice: storing and investigating what has led to them is required to prevent future ones. In the case of ML, errors might not be as obvious to detect as in more traditional applications (see the above mentioned data validators). Even if a single feature's value falls outside the expected distribution, unexpected results can happen. In cases where this might lead to real-world repercussions, extra care has to be taken to construct as many safe-guards as feasible. \textit{GreatAI} should support its clients in doing so. - -\paragraph{End-to-end} In this case, it refers to end-to-end feedback. That is, feedback should be gathered on the real-world performance of the system, and this should be taken into account when designing/training the next iteration of the model. Static datasets may fail to capture the changing nature of real-life and can become outdated if they are not revised continuously. A well packaged deployment should make it trivial to integrate new training data. - -\paragraph{Automated} The available time of data scientists and software engineers is limited and expensive. For this reason, humans should only be involved when their involvement is necessary. Steps in the development process that can be automated without negative consequences must be automated in order to achieve efficient development processes and let the experts focus on the issues that require their attention the most. - -\paragraph{Trustworthy} As detailed by the \textit{Ethics guidelines for trustworthy AI}\footnote{\href{https://digital-strategy.ec.europa.eu/en/library/ethics-guidelines-trustworthy-ai}{digital-strategy.ec.europa.eu/en/library/ethics-guidelines-trustworthy-ai}}, human oversight, transparency, and accountability are some of the key requirements for trustworthy AI applications. For increasing public acceptance and trust while minimising negative societal impact, trustworthiness is essential. - -These requirements were chosen stemming from their general importance and potential to be mostly handled (implemented) by a software framework\footnote{The terms \textit{framework} and \textit{library} are used interchangeably in this work stemming from their vague and often holistic differentiation.}. That is why, these provide an ideal initial direction for tackling the issue. Of course, these do not cover all best practices, for instance, the ones relating to organisational processes fall outside the realm of software engineering. - -\newpage +The existence question regarding the problem itself (\textbf{RQ1}) is answered by reviewing the literature of more than 30 published case studies in Chapter \ref{chapter:background}. \textbf{RQ2} and \textbf{RQ3} are closely connected: the design and evaluation phases utilised to answer them follow an iterative process. They are examined in Chapters \ref{chapter:design} and \ref{chapter:case} respectively. The final evaluation step is to ascertain the capability of the framework's design to generalise beyond a single subdomain and problem context. This question, \textbf{RQ4}, is investigated through interviews with industry professionals in Chapter \ref{chapter:interviews}. \section{Structure} -The rest of the thesis is organised as follows: Chapter \ref{chapter:background} approaches the problem and the state-of-the-art from three perspectives: the trends of AI library API design, the experiences gained from practical applications, and a comparison of existing deployment options. Next, the methodology utilised for the subsequent chapters is described in Chapter \ref{chapter:methods}. The design cycle is broken into two chapters, Chapter \ref{chapter:design} and \ref{chapter:case}. The former clarifies the scope and describes the design principles, while the latter details the specifics of the practical use-case and the framework's interaction with it, and technological contributions of the novel design. The results are further validated by conducting interviews with industry professionals in Chapter \ref{chapter:interviews}. The thesis is concluded in Chapter \ref{chapter:conclusion}. +The rest of the thesis is organised as follows: Chapter \ref{chapter:background} approaches the problem and the state-of-the-art from three perspectives: the recent trends of AI-library API designs, the experiences gained from practical applications, and a comparison of existing deployment options. Next, the methodology utilised for the subsequent chapters is described in Chapter \ref{chapter:methods}. The design cycle is broken into two chapters, Chapter \ref{chapter:design} and \ref{chapter:case}. The former clarifies the scope and describes the design principles, while the latter details the specifics of the practical case studies and the framework's interaction with them. The contributions of the novel design and obtained results are shown and further validated by conducting interviews with industry professionals in Chapter \ref{chapter:interviews}. The thesis is concluded in Chapter \ref{chapter:conclusion}. diff --git a/docs/thesis/chapters/2_background.tex b/docs/thesis/chapters/2_background.tex index 029397b..acef523 100644 --- a/docs/thesis/chapters/2_background.tex +++ b/docs/thesis/chapters/2_background.tex @@ -1,48 +1,38 @@ \chapter{Background} \label{chapter:background} -Despite the long-standing history of artificial intelligence (AI), industry awareness and adoption has only recently started to meaningfully catch up \cite{wirtz2019artificial}. At the same time, more regulations and guidelines are being published, for instance, the Ethics guidelines for trustworthy AI by the European Commission's High-Level Expert Group on AI\footnote{\href{https://digital-strategy.ec.europa.eu/en/library/ethics-guidelines-trustworthy-ai}{digital-strategy.ec.europa.eu/en/library/ethics-guidelines-trustworthy-ai}}. This contains seven key requirements, including human agency and oversight, technical robustness, safety, transparency, and accountability. When it comes to accountability, there are meaningful advances being made \cite{raji2020closing}, however, in the case of the other requirements, the situation is more nuanced. Thankfully, the domain of software engineering for machine learning (SE4ML)\footnote{Both in practice and in the literature, this is sometimes also referred to as \textit{AI engineering} and has a large intersection with --- or arguably is the same as --- \textit{MLOps}.} has been working towards finding ways to assist data scientists in ensuring these (and more) expectations are met by their software. +Despite the long-standing history of artificial intelligence, industry awareness and adoption have only recently started to catch up meaningfully \cite{wirtz2019artificial}. At the same time, more regulations and guidelines are being published, for instance, the Ethics guidelines for trustworthy AI by the European Commission's High-Level Expert Group on AI\footnote{\href{https://digital-strategy.ec.europa.eu/en/library/ethics-guidelines-trustworthy-ai}{digital-strategy.ec.europa.eu/en/library/ethics-guidelines-trustworthy-ai}}. This contains seven key requirements, including human agency and oversight, technical robustness, safety, transparency, and accountability. When it comes to accountability, clear advances are being made \cite{raji2020closing}; however, in the case of the other requirements, the situation is more nuanced. Thankfully, the field of software engineering for machine learning (SE4ML)\footnote{Both in practice and literature, this is sometimes also referred to as \textit{AI Engineering} and has a large intersection with, or arguably is the same as, \textit{MLOps}.} has been working towards finding ways to assist data scientists and software engineers in ensuring these (and more) expectations are met by their software. -In the following, the context of the problem is presented from three perspectives. Starting with its possible cause: the democratisation of state-of-the-art AI algorithms and models. Subsequently, the challenges encountered when applying AI in practice is outlined by case studies and survey data. Lastly, the existing approaches and solutions are introduced. +In the following, the context of the problem is presented from three perspectives. Starting with its possible cause: the democratisation of state-of-the-art AI/ML\footnote{The terms AI and ML are often not differentiated and are used as synonyms in practice, for instance, see this study by the FDA \cite{food2019proposed}. ML is a well-defined subdomain of AI. However, most modern AI applications are also ML applications \cite{russell2010artificial}, hence, conflating the two terms may be slightly imprecise but usually not wrong.} architectures and models. Subsequently, the challenges encountered when applying AI in practice are outlined by case studies and survey data. Lastly, the existing approaches and solutions are introduced. \section{Accessible AI} \label{section:accessible-ai} -Most companies prefer not to develop new models but instead reuse prior ones \cite{bosch2021engineering} and they are able to do so increasingly easier. In recent years, there has been a proliferation of highly accessible AI libraries. For example, let us consider the domain of natural language processing (NLP). There are various options for finding AI solutions that work out of the box: FLAIR \cite{akbik2019flair} and Huggingface's transformers \cite{wolf2019huggingface} let developers access the state-of-the-art models and methods in only a couple of lines of code (in many cases 2 or 3). With the advent of fine-tuneable models such as BERT \cite{devlin2018bert} and its many improved variations, Huggingface enables developers to leverage vast amounts of knowledge learned by any particular model and fine-tune it for their specific use case. The API for this is also extremely accessible. +Most companies prefer not to develop new models but instead reuse prior ones \cite{bosch2021engineering}, and they are able to do so increasingly easily. In recent years, there has been a proliferation of highly accessible AI-libraries, many of which provide reusable models. For example, let us consider the domain of natural language processing. There are various options for finding AI solutions that work out of the box: FLAIR \cite{akbik2019flair} and Hugging Face's transformers \cite{wolf2019huggingface} let developers access state-of-the-art models and methods in only a couple of lines of code (in many cases 2 or 3). Using transfer-learning, Hugging Face enables its users to leverage vast amounts of knowledge learned by pretrained models (such as BERT \cite{devlin2018bert} and its many improved variations) and fine-tune them for their specific use case. The API exposing this is also extremely accessible. -It is not just these two packages, the list of readily available tools for language processing is vast: SpaCy \cite{srinivasa2018natural}, Gensim \cite{vrehuuvrek2011gensim}, and scikit-learn \cite{pedregosa2011scikit} are other great examples. The situation is similar in all subdomains of artificial intelligence: some domain expertise is --- admittedly --- beneficial but not a hard-requirement. This, combined with the exponentially increasing computing power affordably available to consumers and business alike \cite{sun2019summarizing}, results in AI that is accessible by many. +It is not just these two libraries, the list of readily available solutions is vast: SpaCy \cite{srinivasa2018natural}, Gensim \cite{vrehuuvrek2011gensim}, scikit-learn \cite{pedregosa2011scikit}, and XGBoost \cite{Chen_2016} are other great examples. The situation is similar in all subdomains of artificial intelligence: some domain expertise is --- admittedly --- beneficial but not a hard-requirement. This, combined with the exponentially increasing computing power affordably available to consumers and businesses alike \cite{sun2019summarizing}, results in AI that is accessible by many. \section{State of the industry} \label{section:industry} -In contrast with this trend, the software landscape around packaging, deploying, and maintaining machine learning (ML) --- and in general --- data-heavy applications paints a different picture. Fortunately, the related issues and their ramifications have been already thoroughly investigated. +In contrast to this trend, the software landscape around packaging, deploying, and maintaining machine learning (ML) --- and in general --- data-heavy applications paints a different picture. Fortunately, the related issues and their ramifications have already been thoroughly investigated. -When looking at ML code in practice through the lens of technical debt, Sculley et al. \cite{sculley2015hidden} emphasise the repercussions of writing \textit{glue code} between the algorithms and different systems or libraries and define it as an anti-pattern. The consequence of this is the advice against using generic libraries because their rigid API-s may inhibit improvements, cause lock-in, and result in large amounts of glue code. This is a recurring theme in discussions with industry professionals. +When looking at AI/ML code in practice through the lens of technical debt, Sculley et al. \cite{sculley2015hidden} emphasise the repercussions of writing \textit{glue code} between the algorithms and different systems or libraries and define it as an anti-pattern. The consequence of this is the advice against using generic libraries because their rigid APIs may inhibit improvements, cause lock-in, and result in large amounts of glue code. This is a recurring theme in discussions with industry professionals. -Haakman et al. \cite{haakman2021ai} interviewed 17 people at ING which is a well-known fintech company undergoing a digital transformation to embrace AI. They found that the existing tools for ML do not meet the particularities of the field. For instance, a Feature Engineer working in the Data \& Analytics department explained that regular spreadsheets are preferred over existing solutions like MLFlow for keeping track of experiment results. The reason behind this is simplicity. Additionally, multiple other interviewees described the need to self-develop (or highly-customize) dashboards for monitoring deployed models which results in many non-reusable solutions across the company for the same problem. The authors conclude that there is a research gap between the ever-improving SOTA techniques and the challenges of developing real-world ML systems. In short, additional tool support is needed for facilitating the ML lifecycle. +Haakman et al. \cite{haakman2021ai} interviewed 17 people at ING, a well-known fintech company undergoing a digital transformation to embrace AI. They found that the existing tools for ML do not meet the particularities of the field. For instance, a Feature Engineer working in the Data \& Analytics department explained that regular spreadsheets are preferred over existing solutions like MLFlow for keeping track of experiment results. The reason behind this is simplicity. Additionally, multiple other interviewees described the need to self-develop (or highly-customise) dashboards for monitoring deployed models, resulting in many non-reusable solutions across the company for the same problem. The authors conclude that there is a research gap between the ever-improving SOTA techniques and the challenges of developing real-world ML systems. In short, additional tool support is needed for facilitating the ML lifecycle. -In a case study at Microsoft, Amershi et al. \cite{amershi2019software} interviewed 14 people and surveyed another 551 AI and ML professionals from the company. One of the main concerns surfaced was relating to automation which is a vital cross-cutting concern, especially for testing. At the same time, a human-in-the-loop is still favoured. The survey data pointed out the difficulty posed by integrating AI, especially in the case of less experienced respondents. This was elaborated on by describing the preferences of software engineers as striving for elegant, abstract, modular, and simple systems; in contrast, data tends to be of large volume, context-specific and heterogeneous. Reconciling these inherent differences requires significant effort, nevertheless, Microsoft manages to overcome this with highly sophisticated internal infrastructure. +In a case study at Microsoft, Amershi et al. \cite{amershi2019software} interviewed 14 people and surveyed another 551 AI and ML professionals from the company. One of the main concerns surfaced was relating to automation which is a vital cross-cutting concern, especially for testing. At the same time, a human-in-the-loop is still favoured. The survey data pointed out the difficulty posed by integrating AI, especially in the case of less experienced respondents. This was elaborated on by describing the preferences of software engineers as striving for elegant, abstract, modular, and simple systems; in contrast, data tends to be of large volume, context-specific and heterogeneous. Reconciling these inherent differences requires significant effort. Nevertheless, Microsoft manages to overcome this with a highly sophisticated internal infrastructure. -Using AI is not unique to large companies, in a study conducted with the collaboration of three startups \cite{de2019understanding}, the aim was to fill in the gap of understanding how professionals develop ML systems in small companies. Overall, the results showed they have similar priorities to that of large companies, including an emphasis on the online monitoring of deployed models. However, less structure is present in the development lifecycle, as one interviewee had explained: some steps are left out from time to time because they are forgotten about. -%The paper does not give detail about the use or in-house development of ML tools. -Similarly, Thiée \cite{thiee2021systematic} describes the slow but ever-growing rate of ML adoption by small and medium-sized enterprises (SMEs). With the caveat that many more of these companies would wish to adopt data-driven approaches but are facing new challenges stemming from the domain's complexity. +Using AI is not unique to large corporations; in a study conducted with the collaboration of three startups \cite{de2019understanding}, the aim was to fill in the gap of understanding how professionals develop ML systems in small companies. Overall, the results showed they have similar priorities to that of large companies, including an emphasis on the online monitoring of deployed models. However, less structure is present in the development lifecycle, as one interviewee explained: some steps are left out from time to time because they are forgotten. Similarly, Thiée \cite{thiee2021systematic} described the slow but ever-growing rate of ML adoption by small and medium-sized enterprises (SMEs). With the caveat that many more of these companies would wish to adopt data-driven approaches but are facing new challenges stemming from the domain's complexity. -Serban et al. \cite{serban2020adoption,serban2021practices} describe the results of their global surveys aiming to ascertain the SOTA in how teams develop, deploy, and maintain ML systems. In \cite{serban2020adoption}, they compiled a set of 29 actionable best practices. These were analysed and validated with a survey of 313 participants to discover the adoption rate and relative importance of each best practice. For example, they determined the most important best practice to be \textit{logging production prediction traces}, however, the adoption was measured to be below 40\%. In more than three quarters of the cases, newcomers to AI reported that they \textit{partially} or \textit{not at all} follow best practices. This tendency decreases with more years of experience, reaching a minimum of just below 40\%. In a similar fashion, Serban et al. in \cite{serban2021practices}, identify another 14 best practices that concern trustworthy AI mainly through data governance. They strive to complement high-level checklists with actionable best practices. Analysing 42 survey responses reveals a familiar pattern. Most best practices have less than 50\% adoption. +Serban et al. \cite{serban2020adoption,serban2021practices} described the results of their global surveys aiming to ascertain the SOTA in how teams develop, deploy, and maintain ML systems. In \cite{serban2020adoption}, they compiled a set of 29 actionable best practices. These were analysed and validated with a survey of 313 participants to discover the adoption rate and relative importance of each. For example, they determined the most important best practice to be \textit{logging production prediction traces}; however, the adoption was measured to be below 40\%. In more than three-quarters of the cases, newcomers to AI reported that they \textit{partially} or \textit{not at all} follow best practices. This tendency decreases with more years of experience, reaching a maximum adoption rate of just above 60\%. Furthermore, Serban et al., in \cite{serban2021practices}, identified another 14 best practices that concern trustworthy AI, mainly through data governance. They strove to complement high-level checklists with actionable best practices. Analysing 42 survey responses revealed a familiar pattern: most best practices had less than 50\% adoption. -Finally, Bosch et al. \cite{bosch2021engineering} organise and structure the problem space of AI engineering research based on their 16 primary case-studies. The authors note the increasing and broad adoption of ML in the industry, while also emphasising that \textit{transition from prototype to production-quality deployment} proves to be challenging for many companies. Large amounts of software engineering expertise is required to create additional facilities for the application such as data pipelines, monitoring, and logging. They define \textit{deployment \& compliance} to be one of the four main categories of problems and describe it as highly underestimated and the source of ample struggle. +John et al. \cite{john2020architecting} compared and contrasted recent scientific and grey literature on AI deployments from which they extracted concrete challenges and practices. They also observed that most companies are placing many more models into production than in previous years. Additionally, they pointed out that numerous deployment techniques are absent from contemporary literature, which is speculated to be caused by the immaturity of deployment processes employed in academia. Because for instance, most models in scientific literature experience only initial deployment and are not constantly replaced or refreshed as their performance degrades over time. + +Finally, in a follow-up study to \cite{john2020architecting}, Bosch et al. \cite{bosch2021engineering} organised and structured the problem space of AI engineering research based on their 16 primary case studies. The authors noted the increasing and broad adoption of ML in the industry while also emphasising that the \textit{transition from prototype to production-quality deployment} proves to be challenging for many companies. Solid software engineering expertise is required to create additional facilities for the application, such as data pipelines, monitoring, and logging. They defined \textit{deployment \& compliance} to be one of the four main categories of problems and described it as highly underestimated and the source of ample struggle. \section{Existing solutions} \label{section:existing} -From the previous section, it is noticeable that given enough resources and at the scale of 4195 AI professionals, Microsoft managed to create a comprehensive in-house solution. A similar impression is given by Uber \cite{li2017scaling}; they built a highly sophisticated infrastructure using techniques from distributed and high-performance computing. Though, the authors note that even this solution has its shortcomings in the form rigidity (number of supported libraries and model types) but it still allows the easy extension of the system. +It is noticeable that given enough resources and at the scale of 4195 AI professionals, Microsoft managed to create a comprehensive in-house solution. A similar impression is given by Uber \cite{li2017scaling}; they built a highly sophisticated infrastructure using techniques from distributed and high-performance computing. Though the authors note that this solution still has shortcomings in the form of rigidity (number of supported libraries and model types), it also allows for the easy extension of the system. Given the nature of the concerns and the amount of available resources, it is not surprising that both high-tech Fortune 500 companies needed to and did overcome the problems presented by deploying AI. We can learn from their approaches; nonetheless, using them may be infeasible for individuals and SMEs. Thus, the issues remain for the majority of practitioners. -Given the nature of problems faced and amount of available resources, it is not surprising the both of these high-tech, Fortune 500 companies needed to, and did overcome the problems presented by deploying AI. We can learn from their approaches, nonetheless, using them may be infeasible for individuals and SMEs, thus, the issues remain for the majority of practitioners. Luckily, the open-source scene of AI/ML/DS tools, libraries, frameworks, and platforms is thriving. Additionally, there is a considerable number of closed-source --- usually platforms-as-a-service (PaaS) --- solutions next to them. Let us look at some prominent examples. - -IBM's AutoAI \cite{wang2020autoai} promises to provide automation for the entire machine learning lifecycle, including deployment. It is a closed-sourced, paid service which --- from their documentation --- seems to focus mostly on non-technical users by providing them with a UI for authoring models. The restrictions caused by the encapsulation of the entire process can be severe. The challenges of integration were emphasised above \cite{sculley2015hidden}. Additionally, an engineer working on Microsoft's comparable solution, the Azure ML Studio, highlighted that once users gain enough understanding of ML, such visual tools can get in their way, and they may need to seek out other solutions \cite{amershi2019software}. Unfortunately, the main value proposition of Azure ML Studio is also to provide a UI for laypeople, and it has also been set to be retired by 2024. Its successor is Azure Machine Learning which shares many similarities with AWS's SageMaker suite \cite{joshi2020amazon}. - -SageMaker offers the most comprehensive suite of tools and service; most importantly it has a set of features called \textit{AWS SageMaker MLOps}. This provides easy and/or default implementations for industry best practices described by Serban et al. \cite{serban2020adoption,serban2021practices}. Among others, it promotes the use of CI/CD, model monitoring, tracing, model versioning, storing both data and models on shared infrastructure, numerous collaboration tools, etc. Nonetheless, SageMaker does not enjoy universal adoption as indicated by the survey data. The cause of this may be the lack of self-hosting option and its relatively high prices: many companies prefer on-premise hosting for privacy and financial reasons \cite{bosch2021engineering}. Additionally, vendor lock-in, and possibly --- in the case where it is not already used for the project --- the initial effort required for setting up AWS integration could be possible deterrents. - -When it comes to open-source libraries, we can find the MLOps libraries of both TensorFlow and PyTorch: TensorFlow Extended (TFX) \cite{baylor2017tfx} and TorchX\footnote{\href{https://pytorch.org/torchx/latest/}{pytorch.org/torchx/latest}}. TFX comes with a more mature set of features with the caveat that initial time-investment is needed for their setup. The features of TorchX only concern the distributed deployment to a wide range of providers, including Kubernetes, AWS Batch, or Ray. There is no augmentation for the SE4ML best practices. Given the tight coupling between these libraries and their corresponding ML frameworks, they cannot generalise to models\footnote{The Open Neural Network Exchange (\href{https://onnx.ai/}{onnx.ai}) format could be an option for overcoming these incompatibilities, however, a more universal support is needed for seamless integration.} or algorithms of other frameworks and technologies. - -Open-source platforms also exist such as MLflow and Seldon Core. They both rely on Kubernetes (k8s) to provide their features. MLflow puts more emphasis on the training phase (in deployment, it lacks a feedback loop which is essential to reach many of the best-practices), while Seldon Core focuses on the deployment stage. The latter comes integrated with a powerful explanation engine, Alibi Explain \cite{klaise2021alibi}. It also boasts the most comprehensive suite of features including outlier detection, online model selection (with multi-armed bandit theory), and distributed tracing. In short, it seems to be the ideal candidate for the title of \textit{framework for robust end-to-end AI deployments}. Its only downside is the amount of complexity propagated to its clients: it is built on top of Kubernetes, and relies on Helm, Ambasador/Istio, Prometheus, and Jaeger for its features. Hence, the first step in using it setting up a k8s cluster with all the required components, then when it comes to model deployment, a Kubernetes configuration file has to be created to make use of Seldon's Custom Resource Definition. These are smaller obstacles if the project is already built on top of k8s; however, even then, software engineers with strong cloud and DevOps background are actively required for using Seldon Core. - -\begin{table} +\begin{table}[H] \centering \begin{threeparttable} \caption{High-level comparison of popular AI deployment platforms and libraries.} @@ -51,30 +41,46 @@ Open-source platforms also exist such as MLflow and Seldon Core. They both rely {\renewcommand{\arraystretch}{1.2} % for the vertical padding \begin{tabular}{|l|c|c|c|c|c|c|c|} \hline - & AutoAI & Azure ML & SageMaker & TFX & TorchX & MLflow & Seldon Core \\ \hline -Open-source & & & & \checkmark & \checkmark & \checkmark & \checkmark \\ \hline -Free & & & & \checkmark & \checkmark & \checkmark & \checkmark \\ \hline -Vendor-agnostic & & & & \checkmark & \checkmark & \checkmark & \checkmark \\ \hline -AI-agnostic & & \checkmark & \checkmark & & & \checkmark & \checkmark \\ \hline -E2E feedback & & \checkmark & \checkmark & & & & \checkmark \\ \hline -Distributed monitoring & & \checkmark & \checkmark & \checkmark & \checkmark & \checkmark\textsuperscript{*} & \checkmark \\ \hline -Online model selection & \checkmark & \checkmark & \checkmark & & & & \checkmark \\ \hline -Versioning & \checkmark & \checkmark & \checkmark & \checkmark & \checkmark & \checkmark & \checkmark \\ \hline -Quick setup & \checkmark & \checkmark & & & & & \\ \hline -No dependencies (k8s, cloud) & & & & & \checkmark & & \\ \hline + & AutoAI & Azure ML & SageMaker & TFX & TorchX & MLflow & Seldon Core \\ \hline +Open-source\textsuperscript{1} & & & & \checkmark & \checkmark & \checkmark & \checkmark \\ \hline +Self-hosted\textsuperscript{1} & & & & \checkmark & \checkmark & \checkmark & \checkmark \\ \hline +Vendor-agnostic\textsuperscript{2} & & & & \checkmark & \checkmark & \checkmark & \checkmark \\ \hline +AI-agnostic\textsuperscript{2} & & \checkmark & \checkmark & & & \checkmark & \checkmark \\ \hline +E2E feedback\textsuperscript{3} & & \checkmark & \checkmark & & & & \checkmark \\ \hline +Distributed monitoring\textsuperscript{3} & & \checkmark & \checkmark & \checkmark & \checkmark & \checkmark\textsuperscript{*} & \checkmark \\ \hline +Online model selection\textsuperscript{3} & \checkmark\textsuperscript{*} & \checkmark & \checkmark & & & & \checkmark \\ \hline +Versioning\textsuperscript{3} & \checkmark & \checkmark & \checkmark & \checkmark & \checkmark & \checkmark & \checkmark \\ \hline +Quick setup\textsuperscript{4} & \checkmark & \checkmark & & & & & \\ \hline +No DevOps dependencies\textsuperscript{4}& & & & & \checkmark & & \\ \hline \end{tabular}} \begin{tablenotes} +\item[1] For privacy and accountability reasons. \cite{bosch2021engineering} +\item[2] Minimising required glue code. \cite{sculley2015hidden} +\item[3] Implementing best practices. \cite{serban2020adoption,serban2021practices,john2020architecting} +\item[4] Easy integration into existing processes. \cite{haakman2021ai,thiee2021systematic} \item[*] Only partial support. \end{tablenotes} \end{threeparttable} \end{table} -Table \ref{table:platform-comparison} shows a high-level overview about the general properties, and some of the features relating to the \textit{Deployment} stage of the CRISP-DM model \cite{wirth2000crisp}. It makes it apparent that there is a coexistence of persisting problems and their promised solutions. +Luckily, the open-source scene of AI/ML/DS tools, libraries, frameworks, and platforms is thriving. Additionally, there is a considerable number of closed-source --- usually platforms-as-a-service (PaaS) --- solutions next to them. Let us look at some prominent examples. Table \ref{table:platform-comparison} shows a high-level comparison of frameworks along the dimensions in which practitioners reportedly face difficulties in the \textit{Deployment} stage of the CRISP-DM model \cite{wirth2000crisp}. -Additionally, increasing attention is given to ML deployments in embedded systems both from a theoretical \cite{john2020ai} and practical \cite{prado2020bonseyes} point of view. Prado et al. \cite{prado2020bonseyes} survey the available deployment frameworks and end-to-end solutions including those for embedded devices. They note their inefficiencies that come from the lack of features and too much rigidity. They introduce their framework for embedded AI deployments which can be used out-of-the box but also lets the users easily replace and extend its pipeline with steps to fit their changing needs and advancements of the field. While Meenu et al. \cite{john2020ai} present and compare different architectural choices for large-scale deployments in edge-computing. They also note that: \textit{"...there is a need to consider and adapt well established SE practices which have been ignored or had a very narrow focus in ML literature"}. +IBM's AutoAI \cite{wang2020autoai} promises to provide automation for the entire machine learning lifecycle, including deployment. It is a closed-sourced, paid service which --- from their documentation --- seems to focus primarily on non-technical users by providing them with a graphical user interface (GUI) for authoring models. The restrictions caused by the encapsulation of the entire process can be severe: the challenges of integration were emphasised above \cite{sculley2015hidden}. Additionally, an engineer working on Microsoft's comparable solution, the Azure ML Studio, highlighted that once users gain enough understanding of ML, such visual tools can get in their way, and they may need to seek out other solutions \cite{amershi2019software}. Unfortunately, the main value proposition of Azure ML Studio is also to provide a GUI for laypeople, and it has also been set to be retired by 2024. Its successor is Azure Machine Learning which shares many similarities with AWS's SageMaker suite \cite{joshi2020amazon}. + +SageMaker offers the most comprehensive suite of tools and services; most importantly, it has a set of features called \textit{AWS SageMaker MLOps}. This provides easy and/or default implementations for multiple industry best practices described in \cite{serban2020adoption,serban2021practices,john2020ai}. Among others, it promotes using CI/CD, model monitoring, tracing, model versioning, storing both data and models on shared infrastructure, numerous collaboration tools, etc. Nonetheless, SageMaker does not enjoy universal adoption, as indicated by the survey data. The cause of this may be the lack of a self-hosting option and its relatively high prices: many companies prefer on-premise hosting for privacy, and financial reasons \cite{bosch2021engineering}. Additionally, vendor lock-in and possibly --- in the case where it is not already used for the project --- the initial effort required for setting up AWS integration could be likely deterrents. + +When it comes to open-source libraries, we can find the MLOps libraries of both TensorFlow and PyTorch: TensorFlow Extended (TFX) \cite{baylor2017tfx} and TorchX\footnote{\href{https://pytorch.org/torchx/latest/}{pytorch.org/torchx/latest}}. TFX comes with a more mature set of features with the caveat that initial time investment is needed for their setup. The features of TorchX only concern the distributed deployment to a wide range of providers, including Kubernetes (K8s), AWS Batch, or Ray \cite{moritz2018ray}. There is no augmentation for most deployment best practices. Given the tight coupling between these libraries and their corresponding ML frameworks, they cannot generalise to models or algorithms of other frameworks and technologies. The Open Neural Network Exchange\footnote{\href{https://onnx.ai/}{onnx.ai}} format could be an option for overcoming these incompatibilities. However, wider support would be needed for seamless integration. + +Open-source platforms also exist, such as MLflow and Seldon Core. They both rely on Kubernetes to provide their features. MLflow emphasises the training phase (in deployment, it lacks a feedback loop which is essential for reaching many of the best practices), while Seldon Core focuses on the deployment stage. The latter comes integrated with a powerful explanation engine, Alibi Explain \cite{klaise2021alibi}. It also boasts the most comprehensive suite of features, including outlier detection, online model selection (with multi-armed bandit theory), and distributed tracing. + +In short, it seems to be the ideal candidate for the title of \textit{framework for robust end-to-end AI deployments}. Its only downside is the amount of complexity propagated to its clients: it is built on top of Kubernetes and relies on Helm, Ambassador/Istio, Prometheus, and Jaeger for its features. Hence, the first step in using it is setting up a K8s cluster with all the required components; then, when it comes to model deployment, a Kubernetes configuration file must be created to use Seldon's Custom Resource Definition. These are minor obstacles if the project is already built on top of K8s; however, even then, software engineers with solid cloud and DevOps backgrounds are actively required to use Seldon Core. + +Additionally, increasing attention is given to ML deployments in embedded systems both from a theoretical \cite{john2020ai} and practical \cite{prado2020bonseyes} point of view. Prado et al. \cite{prado2020bonseyes} survey the available deployment frameworks and end-to-end solutions, including those for embedded devices. They note the inefficiencies of these that come from the lack of features and too much rigidity. They introduce their framework for embedded AI deployments, which can be used out-of-the-box but also lets users easily replace and extend its pipeline to fit their changing needs and advancements in the field. + +At the same time, Meenu et al. \cite{john2020ai} present and compare different architectural choices for large-scale deployments in edge computing. They also note that: \textit{``...there is a need to consider and adapt well-established software engineering practices which have been ignored or had a very narrow focus in ML literature''}. In summary, the issues expressed in Section \ref{section:industry} can be understood when looking at the available solutions. \section{Summary} -The surveys and case-studies have shown the industry's continuous struggle to evolve their prototypes into robust and responsible production-ready deployments. Simultaneously, platforms aiming to help overcome this challenge already exist but lack widespread adoption. The frequently recurring explanations for not adopting pre-existing solutions surfaced in Section \ref{section:industry} revolve around their complexity and rigidity. These complaints are validated when looking at the available frameworks in Section \ref{section:existing}. While using AI has become more accessible than ever, deploying remains challenging owing to the lack of any \textit{easy-to-use framework for robust end-to-end AI deployments}. +The surveys and case studies have shown the industry's continuous struggle to evolve prototypes into robust and responsible production-ready deployments. Simultaneously, platforms aiming to help overcome this challenge already exist but lack widespread adoption. The frequently recurring explanations for not adopting existing solutions surfaced in Section \ref{section:industry} revolve around their complexity and rigidity. These complaints are validated when looking at the available frameworks in Section \ref{section:existing}. While using AI has become more accessible than ever, deploying remains challenging owing to the lack of any easy-to-adopt framework for robust end-to-end AI deployments. -The coexistence of multiple major obstacles along with their promised solutions and the lack of their wide-spread adoption leads us to believe that current frameworks are inadequate for many contexts. There is an unmet need for accessible AI deployment methods. The revolution brought by FLAIR, HuggingFace, and similar libraries for the domain of ML remains unmatched in the domain of AI engineering. +The coexistence of multiple major obstacles, along with their promised solutions and the lack of their widespread adoption, leads us to believe that current frameworks are inadequate for many contexts, especially in cases where teams lack the background in cloud, operations, and more generally, software engineering. Thus, the answer to \textbf{RQ1} is that the complexity of deploying AI can severely hinder industrial applications even in the presence of existing frameworks. There is an unmet need for accessible AI deployment methods. The revolution brought by FLAIR, Hugging Face, and similar libraries for the domain of AI/ML remains unmatched in the field of AI Engineering and MLOps. diff --git a/docs/thesis/chapters/3_methods.tex b/docs/thesis/chapters/3_methods.tex index 10bb2ae..c3f512c 100644 --- a/docs/thesis/chapters/3_methods.tex +++ b/docs/thesis/chapters/3_methods.tex @@ -1,27 +1,45 @@ \chapter{Methods} \label{chapter:methods} -The chosen methodology for this study is Design Science which emphasises the need to design and investigate artifacts in their context \cite{wieringa2014design}. It consists of a design and an empirical cycle. The purpose of the former is to improve a problem context with a new or redesigned artifact. While in the latter, the problem is investigated and its potential treatment is validated concurrently. The design cycle shares similarities with Action Research \cite{davison2004principles}, where the researchers attempt to solve a real-world problem while simultaneously studying the experience of solving said problem. +The chosen methodology for this study is Design Science which emphasises the need to design and investigate artifacts in their contexts \cite{wieringa2014design}. It consists of a design and an empirical cycle. The purpose of the former is to improve a problem context with a new or redesigned artifact, while in the latter, the problem is investigated, and its potential treatment is validated concurrently. This strategy seems fitting for our problem in consequence of its practical nature. -As for the empirical cycle, the pragmatist approach is taken since the value of this research lies in its utility. Moreover, pragmatism adopts an engineering approach to research \cite{shull2007guide} which is inline with the philosophy of design science. Additionally, as no research method is without flaws, it is imperative to try to compensate their weaknesses by applying multiple methods. Hence, the study also relies on interviews with professionals for validating the design decisions of \textit{GreatAI}. +The design cycle shares similarities with Action Research \cite{davison2004principles} in which researchers attempt to solve a real-world problem while simultaneously studying the experience of solving said problem. As for the empirical cycle, the pragmatist approach is taken since the value of this research lies in its utility. Moreover, pragmatism adopts an engineering approach to research \cite{shull2007guide}, which happens to be in line with the philosophy of design science. Additionally, as no research method is without flaws, it is imperative to try to compensate for their weaknesses by applying multiple methods. Hence, the study also relies on interviews with professionals to validate the design decisions and determine the generalisability of \textit{GreatAI}. -\section{Problem context} +\section{Design cycle} -The problem context is the difficulty in responsibly transitioning (while following best practices) from prototype industrial AI applications to production-ready deployments. With the possible treatment being libraries with high-level API-s and a set of default settings. It is important to note that \textit{GreatAI} is merely a proof-of-concept, and its aim is to serve as the proxy for the design decisions behind it. Through this, the design can be indirectly evaluated. Hopefully, a by-product will be a library that can be successfully applied to this problem context. - -The practical cases used for the evaluation are further elaborated in Chapter \ref{chapter:case}. In short, they focus on individual components of a growing commercial platform with the aim of finding tech-transfer opportunities in academic publications. The main input of the system as a whole are individual PDF-files while the output is a list of metrics describing various aspects of the paper, such as interesting sentences, scientific domains, and the scientific contribution. The output also includes a predicted score used for ranking. This ranking is subsequently processed by the business developers of Technology Transfer Offices (TTO-s) of multiple Dutch and German universities who later give feedback on the results. - -Overall, this problem context carries the properties of typical industry use-cases: it utilises a wide-range of text mining methods, contains complex interactions between the services, benefits from the integration of end-to-end feedback, and has to provide the clients with a platform that they can rely on in their organisation's core processes. Since the final ranking affects real people, explainability and robustness are also central questions. - -\section{Design \& empirical cycles} - -The aim of the project can be summarised using the terminology of design science in the following way: -\textit{Facilitate the easy adoption of AI deployment best practices +The aim of \textit{GreatAI} can be summarised using the terminology of design science in the following way: +\textit{Facilitate the adoption of AI deployment best practices by finding a less complex framework design which is easier to adopt -to decrease the negative externality of misused AI.} +in order to decrease the negative externality of misused AI.} -However, before generalising, the design of the framework is iteratively refined using the feedback acquired from applying it in practical contexts which in this case is the research and development of a smaller and a more complex AI component followed by refactoring larger AI-based applications using the finished framework. The treatment is finding a simpler design which still leads to high-quality deployments as defined in Section \ref{section:requirements}. \textbf{RQ2} and \textbf{RQ3} captures this process; for investigating the feedback acquired from iteratively working --- which is the definition of action research --- on the case will be valuable. +The problem context is the difficulty of responsibly transitioning (while following best practices) from prototype industrial AI applications to production-ready deployments. With the possible treatment being libraries with high-level APIs and a set of default settings. It is important to note that \textit{GreatAI} is merely a proof-of-concept, and its aim is to serve as a proxy for the design decisions behind it. Through this, the design can be indirectly evaluated. Hopefully, a by-product will be a library that can be effectively applied to this problem context. -To answer how well the design of \textit{GreatAI} can generalise (\textbf{RQ4}), interviews will be conducted from a population of software engineers and data scientists with varying levels of professional background. Since me and my colleagues are likely to have a bias for (or against) the proposed designs, the first step of checking its applicability in other practical contexts is to ask the opinion of non-affiliated fellow practitioners. +The practical cases used for the evaluation are further elaborated in Chapter \ref{chapter:case}. In short, they focus on individual components of a growing commercial platform which aims to find tech-transfer opportunities in academic publications. The primary input of the system as a whole is a set PDF files, while the output is a list of metrics describing various aspects of each paper, such as interesting sentences, scientific domains, and contributions. The result also includes a predicted score used for ranking. This ranking is subsequently processed by the business developers of Technology Transfer Offices (TTOs) of multiple Dutch and German universities, who later give feedback on the results. -\textit{GreatAI} might have the potential to bridge the gap between data science and software engineering. Stemming from the bidirectional nature of bridges, we can look at the framework from two perspectives: for professionals closer to the field of data science, it provides an automatic scaffolding of software facilities that are required for deploying, monitoring, and iterating on their models. For software engineers, it highlights the necessary steps required for robust and improvable deployments, while at the same time saves them from the grunt work of implementing these constructs. While most importantly, it serves as a proxy for the design decisions through which they can be tested and evaluated in their practical context. +Overall, this problem context carries the properties of typical industry use cases: it utilises a wide range of natural language processing (NLP) methods, contains complex interactions between the services, benefits from the integration of end-to-end feedback, and has to provide the clients with a platform that they can rely on within their organisation's core processes. Since the final ranking affects real people, explainability and robustness are also central questions. + +\begin{figure} + \centering + \includegraphics[width=.9\linewidth]{figures/design-cycle.drawio.png} + \captionsetup{width=.9\linewidth} + \caption{Implementation of the design cycle of design science \cite{wieringa2014design} for our problem context of AI/ML deployments. The thinner arrows denote smaller but more frequent iterations.} + \label{fig:design-cycle} +\end{figure} + +The goal is to find a simpler, less cognitively-straining-to-use design that still leads to high-quality deployments, the definition of which will be described in Section \ref{section:requirements}. Before generalising, the framework's design is iteratively refined using the feedback acquired from applying it in practical contexts, which in this case are the research and development of a smaller and a more complex AI component using the work-in-progress framework. + +The design cycle summarising the research approach is shown in Figure \ref{fig:design-cycle} indicating the role of the case studies. The concerns arisen in the \textit{Treatment validation} iterations and their short discussions are highlighted in the form of \textit{Design notes}. Afterwards, they are addressed in the following \textit{Treatment design} iteration. This way, the issues are immediately considered and the proposed solutions can be traced back to the problems prompting their introduction. + +\section{Applicability \& generalisability} \label{section:interview-setup} + +To conclusively answer \textbf{RQ3} and \textbf{RQ4}, we conduct interviews with software engineers and data scientists with varying levels of professional background. The interview candidates were recruited from the recommendations of my acquaintances, who were kindly asked to seek out people from their professional networks with any connection to AI/ML. After the first few interviews, participants were also asked to suggest other candidates, preferably from different subfields. After two iterations of reaching out to potential interviewees personally, ten engineers and researchers eventually responded positively and participated in the study. Albeit the sample size is small, it still represents a wide range of organisation types: experts were included from startups, consultancies, government organisations, and research companies. + +First, before their interview, participants are requested to complete a questionnaire (shown in Appendix \ref{appendix:practices}) about their last completed AI project; the questions refer to the best practices implemented by \textit{GreatAI}. They are also advised to take a quick look at the tutorial page of the documentation. + +The interviews are divided into two halves. In the first part, after a brief introduction, interviewees are asked to solve a real-world deployment task by finishing a partially completed example project\footnote{Available at \href{https://github.com/schmelczer/great-ai-interview-task}{github.com/schmelczer/great-ai-interview-task}. The training part of the task has already been done, and the participants only have to deploy the trained classifier.} using \textit{GreatAI}. This is a more straightforward instance of the AI development lifecycle presented in the \textit{GreatAI} tutorials. They are also encouraged to think aloud so their feedback can be noted. Successfully completing the task creates a system implementing a known number of best practices. This way, the added value --- in terms of a larger number of implemented best practices --- can be quantitatively analysed by comparing the qualities of the finished implementation with the previously given answers. The target duration for the interviews is approximately one and a half hours. + +We follow the guidelines proposed by Halcomb et al. \cite{halcomb2006verbatim} for collecting information from interviews and reporting it. This reflexive, iterative process starts by recording participants (with their permission) and concurrent note-taking. Reflective journaling is immediately done post-interview, which is subsequently extended and revised by listening to the recordings. Afterwards, we interpret the gathered information by applying the methodology of thematic analysis \cite{alhojailan2012thematic}. Thematic analysis is an iterative qualitative investigation technique consisting of labelling, correlating, and structuring the central recurring topics raised during discussions. It has been successfully used in previous software engineering studies for extracting emergent patterns \cite{haakman2021ai,cruz2019catalog}. + +The second half of the one-on-one sessions consists of a short survey allowing us to create the Technology Acceptance Model (TAM) \cite{davis1989perceived} of the problem context. The ultimate goal of the presented library is to help increase the adoption rate of best practices. In order to reach that goal, first, the library itself has to gain adoption. TAM and its numerous variations provide means of measuring users' willingness of adopting new technologies. TAM has been widely applied in literature \cite{marangunic2015technology}, and due to its general psychological origins, it proves to be effective in other areas of technology, not just software \cite{riemenschneider2002explaining}. + +We employ the parsimonious version of TAM, which has been measured to have similar predictive power to that of the original TAM while having fewer variables \cite{wu2011user}. Parsimonious TAM observes three interconnected human aspects that influence the actual behaviour (adoption): \textit{perceived usefulness}, \textit{perceived ease of use}, and \textit{intention to use}. Participants are asked ten questions corresponding to these aspects of their experience using \textit{GreatAI}. The questionnaire is shown in Appendix \ref{appendix:questions}. The internal consistency of the answers is calculated using Cronbach's Alpha \cite{bland1997statistics}, after which we reflect on the responses. diff --git a/docs/thesis/chapters/4_design.tex b/docs/thesis/chapters/4_design.tex index ed16827..0f15901 100644 --- a/docs/thesis/chapters/4_design.tex +++ b/docs/thesis/chapters/4_design.tex @@ -1,62 +1,111 @@ \chapter{Designing the framework} \label{chapter:design} -Providing the users with a high-level of abstraction is not unheard of in the domain of practical AI platforms. Many software-as-a-service products offer features for hiding the details of machine learning applications. However --- as we saw in Section \ref{section:existing} --- these tend to abstract away the details of both data science and AI-engineering, overall hindering the development process. The design proposed here aims to simplify only the deployment related concepts. +Providing users with a high level of abstraction is not unheard of in the context of practical AI/ML platforms. Many software-as-a-service products offer features for hiding the technicalities of machine learning. However --- as we discussed in Section \ref{section:existing} --- these tend to abstract away the details of both data science and AI engineering, overall hindering the development process. The design proposed here aims to tackle and simplify only the deployment-related concepts. \section{Scope} \label{section:scope} -As highlighted by several case studies in Chapter \ref{chapter:background}, the transition from prototypes to production-ready systems is often named as the source of unexpected struggle. Maybe it is not a coincidence that a significant portion of the SE4ML best practices should be implemented in this phase as well. Unfortunately, it is easy to gloss over them while tackling the underestimated difficulties of this \textit{transition}. Therefore, the aim of GreatAI is to ease this step of the life-cycle, consequently, its scope is limited to the \textit{transition} step. +As highlighted by several case studies in Chapter \ref{chapter:background}, the transition from prototypes to production-ready systems is often named as the source of unexpected struggle. Maybe it is not a coincidence that a significant portion of the SE4ML best practices should be implemented in this phase. Unfortunately, it is easy to gloss over them while tackling the underestimated difficulties of this \textit{transition}. Therefore, the aim of \textit{GreatAI} is to ease this step of the lifecycle. Consequently, its scope is limited to the \textit{transition} step. -There have been attempts that at least partially address this issue, however, as we have seen in Chapter \ref{chapter:background}, these have limitations either from the perspective of best practices, or stemming from their difficulty to be adopted. To have the best chance of providing an easy-to-adopt solution, the scope has to be well-defined and limited. Because to understand the API of a library, users first have to understand its aim, surface, and have to become familiar with the problems it solves. Thus, focusing only on the \textit{transition} step seems reasonable. This step is highlighted in Figure \ref{fig:scope}. +There have been attempts that at least partially address this issue; however, as we saw in Chapter \ref{chapter:background}, these have limitations either from the perspective of best practices or stemming from their difficulty in being adopted. The scope has to be well-defined and limited to provide the best chance of providing an easy-to-adopt solution. To understand the API of a library, users first need to understand its aim and surface and have to become familiar with the problems it solves. Thus, limiting the focus solely to the \textit{transition} step seems reasonable. This step is highlighted in Figure \ref{fig:scope}. \begin{figure} \centering \includegraphics[width=\linewidth]{figures/scope.drawio.png} - \caption{Usual process steps in the development life-cycle of a data-heavy software solution. The dashed arrows denote optional paths: after a prototype has been completed, there are multiple options for its deployment. The steps with blue background show the scope of GreatAI.} + \captionsetup{width=.9\linewidth} + \caption{Usual process steps (based on \cite{john2020architecting}) in the development lifecycle of a data-heavy software solution. The dashed arrows denote optional paths: after a prototype has been completed, there are multiple options for its deployment. The steps with blue background show the primary scope of \textit{GreatAI}.} \label{fig:scope} \end{figure} -It is interesting to mention that there is a proliferation\footnote{\href{https://xkcd.com/927/}{xkcd.com/927}} of platform/software as a service (PaaS/SaaS) products for deploying AI\footnote{Such as \href{https://mlem.ai/}{MLEM} or any AutoML SaaS platform, for example, \href{https://www.akkio.com/role/software-engineers}{Akkio} as these often have a one-click deployment feature as well.}. At first, these may look promising, however, they tend to only focus on getting code easily deployed in the cloud: AI best practices are not prioritised in this setup. Nevertheless, in many cases, it may be a suitable option to use such a service and these can also complement GreatAI as illustrated in Figure \ref{fig:scope}. First, the prototype is transformed into a GREAT service and materialised as a common software artifact implementing the best practices. Then, it is either deployed using a deployment SaaS, or by using the organisation's existing software deployment setup. +It is interesting to mention that \href{https://xkcd.com/927/}{there is a proliferation} of platform/software as a service (PaaS/SaaS) products for deploying AI\footnote{Such as \href{https://mlem.ai/}{MLEM}, \href{https://streamlit.io/cloud}{Streamlit} or any AutoML SaaS platform, for example, \href{https://www.akkio.com/role/software-engineers}{Akkio} as these often have a one-click deployment feature as well.}. At first, these may look intriguing. However, they tend to only focus on getting code easily deployed in the cloud: AI best practices are not prioritised in this setup. Nevertheless, in many cases, it may be a suitable option to use such a service, and these can also complement \textit{GreatAI} as illustrated in Figure \ref{fig:scope}: first, the prototype is transformed into a \textit{GREAT} service and materialised as a common software artifact implementing best practices. Then, it is either deployed using a deployment SaaS or the organisation's existing software deployment setup. -\section{Design principles} +\section{Requirements} \label{section:requirements} -As implied in Section \ref{section:scope}, the Unix philosophy \cite{ritchie1978unix,salus1994quarter} of software design is followed. Most notably, the design goal that encourages to \textit{write programs that do one thing and do it well.}\footnote{Of course, \textit{write programs to work together} is also very much applicable, since allowing interoperability is one of the core requirements for GreatAI.}. Apart from providing a clear and simple picture of the intended use cases for the library, this is also in line with the main notion of \textit{A Philosophy of Software Design} \cite{ousterhout2018philosophy}: API-s should be narrow and deep. A narrow width refers to having a small exposed surface area, i.e. having a small number of functions and classes in the public API. While depth implies each of them accomplishing an involved, complex goal. +The best practices (which are referenced throughout the thesis) with which the design is concerned are a subset of those compiled by Serban et al. \cite{serban2020adoption,serban2021practices} and John et al. \cite{john2020architecting}. The core requirements --- set of covered best practices --- for a software solution that has the potential to improve our problem context are presented in the following, along with some explanation and clarification for each of them. -In a way, the API-s width is the price the users have to pay (the effort required for learning it) to use it, while the depth is analogous to the return they get from it. Having to learn little and being provided by a lot of functionality maximises return on investment, hence, developer experience (DX). The theoretical frameworks presented in \textit{The Programmer's Brain} \cite{hermans2021programmer} provides us with explanations and vocabulary from psychology for arguing about the cognitive aspects of API designs. In the following, two of them will be used for detailing the design principles: cognitive dimensions of code bases (CDCB) which is an extension of the cognitive dimensions of notation (CDN) framework \cite{blackwell2001cognitive}, and linguistic antipatterns \cite{arnaoudova2016linguistic}. The former comes with a set of dimensions which describe different (often competing) cognitive aspects of code that influence one's ability to perform certain tasks with it. +\paragraph{General} Albeit not explicitly in the list of best practices, compatibility is vital in encouraging adoption. Large projects frequently end up depending on numerous packages, each of which may impose some restrictions on the code: since these all have to be satisfied simultaneously, this can result in severe constraints. -While linguistic antipatterns provide guidelines for improving consistency and decreasing the false sense of consistency when there is none. Also, choosing the right names for identifiers can help activate information stored in the long-term memory which makes it quicker to comprehend and easier to reason about the code \cite{deissenboeck2006concise}. Finding the most accurate and useful names is harder than it first seems. Accuracy and usefulness are already often competing goals. The more precise the name, the longer and therefore less convenient to use \cite{butler2009relating}. In short, good names are key to good API-s; consciously considering the implications of names has to be an integral part of the design process. +The open-source scene of data-related libraries is vibrant. To take the example of data validation, there are at least four popular choices which offer varying but similar features: \href{https://github.com/SeldonIO/alibi-detect}{Alibi detect}, \href{https://github.com/PAIR-code/facets}{Facets}, \href{https://github.com/great-expectations/great_expectations}{Great Expectations}, and Data Linter \cite{hynes2017data}. The responsibility of choosing the most fitting solution falls on the user. Thus, they should not be limited in this by \textit{GreatAI}. On the contrary, the programming language (PL) of the library may be its only non-general property. Fortunately, the de facto PL for data science is Python, so implementing the library in it should not significantly limit its applicability. -Nonetheless, simple API-s come at a high technical cost. The library has to implement these in a way that still allows high-performance in production \cite{kleppmann2017designing} and avoids being tied to specific libraries or technologies. Inspiration for the latter may be gained from the pipelines of Prado et al. \cite{prado2020bonseyes}: they show that more freedom can be achieved with plug-and-play steps and preconfigured defaults. +\paragraph{Robustness} In software development, robustness can be achieved by preparing the application to handle errors gracefully, even unexpected ones \cite{bishop1998robust}. Errors can and will happen in practice: storing and investigating what has led to them is required to prevent future ones. In the case of ML, errors might not be as obvious to detect as in more traditional applications (see the above-mentioned data validators). Even if a single feature's value falls outside the expected distribution, unexpected results can happen. In cases where this might lead to real-world repercussions, extra care has to be taken to construct as many safeguards as practicable. \textit{GreatAI} should support its clients in this. -Before diving into the concrete issues solved, let us detail the principles that should be used for implementing them in the scope of this framework. +\paragraph{End-to-end} In this case, it refers to end-to-end feedback. That is, feedback should be gathered on the system's real-world performance, which should be taken into account when designing/training the next iteration of the model. Static datasets may fail to capture the changing nature of real life and can become outdated if they are not revised continuously. A well-packaged deployment should make it trivial to integrate new training data. + +\paragraph{Automated} The available time of data scientists and software engineers is limited and expensive. For this reason, humans should only be involved when their involvement is necessary. Steps in the development process that can be automated without negative consequences must be automated in order to achieve efficient development processes and let the experts focus on the issues that require their attention the most. + +\paragraph{Trustworthy} As detailed in the \href{https://digital-strategy.ec.europa.eu/en/library/ethics-guidelines-trustworthy-ai}{\textit{Ethics guidelines for trustworthy AI}}, human oversight, transparency, and accountability are some of the key requirements for trustworthy AI applications. For increasing public acceptance and trust while minimising negative societal impact, trustworthiness is essential. + +The requirements were chosen stemming from their general importance and potential to be mostly implemented by a software framework. That is why these provide an ideal initial direction for tackling the issue. Of course, these do not cover all best practices; for instance, the ones relating to organisational processes fall outside the realm of computer science. + +\section{Design principles} \label{section:principles} + +Before diving into the concrete issues being solved, let us detail the principles we use while implementing their solutions. As implied in Section \ref{section:scope}, the Unix philosophy \cite{ritchie1978unix,salus1994quarter} of software design is followed. Most notably, the design goal that encourages to \textit{write programs that do one thing and do it well}. Apart from providing a clear and simple picture of the intended use cases for the library, this is also in line with the main notion of \textit{A Philosophy of Software Design} \cite{ousterhout2018philosophy}: APIs should be narrow and deep. + +A narrow width refers to having a small exposed surface area, i.e. having a small number of functions and classes in the public API. In contrast, depth implies that each accomplishes an involved, complex goal. In a way, the width of an API is the price users have to pay (the effort required for learning it) to use it, while the depth is analogous to the return they get from it. Having to learn little and being provided with a lot of functionality maximises return on investment (ROI), hence, developer experience (DX). + +Moreover, the theoretical frameworks presented in \textit{The Programmer's Brain} \cite{hermans2021programmer} provides us with explanations and vocabulary from psychology for arguing about the cognitive aspects of API design. In the following, two of them will be used for detailing the design principles: cognitive dimensions of code bases (CDCB) which is an extension of the cognitive dimensions of notation (CDN) framework \cite{blackwell2001cognitive}, and linguistic anti-patterns \cite{arnaoudova2016linguistic}. The former comes with a set of dimensions describing different (often competing) cognitive aspects of code that influence one's ability to perform specific tasks. + +Linguistic anti-patterns provide guidelines for improving consistency and decreasing the false sense of consistency when there is none. Also, choosing the right names for identifiers can help activate information stored in the long-term memory, making it quicker to comprehend and easier to reason about the code \cite{deissenboeck2006concise}. Finding the most accurate and useful names is more challenging than it first seems. Accuracy and usefulness are already often competing goals: the more precise the name, the longer and, therefore, less convenient to use \cite{butler2009relating}. In short, good names are essential to good APIs; consciously considering the implications of names must be an integral part of the design process. + +Nonetheless, simple APIs come with a high technical cost. The library has to implement these in a way that still allows for high performance in production \cite{kleppmann2017designing} and avoids being tied to specific libraries or technologies. Inspiration for the latter may be gained from the ML pipelines of Prado et al. \cite{prado2020bonseyes}: they show that more freedom can be achieved with plug-and-play steps and preconfigured defaults. \subsection{Default configuration} -Existing frameworks oftentimes suffer from the entanglement of numerous levels of abstractions. Instead of exposing each implementation detail and encouraging users to interact with most of them, many of these could be abstracted away. Where configuration may be helpful for advanced users, default values can still be chosen automatically while providing an override option where necessary. +Existing frameworks frequently suffer from the entanglement of numerous levels of abstractions.\footnote{\href{https://grugbrain.dev/\#grug-on-apis}{grugbrain.dev/\#grug-on-apis}} Instead of exposing each implementation detail and encouraging users to interact with most of them, these can be abstracted away in a more high-level layer. Even where configuration may be helpful for advanced users, default values can still be chosen automatically while providing an override option where necessary. -For example, tracing the evaluations and the model versions used in a distributed fashion is very much expected of a trustworthy system. Hence, turning this feature on by default but allowing opting-out from it can result in less scaffolding required from the library's user. It also decreases their up-front cognitive load which by definition flattens the learning-curve \cite{hermans2021programmer}. Similar features can be imagined for providing an access API for the algorithms and for giving feedback, marking outliers, etc. +For example, tracing the evaluations and the model versions used in a distributed fashion is very much expected of a trustworthy system. Hence, turning this feature on by default but allowing opting-out from it can result in less scaffolding required from the library's users. It also decreases their up-front cognitive load, which by definition flattens the learning-curve \cite{hermans2021programmer}. Similar features can be imagined for providing a service API for the algorithms, giving feedback, marking outliers, and more. -Being \textit{automated} is listed as a requirement but it is imperative to only automate for simplifying and not for hiding decisions. More precisely, guessing must not be a part of automation. For instance --- an otherwise incredibly useful WebGL library --- TWGL.js\footnote{\href{https://twgljs.org/}{twgljs.org}} has a feature for automatically guessing the type of vectors based on their names. If it matches the \texttt{/colou?r/i} pattern, it is treated as a vector with 3 components\footnote{\href{https://github.com/greggman/twgl.js/blob/e3a8d0ed09f7f5cd4be0e4cb5976081c2b5013aa/src/attributes.js\#L139}{\tiny github.com/greggman/twgl.js/blob/e3a8d0ed09f7f5cd4be0e4cb5976081c2b5013aa/src/attributes.js\#L139}}. It is easy to imagine that this can help in certain scenarios, but it does so at the cost of immense confusion when renaming a variable breaks the application. In CDCB, this equates to scoring high on the dimension of \textit{Hidden dependencies} and low on \textit{Visibility}. +Being \textit{automated} is listed as a requirement, but it is imperative to only automate for simplifying and not for hiding decisions. More precisely, guessing must not be a part of automation. For instance --- an otherwise handy WebGL library --- TWGL.js, has a feature for automatically guessing the type of vectors based on their names. Suppose it matches the \texttt{/colou?r/i} pattern. In that case, it is treated as a vector with three components\footnote{\href{https://github.com/greggman/twgl.js/blob/e3a8d0ed09f7f5cd4be0e4cb5976081c2b5013aa/src/attributes.js\#L139}{\tiny github.com/greggman/twgl.js/blob/e3a8d0ed09f7f5cd4be0e4cb5976081c2b5013aa/src/attributes.js\#L139}}. It is easy to imagine that this can help in certain scenarios. Still, it does so at the cost of immense confusion when correctly renaming a variable breaks the application. In CDCB, this equates to scoring high on the dimension of \textit{Hidden dependencies} and low on \textit{Visibility}. -Learning from this, any kind of guessing must be avoided for creating a pleasant API. However, this is in conflict with providing defaults for each configuration value. Even if these would be reasonable defaults derived from educated guesses, they are still merely guesses. Nevertheless, if the users are required to specify each configuration option, that leads to considerably more boilerplate code. This verbosity is captured by the \textit{Diffuseness} dimension of CDCB and, of course, should be minimised. +Learning from this, any guessing must be avoided to create a pleasant API. However, this conflicts with providing defaults for each configuration value. Even if these would be reasonable defaults derived from educated guesses, they are still merely guesses. Nevertheless, if the users were required to specify each configuration option, that would lead to vastly more boilerplate code. This verbosity is captured by the \textit{Diffuseness} dimension of CDCB and, of course, should be minimised. -To resolve this conflict, GreatAI should have recommended values instead of defaults. This can mean a context object (as suggested in \cite{ousterhout2018philosophy}), which contains the result of each design decision that has to be made for a service's deployment. If not configured manually, the recommended values are applied, just like defaults. The values chosen for each parameter must be clearly highlighted. Coming from the library's single responsibility, the number of parameters should not be immense, hence, the user can be expected to comprehend them instead of just being overwhelmed and skimming it. +To resolve this conflict, \textit{GreatAI} should have recommended values instead of defaults. This can mean a context object (as suggested in \cite{ousterhout2018philosophy}), which contains the result of each design consideration that has to be made for a service's deployment. If not configured manually, the recommended values are applied automatically, just like defaults. However, the values chosen for each parameter must be clearly highlighted. Coming from the library's single responsibility, the number of parameters should not be immense; hence, the user can be expected to comprehend them instead of just being overwhelmed and skipping them. -This way, the library attempts to notify its user about the existence of these decisions but does not force them to manually decide. As a result, no initial configuration is needed for starting out with the library (high \textit{Provisionality}, low \textit{Diffuseness}) and the dependencies are not hidden since they are explicitly highlighted. +This way, the library attempts to notify its user about the existence of these decisions but does not force them to decide manually. As a result, no initial configuration is needed for starting out with the library (high \textit{Provisionality}, low \textit{Diffuseness}), and the dependencies are not hidden since they are explicitly highlighted. \subsection{Documentation} -Without a doubt, good documentation is a prerequisite for adoption. Documentation comes in multiple forms: modern integrated development environments (IDEs) tend to show a popup of a function's documentation when requested, at the same time a more comprehensive online documentation and example projects are also still expected. But descriptive error messages can be also viewed as documentation. The library should have quality documentation for all categories. +Little value can be derived from software without good documentation; undoubtedly, good documentation is a prerequisite for adoption. Documentations come in many shapes: modern integrated development environments (IDEs) tend to show a popup of a function's description when requested (for instance, on mouse hover), but at the same time, a more comprehensive online manual and example projects are also still expected. Descriptive error messages can also be viewed as documentation. -Once again, we might notice two competing interests: the level-of-detail and the length of the documentation. For example, FastAPI\footnote{\href{https://fastapi.tiangolo.com/async/\#concurrent-burgers}{fastapi.tiangolo.com}}, a popular Python web framework, has extensive descriptions and explanations on all topics related to Python's import system, the HTTP protocol, concurrency, deployment, etc. The actual framework's documentation is sprinkled over these very broad topics. This is certainly helpful for beginners to acquire knowledge from a single place. Nevertheless, this high-level of accessibility actually hinders the process of finding the relevant sections (in CDCB, this shows a trade-off between the support of Searching and Comprehension tasks). My opinion is that linking to external resources about the library's domain are welcome, but the documentation must have a single responsibility: describing the library itself. +The library must have quality documentation for all categories. Accordingly, for structuring it, the \textit{Diátaxis} philosophy is preferred \cite{Procida_Diataxis_documentation_framework} which prescribes dividing documentation into 4 parts along 2 axes: practical-theoretical and passive-active consumption. The four quadrants derived from this are tutorials, how-to guides, references, and explanations. -A large portion of software documentations is automatically generated from source code. This has the advantage of always keeping it in sync with code changes, however, it might also signal that the API is too large, since it is inconvenient for the developers to document it by hand. +Once again, we might notice two competing interests: the level of detail and the length of the documentation. For example, FastAPI\footnote{\href{https://fastapi.tiangolo.com/async/\#concurrent-burgers}{fastapi.tiangolo.com}}, a popular Python web framework, has extensive descriptions and explanations on all topics related to Python's import system, the HTTP protocol, concurrency, deployment, and more. The actual framework's documentation is sprinkled over these overly broad topics. This is undoubtedly helpful for beginners to acquire knowledge from a single place. Yet, this high level of accessibility actually hinders the process of finding the relevant sections; in CDCB, this shows a trade-off between the support of \textit{Searching} and \textit{Comprehension} tasks. Diátaxis' take is that linking to external resources about the library's domain is welcome, but the documentation must have a single responsibility: describing the library itself. -When it comes to example code, showing at least the minimal starter code, and the way of customising it has to be showcased front and centre. It is a well-known observation that developers only read documentation when they are stuck and there might be some merit to this. Making them not get stuck --- by providing a starter code from which they can explore the API using IntelliSense-like solutions --- should be preferred. For example, another widely popular Python web framework, Flask\footnote{\href{https://flask.palletsprojects.com/en/2.1.x/}{flask.palletsprojects.com/en/2.1.x}}, at this time, has 324 uniformly styled links on its landing page. Out of these, only 2 lead to the quick start code. Of course, it is not hidden, but I argue that the DX could be improved by displaying it more prominently. +A large portion of software documentations is automatically generated from source code, and this has the advantage of always keeping it in sync with code changes. However, it might also signal that the API is too large because it is inconvenient for the developers to document it by hand. Striking the right balance between handcrafted and automatically extracted documentation may be a vital component of good documentation. + +When it comes to example code, showing at least a minimal starter code and the way of customising it has to be showcased front and centre. It is a well-known observation that developers only read the documentation when they are stuck, and there might be some merit to this. Helping them not get stuck --- by providing a starter code from which they can explore the API using IntelliSense-like solutions --- should be preferred. Take the example of another widely popular Python web framework, Flask\footnote{\href{https://flask.palletsprojects.com/en/2.1.x/}{flask.palletsprojects.com/en/2.1.x}}, at this time, has 324 homogeneously styled links on its landing page. Out of these, only two lead to the quick-start code. Of course, it is not hidden, but we argue that the DX could be improved by displaying where to start more prominently. \subsection{Developer experience} -Subjectively, the key to good DX is consistency and discoverability. To give an example, the MySQL connector's Python implementation\footnote{\href{https://dev.mysql.com/doc/connector-python/en/}{dev.mysql.com/doc/connector-python/en/}} has a cursor object which exposes a \texttt{fetchone} method. Even though this naming scheme is not conventional in Python since it does not follow \href{https://peps.python.org/pep-0008/}{PEP 8}, at least the API is logical: changing \texttt{sql\_cursor.fetchone()} to \texttt{sql\_cursor.fetchall()} returns all items instead of just one. Using good and consistent names is the key to good DX. +Subjectively, a key component of good DX is \textit{Progressive evaluation} through which development can become a highly iterative, experimental process. This is well-understood by popular data science tools, such as Jupyter Notebooks. \textit{GreatAI} also has to support some level of this, for example, in the form of auto-reload on code changes. Further key ingredients of good DX are consistency and discoverability. To give one more example, the MySQL connector's Python implementation\footnote{\href{https://dev.mysql.com/doc/connector-python/en/}{dev.mysql.com/doc/connector-python/en}} has a cursor object which exposes a \texttt{fetchone} method. Even though this naming scheme is not conventional in Python since it does not follow \href{https://peps.python.org/pep-0008/}{PEP 8}, at least the API is intuitive: changing \texttt{sql\_cursor.fetchone()} to \texttt{sql\_cursor.fetchall()} returns all items instead of just one. Using good and consistent names is the key to good DX. -Also, Python codebases are rarely strictly object-oriented (OO), they are a mix of functional, data-driven, and OO programming. Consequently, relying on classes for grouping related functions is not always desirable. Therefore, it is even more imperative to name similar functions similarly. This helps discoverability and chunking \cite{hermans2021programmer} which amount to quicker comprehension. +At the same time, Python codebases are rarely strictly object-oriented (OO). They are a mix of the functional, data-driven, and OO paradigms. Consequently, relying on classes for grouping related functions is not always desirable; therefore, it is even more imperative to name similar functions similarly. This helps discoverability and chunking \cite{hermans2021programmer}, which amounts to quicker comprehension. -There is one more reason to prefer consistency. Humans have a limited short-term memory (STM) \cite{miller1956magical}. Even though flags as function parameters are frowned upon by some \cite{martin2009clean}, they are useful, especially, when configuring libraries. However, if there is no convention for the default value of a flag, clients have to remember the flag's name and initial value at the same time, quickly overloading their STM. Thus, in the codebase, all defaults must be \texttt{False}. Sometimes, it can result in a \textit{disable} prefix, which turn into a double negation, users shouldn't ever encounter this themselves since the doubly-negated version is the default, thus when overriding it, it is only singly-negated. This approach also implies, that something may be recommended to be turned on by default. +There is one more reason to prefer consistency: humans have limited short-term memory (STM) \cite{miller1956magical}. Even though flags as function parameters are frowned upon by some \cite{martin2009clean}, they can be useful, especially when configuring libraries. However, if there is no convention for the default value of a flag, clients have to remember the flag's name and initial value simultaneously, quickly overloading their STM. Thus, in the codebase, all defaults must be the same, let us say, \texttt{False}. Sometimes, it can result in a \textit{disable} prefix, which may turn into a double negation. Nevertheless, users should never encounter this since the doubly-negated version is the default; thus, it is only singly negated when overriding it. This approach also implies that something may be recommended to be turned on by default. + +\section{Architecture} \label{section:architecture} + +Although API design has been the central subject so far, it is worth remembering that APIs are usually expected to have corresponding implementations. \textit{GreatAI} is no exception. As laid out in Section \ref{section:principles}, we strive for narrow and deep interfaces; thus, it is time to address the \textit{depth} component. + +\textit{GreatAI} stands on the shoulders of numerous open-source packages and integrates them to provide its various features. The most fundamental dependencies and the entire library in context are shown in Figure \ref{fig:technologies}. Given a Python script or a Jupyter notebook, \textit{GreatAI} transforms the specified prediction functions into a production-ready deployment, deployable either as a Docker image, WSGI-server, or an executable relying on \texttt{uvicorn}. The complete list of dependencies can be found in the repository\footnote{\href{https://github.com/schmelczer/great-ai/blob/main/pyproject.toml}{github.com/schmelczer/great-ai/blob/main/pyproject.toml}}. + +\begin{figure} + \centering + \includegraphics[width=0.65\linewidth]{figures/technologies.png} + \captionsetup{width=.9\linewidth} + \caption{A very high-level overview of \texttt{GreatAI} in its context. The main dependencies are also highlighted.} + \label{fig:technologies} +\end{figure} + +The general theme in the implementation is that each explicit best practice should have its distinct, loosely-coupled functions or classes. When collaboration opportunities arise, such as persisting the model versions (\nth{1} component) into prediction traces (\nth{2} component), there are three primary conduits for realising them. These are the \texttt{context} object responsible for the global configuration per process, the \texttt{FunctionMetadataStore} specifying the expected behaviour of each prediction function, and finally the \texttt{TracingContext} that is created anew for each prediction input (session). + +After refining the framework with feedback gathered from case studies and users, we will end up with the core architecture presented in Figure \ref{fig:architecture}. The implementation is mixed-paradigm, combining the expressiveness of functional and the design patterns of object-oriented programming (OOP) in order to maintain an overall low complexity. Reflection is also utilised, especially for run-time type-checking and generating the API definitions and dashboard components. Regardless, the architecture is still presented with a syntax similar to the class diagrams of UML2 \cite{Rumbaugh2004} because it provides the freedom to express even the non-OOP design aspects. + +For the sake of brevity, Figure \ref{fig:architecture} does not show all fields, and some related entities have been combined, e.g. the \textit{GroundTruthAPI} box represents the \texttt{add\_ground\_truth}, \texttt{query\_ground\_truth}, and \texttt{delete\_ground\_truth} functions. The client project can also access most of the presented entities, but these optional dependency arrows are not shown in the diagram. The \texttt{utilities} submodule is also left unexpanded; almost all of its functions are orthogonal with the exception of \texttt{parallel\_map}. The latter follows a textbook producer-consumer model facilitated by queues and event signals \cite{wang2020producer}. + +\begin{figure} + \centering + \includegraphics[width=\linewidth]{figures/architecture.png} + \captionsetup{width=.9\linewidth} + \caption{The core architecture of \textit{GreatAI} illustrated with syntax loosely-based on UML2 \cite{Rumbaugh2004}. Given its framework nature, the expected client project and the actor integrating it are highlighted; the associations between the framework and the client project are achieved through the use of decorators.} + \label{fig:architecture} +\end{figure} diff --git a/docs/thesis/chapters/5_case/2-stage.tex b/docs/thesis/chapters/5_case/2-stage.tex deleted file mode 100644 index 5248edd..0000000 --- a/docs/thesis/chapters/5_case/2-stage.tex +++ /dev/null @@ -1,35 +0,0 @@ -\section{A complex case} - -Let us now turn our attention towards a more complex component. The ScoutinScience Dashboard contains a full-page evaluation view for each academic publication. On this, the known metadata, historical data about the paper's topics, social media mentions, a PDF viewer showing the document, and other augmentation tools are displayed. One of these is the \textit{interesting sentences} section, which aims to summarise the paper from a technology-transfer perspective. - -The current approach uses a simple heuristic based on a set of phrases selected by business developers and extended with the help of a word2vec model \cite{mikolov2013efficient}. The user feedback deemed this implementation slightly helpful but not adequate for providing an accurate overview. Thus, this is the baseline that I attempt to improve on in this section. - -\begin{displayquote} -Compared with Section \ref{section:simple-case}, this time around, the toolset of GreatAI is at our disposal. Hopefully, this will streamline the development and --- especially --- the deployment. Given its arguably higher complexity, this experiment falls closer to industrial use-cases, and hence, can give a more accurate feedback on how to further improve the API. -\end{displayquote} - -\subsection{Background} - -Automatic text summarisation (ATS) is one of earliest established problems of text analysis and boasts numerous promising results \cite{el2021automatic}. However, our problem requires generating a special type of summary: it must only concern a single aspect (tech-transfer) of the document. Aspect-based text summarisation has also seen some progress over the last decades \cite{berkovsky2008aspect,hayashi2021wikiasp}, but these approaches require concretely defined topics. Unfortunately, \textit{tech-transfer potential} is anything but a clear topic definition. - -Our numerous discussions and interviews with business developers over the last years made it clear that there is no universally agreed on definition for it. At least, all of them agrees that they know it when they see it. Additionally, most of them agree that they can confidently make a decision at the granularity of sentences. This gives rise to an obvious idea: show the experts something that they can annotate. Because the time of experts is valuable, and relevant sentences are few and far between, extra care needs to be taken to improve the ratio of positive examples in the dataset. The research of Iwatsuki Kenichi on formulaic expressions (FE) \cite{iwatsuki2020evaluation,iwatsuki2021extraction,iwatsuki2021communicative,iwatsuki2022extraction} provides a promising direction to do so. - -A formulaic expression is a phrase with zero or more slots that expresses a certain intent. In the context of scientific texts, an example\footnote{Taken from the ground-truth data at \href{https://github.com/Alab-NII/FECFevalDataset/blob/master/human_evaluation/background.tsv}{github.com/Alab-NII/FECFevalDataset}} could be: \texttt{it was not until * that}. The asterisk can be substituted with multiple terms and the intention of this expression is (likely) to describe the \textit{History of the related topics}. Iwatsuki et al. identified a set of 39 intentions, compiled a manually labelled dataset \cite{iwatsuki2020evaluation}, and developed multiple approaches for automatically extracting and classifying formulaic expressions in large corpora \cite{iwatsuki2021communicative,iwatsuki2022extraction}. - -\subsection{Methods} - -In the following, we explore a 2-stage retrieval approach \cite{schutze2008introduction} commonly used in the field of information retrieval. The first stage is expected to filter out sentences that are certainly not relevant from a technology-transfer perspective using Iwatsuki's formulaic expression intention labels. Subsequently, the second stage utilises a fine-tuned SciBERT model to rank the remaining sentence based on a model learned from expert annotations. - -This approach has multiple shortcoming, for the first stage, we must assume the independence of sentences and that the FE intentions are strongly correlated with the sought after aspect. Additionally, the reranking only considers the individual relevance of the sentences instead of the overall relevance (utility) of the summary. It is expected, that stemming from the length of the documents and the sparseness of the selected sentences, that any combination of them is likely to have low redundancy. - -TODO - -Finetuning SciBERT \cite{jurafsky2019speech}. - -\subsection{Results} - -For measuring the interrater agreement, Cohen's kappa \cite{cohen1960coefficient} is calculated as shown in Equation \ref{equation:kappa}. - -\begin{equation} \label{equation:kappa} -\kappa_{agreement} \equiv \frac{p_{observed} - p_{expected}}{1 - p_{expected}} = 1 - \frac{1 - p_{observed}}{1 - p_{expected}} -\end{equation} diff --git a/docs/thesis/chapters/5_case/features.tex b/docs/thesis/chapters/5_case/features.tex deleted file mode 100644 index 12b0c23..0000000 --- a/docs/thesis/chapters/5_case/features.tex +++ /dev/null @@ -1,40 +0,0 @@ -\section{Bridging \textbf{the gap} with GreatAI} - -This section briefly explores how the problems raised can be solved using GreatAI, and the API it provides to best fit the needs of its users. We first focus on the aspects of data, then, the automated wrapping of service, lastly we discuss the utility of helper functions. - -First, let us revisit the scope. As concluded in Section \ref{section:scope}, GreatAI should ease the \textit{transition} step between prototypes and production-ready deployments. However, this leaves open the question of what constitutes to this step? There are cross-cutting concerns such as the feature extraction code: for example, feature extraction is implemented and used in the training phase but it is also deployed alongside the model. The robustness criterion has to be met by this procedure after deployment even though its implementation is only in focus at the earlier stage of the project. Since having an untested function deployed into production can have severe repercussions, I believe, assuring its correctness lies within the scope of GreatAI. - -\subsection{Data} - -There are two kinds of data storage need we need to address: training data and trained models. Because our code is probably already tracked under Git (and likely synced with GitHub), using the Git Large File Storage (LFS)\footnote{\href{https://git-lfs.github.com/}{https://git-lfs.github.com/}} might seem intriguing. However, it is a paid (and surprisingly expensive) service of GitHub especially when we factor in the expected sizes of the models and train data with the fact that the only way remove files counting towards our quota is to \href{https://docs.github.com/en/repositories/working-with-files/managing-large-files/removing-files-from-git-large-file-storage#git-lfs-objects-in-your-repository}{recreate the repository}. - -The Data Version Control (DVC)\footnote{\href{https://dvc.org/}{https://dvc.org/}} open-source project provides a nearly perfect solution. It comes with a command-line interface (CLI) inspired by git's, and it can be integrated with several backend storage servers. Its only downside is of course that it is one more tool that increases the complexity of the project and the initial setup time. If this is an acceptable price to pay, then I personally recommend opting for DVC. Nevertheless, if this may prohibit a team from properly handling data according to the best practices, I present a simpler solution in the following. - -The complexity of an API can be decreased by relying on its users preexisting knowledge. Therefore, we can reuse familiar API-s, such as the \texttt{open()} method from Python. A method is proposed which provides the same interface, however, the backing storage for it is a mixture of local disk space, S3-compatible storage, MongoDB, or any other storage backend. It provides a superset of \texttt{open()}'s interface; the same parameters can be used with it. - -Easing development isn't just about automating everything but also making the code easy to change (which is the \textit{Viscosity} dimension of CDCB). Going from opening a local file on the disk with the built-in open method, to opening a file from S3 is as easy as changing \texttt{with open('file.txt', 'w' as f: ...} to \texttt{with LargeFileS3('file.txt', 'w' as f: ...}. In the case of the latter, an additional \texttt{version} keyword argument can also be given to lock ourselves in using as certain version which is very much desired in the case of models. - -The obstacles coming from the intertwined nature of different models is widely recognised \cite{sculley2015hidden,haakman2021ai,amershi2019software}. This can lead to non-monotonic error propagation, meaning that improvements in one part of the system might decrease the overall system quality \cite{amershi2019software}. The importance of schema versioning in an environment of rapidly changing models and transformations is highlighted and solved for a specific use-case in \cite{van2017versioning}. - -The expected features: progress bar, caching, automatically purging the cache, automatically deleting old remote version if requested are all present and come with recommended --- but easy to see and change --- configuration. - -\subsection{Utilities} - - -utilities: clean, language, parallel map \textit{Enable Parallel Training Experiments} - -traces - -\textit{Deployment approach} - -% Should the order of the decorators matter? all except in one case, they're written in a way that the order doesn't matter even with the original semantics of decorators. In that one case, it cannot be written in that way. Instead of correcting a user's error, there's a mechanism looking for this error and the user is notified. Guessing the unspecified is cool, but correcting the wrong is not - -to do - -% During development, I wanted to check out which types of request fail -> log errors in traces -% Even production systems are not perfect, saving and letting the users filter on the errors is useful. e.g. they can correlate it with the input - -% I use a toy example when quickly experimenting, it's important not to overfit on it ( moving it into the library would result in a online for it, so I have to consciously avoid that), but having a very simple - -% Argumetn/parameter names were confusing -% offlinemode -> cacheonly mode diff --git a/docs/thesis/chapters/5_case/introduction.tex b/docs/thesis/chapters/5_case/introduction.tex deleted file mode 100644 index b743de1..0000000 --- a/docs/thesis/chapters/5_case/introduction.tex +++ /dev/null @@ -1,11 +0,0 @@ -\chapter{The ScoutinScience platform} \label{chapter:case} - -The core product of ScoutinScience B.V. is its platform. The clients are technology-transfer offices of Dutch and German universities, government organisations (e.g.: Wetsus), and corporates (e.g.: Heraeus Group, Ruma Rubber B.V.) who wish to extend the scope of their R\&D activities. ScoutinScience connects to multiple data sources of academic publications and integrates them into a single database. Each new publication is evaluated with a suite of AI components that ultimately determine its technology transfer potential. Other features are also extracted that help the users get a quick overview of the authors, topics, and contributions of a given piece of research. - -Each client organisation gets to see a different filtered view of this database ranked by the predicted probability of technology transfer opportunities being present. The main motivation is to make these business developers' and other professionals work more efficient by showing them which papers have the largest likelihood of being considered interesting by them. - -To achieve this, we have a service-based architecture \cite{kleppmann2017designing} on the backend, apart from the data integration, communication, and business logic, it is made up of services wrapping simpler (phrase-matching, Naive Bayes) and more sophisticated (conditional random fields, transformer) models. As we will soon see, these can also depend on each other, for instance, based on the predicted scientific domain, a different model may be applied for scoring the paper's certain aspects. - -I was the first software engineer on the team which has grown considerably in the past two years. While architecting, designing, and integrating more and better models into our software solution, we noticed the same difficulties as described in Chapter \ref{chapter:background}. The gap between prototypes and production-ready services is larger than it seems. It is also larger than it should be. This motivated me to investigate the state-of-the-art and had found that it is insufficient in many cases. Since the ScoutinScience platform is a quite typical example of applying AI in the industry, it will serve as the real-life case, problem context, and testbed for attempting to design a solution which can advance the state-of-the-art. - -In this chapter, the process of designing GreatAI is described along with how it fits into real-life use cases. First, a simple experiment is presented which leads to the implementation of a service, then, as the featureset of the library grows and matures, a more complex service is developed. Subsequently, the close to final library version is used to refactor existing ScoutinScinece services in order to further refine the API of GreatAI. Lastly, the final version of the design is presented and qualitatively evaluated to verify how well it satisfies the requirements described in Section \ref{section:requirements}. diff --git a/docs/thesis/chapters/5_case/main.tex b/docs/thesis/chapters/5_case/main.tex deleted file mode 100644 index 7d305bb..0000000 --- a/docs/thesis/chapters/5_case/main.tex +++ /dev/null @@ -1,10 +0,0 @@ -\input{chapters/5_case/introduction} - -\input{chapters/5_case/naive-bayes} -\input{chapters/5_case/features} - -\input{chapters/5_case/2-stage} - -\input{chapters/5_case/refactoring} - -\input{chapters/5_case/results} diff --git a/docs/thesis/chapters/5_case/naive-bayes.tex b/docs/thesis/chapters/5_case/naive-bayes.tex deleted file mode 100644 index 32c7e06..0000000 --- a/docs/thesis/chapters/5_case/naive-bayes.tex +++ /dev/null @@ -1,97 +0,0 @@ -\section{A simple case} \label{section:simple-case} - -Using different models for slight variations of the same problem is quite commonplace in the industry. For instance, UberEats has a vast, hierarchical set of models for every country, region, and city for calculating the estimated time of delivery \cite{li2017scaling}. We have also found, that in order to best process an academic publication, knowing its domain is essential. The reason for this can be (among others) the wildly different vocabularies of different domains. For example, the term \textit{framework} in computer science almost always refers to a software artifact (usually implying high tech-transfer potential), while in every other domain, \textit{framework} is used to describe theoretical models that are less central to practical applications. Of course, it is not merely the meaning of the terms but more importantly, their distribution that varies significantly. Therefore, the topic of this section is to design and develop a domain prediction model for academic papers. - -\subsection{Background} - -Fortunately, this is one of the oldest subjects of text classification. In fact, Maron introduced the Naive Bayes classifier in 1961 for exactly this purpose: classifying documents' subjects. To look at a more recent approach, SciBERT \cite{beltagy2019scibert} --- a BERT \cite{devlin2018bert} model pretrained on academic publications --- was also used for a similar task in which the domains of sentences have to be decided\footnote{\href{https://paperswithcode.com/sota/sentence-classification-on-paper-field}{paperswithcode.com/sota/sentence-classification-on-paper-field}}. It achieved an F1-score of $0.6571$ after being pretrained on the Semantic Scholar Corpus (SSC) \cite{Lo2020S2ORCTS} and finetuned on the train split of the Microsoft Academic Graph (MAG) dataset \cite{wang2019review}\footnote{SciBERT was applied to a preprocessed version of this dataset available at \href{https://github.com/allenai/scibert/tree/master/data/text_classification/mag}{github.com/allenai/scibert/tree/master/data/text\_classification/mag}}. - -\begin{displayquote} -\textbf{Design note} After getting familiar with the context, it is time to focus on experimenting and developing our domain prediction service. At the same time, the difficulties encountered should be noted and integrated into GreatAI's design. -\end{displayquote} - -\subsection{Data} - -Two datasets will be considered for the experiments. SciBERT's MAG and the SSC. The former is used to compare the results with SciBERT's, while the latter is utilised for training a model for production purposes because it has 19 labels compared with MAG's 7 and it also contains abstracts instead of just sentences, thus, it is more fitting for our use-case. - -SciBERT's version of the MAG dataset has 84 thousand and 22.3 thousand sentences in its train and test splits respectively. These are mostly in English and have all punctuation and casing removed. Each sentence is classified as belonging to one of seven fields. Figure \ref{fig:mag-distribtion} shows that the classes have a uniform distribution. - -\begin{figure} - \centering - \includegraphics[width=\linewidth]{figures/mag-distribution.png} - \caption{Class distribution of the MAG \cite{wang2019review} dataset's 84000 sentences in its \textit{train} split.} - \label{fig:mag-distribtion} -\end{figure} - -SSC is much larger: it contains over 80 million abstracts. Having more data certainly helps in sampling the term distribution more accurately, the law of diminishing returns apply, especially when using simple models. Therefore, the data will be randomly downsampled to leave us with a more manageable couple of hundred megabytes of abstracts. We can see the distribution of class labels in Figure \ref{fig:ss-distribution}. The dataset is considerably less balanced: \textit{medicine} is by far the most popular field. - -\begin{figure} - \centering - \includegraphics[width=\linewidth]{figures/ss-distribution.png} - \caption{Label distribution of the Semantic Scholar dataset \cite{Lo2020S2ORCTS}. The \textit{variable} refers to the position of the domain in the list of domains assigned to a paper.} - \label{fig:ss-distribution} -\end{figure} - -\begin{displayquote} -\textbf{Where should we store this data?} "On my machine" seems like an easy answer. However, if we have a team working with the data or it has intrinsic value, it must be stored in an easy-to-access, potentially redundant way. Serban et al. \cite{serban2020adoption} expressed this need in the following best practice: \textit{Make Data Sets Available on Shared Infrastructure (private or public)}. Meanwhile, wherever data is stored, it should also be versioned to satisfy the next best practice: \textit{Use Versioning for Data, Model, Configurations and Training Scripts}. -\end{displayquote} - -MAG needs no further preprocessing if we aim to match SciBERT's setup \cite{beltagy2019scibert}. But since SSC contains a heap of metadata, the relevant parts have to be extracted and preprocessed. In this case, these are the the concatenation of the abstract's text, paper's title and the journal's name along with the paper's domains (there can be multiple domains for a single paper, it is a mulitlabel classification task). Lastly, the non-English entries are discarded because we only expect to process papers in English. - -\begin{displayquote} -\textbf{How should we preprocess the data?} These simple processing steps (filter, map, project) are almost always present in the data science life-cycle. For example, cleaning the input text from various HTML, OCR, PDF, or \LaTeX \hskip 0.12cm extraction artifacts is almost always necessary for text analysis. This is captured in the AI best-practices collection under the following category: \textit{Write Reusable Scripts for Data Cleaning and Merging}. Also, the best practice of \textit{Test all Feature Extraction Code} is somewhat applicable: the applied processing steps must not introduce unwanted artifacts. -\end{displayquote} - -\subsection{Methods} - -Since the aim is to classify papers to allow the ScoutinScience platform to select models which have been trained on a matching vocabulary (and domain), it seems reasonable that only considering the distribution (frequencies) of individual terms may be sufficient. To test this hypothesis, a unigram language model (Multinomial Naive Bayes) is constructed and its accuracy is compared with SciBERT's. The former definitely aligns with the advice to \textit{Use The Most Efficient Models}. - -Using the MNB implementation of scikit-learn \cite{pedregosa2011scikit}, it only took a couple of lines to create, hyperparameter-optimise, and test a text classifier. Including data loading and visualisations, it takes 71 LOC to be more precise. \footnote{The code is available at \href{https://github.com/ScoutinScience/great-ai/blob/main/examples/simple-mag/train.ipynb}{github.com/ScoutinScience/great-ai/blob/main/examples/simple-mag/train.ipynb}} This further proves relatively how simple it is to apply existing algorithms. The code can be considered for satisfying the \textit{Automate Hyper-Parameter Optimisation} best-practice, since it also implements an automated hyperparameter sweep. - -The sentences are tokenised into words and vectorised with TF-IDF (with logarithmic term frequency) \cite{buckley1985implementation}, the hyperparameters found via 3-fold cross-validation on the \textit{train} split lead to filtering out tokens which occur in fewer than 5 documents or more than 5\% of the documents. - -\begin{displayquote} -\textbf{What could be automated here?} As discussed in Section \ref{section:accessible-ai}, libraries exposing algorithms and state-of-the-art models can already be considered mature and accessible. In this case, only scikit-learn was utilised, but subjectively, most popular libraries have a similarly easy to use use API. Therefore, I see no urgent need for further action regarding the \textit{experimentation} step of the life-cycle in connection with the AI best practices. -\end{displayquote} - -\subsection{Results \& Discussion} - -\begin{figure} - \centering - \includegraphics[width=0.8\linewidth]{figures/confusion-matrix.png} - \caption{Confusion matrix of a Naive Bayes classifier on the MAG dataset's sentences. The matrix is normalised column-wise. Notice, how most mistakes happen between semantically similar classes, for instance: \textit{politics} -- \textit{sociology} or \textit{business} -- \textit{economics}.} - \label{fig:mag-confusion} -\end{figure} - -\begin{figure} - \centering - \includegraphics[width=\linewidth]{figures/ss-confusion.png} - \caption{Confusion matrix of a Naive Bayes classifier on the SSC dataset's sentences. The matrix is normalised column-wise. Notice, how most mistakes happen between semantically similar classes, for instance: \textit{philosohpy} -- \textit{sociology} or \textit{history} -- \textit{art}.} - \label{fig:ss-confusion} -\end{figure} - -When this model is applied to the \textit{test} split of MAG, we get the confusion matrix of Figure \ref{fig:mag-confusion}. This Naive Bayes classifier achieves a whopping $0.6795$ F1-score. This is $3.4\%$ better than SciBERT's on the same dataset. Thus, it seems, MNB clearly outperforms SciBERT for this particular use-case: it is not only more accurate, its model is magnitudes smaller, while it is also considerably faster to train (or finetune in the case of SciBERT) and use. - -It is, of course, not entirely surprising that the sophisticated transformer architecture of SciBERT is not necessary for a plain task like this. Apart from phrases, the relation between separate words of a sentence do not carry nearly as much discriminative power as the identity of the terms\footnote{On a similar note, the independence assumption of Naive Bayes is often less wrong than it might seem \cite{hand2001idiot}.}, hence there is little reason for using an attention mechanism. The fact that SciBERT even works in any way on this task is already a testament to its general applicability. Nevertheless, this short experiment has proved that we can safely opt for using MNB for production. - -Since Multinomial Naive Bayes is best at returning a single label and SSC is has multiple labels per datapoint: for evaluation purposes, it is checked whether the returned label is contained in the labels of the ground truth. On this dataset, MNB achieves a significantly lower macro-average F1-score which is 0.49. The weighted-average F1 is 0.61 and the overall accuracy is 62\%. The large difference between the macro and weighted averages come from the unbalanced distribution of the labels, better performance could be achieved by uniformly sampling from each class. - -The lower F1-score is not surprising because there are more than twice as many classes in this dataset, Additionally, the mistakes made are defendable when we look at Figure \ref{fig:ss-confusion}: most of them are between close or related classes. - -\begin{displayquote} -This is the usual point where papers conclude: a proof-of-concept/prototype has been built and its performance demonstrated, measured --- and usually --- explained. Nonetheless, in an industrial setting, our problem is far from being solved: it has yet to be deployed. -\end{displayquote} - -\subsection{Deployment} - -First, an inference function needs to be written that can take an input on the fly and calculate a corresponding prediction. Since we aim to follow the best practices, namely: \textit{Explain Results and Decisions to Users} and \textit{Employ Interpretable Models When Possible}, giving an explanation of the results is expected. Fortunately, with our simple model it's easy to determine the most influential weights, thus, words. The last deployment step may be to provide access to our model for others. - -\begin{displayquote} -\textbf{How do we provide an interface for the inference function?} We either have an offline or online inference workflow (or both). For the former, we have to provide a way to use it in batch processing; a simple Python function may be adequate for this purpose, though, allowing it to be easily (or automatically) parallelised would make its consumers' DX better. If it is an online-workflow, we must have a service running continuously and accepting input at any time. This can be achieved by a remote procedure call (RPC) interface, or more commonly, a web API. Developers usually refer to these as REST API-s, sometimes, they even follow the conventions of REST. Either ways, we must develop a wrapper over the service in order to make it available for other internal/external consumers. -\end{displayquote} - -According to the research on the adoption of best practices, this is where many real-world projects conclude. This happens to be \textbf{the gap}. Believing that solely focusing on the research and experiments is good enough is a fallacy: when following this approach, the deployment step ends up being a rushed attempt of wrapping the \textit{AI} and putting it in the production environment. This is inarguably a deployment. However, it follows very few of the best practices. This can lead to suboptimal real-life performance, lack of accountability, lack of opportunity to improve, and can overall lead to negative societal impact \cite{o2016weapons}. - -\begin{displayquote} -\textbf{How could we implement more best practices?} The most notable missing best practices are the lack of automated deployment, automated regression testing, online monitoring, persisting the traces, graceful error-handling, taking feedback on the results (if possible in the use-case), calculating the online accuracy based on the feedback, and retraining the model if necessary using novel data. These all correspond to a best practice. -\end{displayquote} diff --git a/docs/thesis/chapters/5_case/refactoring.tex b/docs/thesis/chapters/5_case/refactoring.tex deleted file mode 100644 index bd05947..0000000 --- a/docs/thesis/chapters/5_case/refactoring.tex +++ /dev/null @@ -1 +0,0 @@ -\section{Refactoring with GreatAI} diff --git a/docs/thesis/chapters/5_case/results.tex b/docs/thesis/chapters/5_case/results.tex deleted file mode 100644 index afaa299..0000000 --- a/docs/thesis/chapters/5_case/results.tex +++ /dev/null @@ -1,38 +0,0 @@ -\section{Results} - -\begin{table} -\centering -\caption{A subset of the AI lifecycle \href{https://se-ml.github.io/practices/}{best practices identified by Serban et al.} \cite{serban2020adoption,serban2021practices} and the level of support GreatAI provides for them. \textit{Full} requires no action from the user, \textit{Partial} requires at least some involvement, while \textit{Slight} provides some useful features but the client is still expected to make a significant effort.} -\label{table:best-practices} -\begin{tabular}{p{7cm}@{\hskip 0.5cm}c@{\hskip 0.5cm}c} -\hline -\textbf{Best practice} & \textbf{Implementation} & \textbf{Level of support} \\\hline - -Use Sanity Checks for All External Data Sources & \texttt{great\_ai.parameter} & Partial \\\hline -Check that Input Data is Complete, Balanced and Well Distributed & Type-checked input & Slight \\\hline -Write Reusable Scripts for Data Cleaning and Merging & \texttt{great\_ai.utilities} & Partial \\\hline -Make Data Sets Available on Shared Infrastructure (private or public) & \texttt{great\_ai.large\_file} & Full \\\hline - -Test all Feature Extraction Code & \texttt{great\_ai.utilities} & Partial \\\hline -Employ Interpretable Models When Possible & \texttt{great\_ai} & Slight \\\hline -Enable Parallel Training Experiments & \texttt{great\_ai.parallel\_map} & Partial \\\hline -Continuously Measure Model Quality and Performance & \texttt{great\_ai} & Full \\\hline -Use Versioning for Data, Model, Configurations and Training Scripts & \texttt{great\_ai.large\_file} & Full \\\hline - -Run Automated Regression Tests & \texttt{great\_ai} & Full \\\hline -Use Continuous Integration & Docker Images \& scripts & Partial \\\hline -Use Static Analysis to Check Code Quality & Typed API & Partial \\\hline -Assure Application Security & GreatAI is audited & Partial \\\hline - -Automate Model Deployment & Docker Images \& scripts & Partial \\\hline -TODO: Enable Shadow Deployment & GreatAI & Full \\\hline -Continuously Monitor the Behaviour of Deployed Models & \texttt{great\_ai} & Full \\\hline -Enable Automatic Roll Backs for Production Models & Docker Images & Partial \\\hline -Log Production Predictions with the Model's Version and Input Data & GreatAI & Full \\\hline - -Explain Results and Decisions to Users & GreatAI & Slight \\\hline -\end{tabular} -\end{table} - - -Table \ref{table:best-practices} summarises the implemented best practices. diff --git a/docs/thesis/chapters/5_cases/main.tex b/docs/thesis/chapters/5_cases/main.tex new file mode 100644 index 0000000..4b460d6 --- /dev/null +++ b/docs/thesis/chapters/5_cases/main.tex @@ -0,0 +1,14 @@ +\chapter{The ScoutinScience Platform} \label{chapter:case} + +The core product of ScoutinScience B.V.\footnote{\href{https://scoutinscience.com/}{scoutinscience.com}} is its Platform\footnote{\href{https://dashboard.scoutinscience.com/}{dashboard.scoutinscience.com}}. The clients are Technology Transfer Offices of Dutch and German universities, government organisations (e.g. Wetsus), and corporations (e.g. Heraeus Group and Ruma Rubber B.V.) who wish to extend the scope of their R\&D activities. ScoutinScience connects to multiple data sources of academic publications and integrates them into a single database. Each new publication is evaluated with a suite of AI components that ultimately determine its technology-transfer potential. Other markers are also extracted that help the users get a quick overview of the authors, topics, and contributions of a given piece of research. + +Each client organisation gets to see a different filtered view of this database ranked by the predicted probability of technology-transfer opportunities being present. The main motivation is to make these business developers' and other professionals' work more efficient by showing them which papers have the highest chance of being considered interesting by them. + +To achieve this, we have a service-based architecture \cite{kleppmann2017designing} on the backend-side --- apart from the data integration, communication, and business logic --- it is made up of services wrapping simpler (phrase-matching, Naïve Bayes) and more sophisticated (conditional random fields, transformer) models. As we will soon see, these can also depend on each other; for instance, based on the predicted scientific domain, a different model can be chosen for scoring certain aspects of papers. + +I was among the first engineers on the team, which has grown considerably in the past two years. While architecting, designing, and integrating more and better models into our software solution, I experienced the same difficulties as were described in Chapter \ref{chapter:background}. The gap between prototypes and production-ready services is larger than it seems, and it is also larger than it should be. This has motivated me to investigate the state-of-the-art, and I have found that it is insufficient in many cases. Since the ScoutinScience Platform is a typical example of applying AI in the industry, it will serve as the real-life case, problem context, and testbed for attempting to design a solution that can hopefully advance the state-of-the-art. + +This chapter describes the process of designing \textit{GreatAI} and how it fits into real-life use cases. First, a simple experiment is presented which investigates a Naïve Bayes classifier's \cite{maron1961automatic} accuracy at predicting the fields of papers. This leads to the implementation of a software service that is deployed to production. Subsequently, as the feature set of the library grows and matures, a more complex component is developed concerning text-summarisation with SciBERT \cite{beltagy2019scibert}. After implementing each case, the insights gained are fed back into the library's design. + +\input{chapters/5_cases/naive-bayes} +\input{chapters/5_cases/scibert} diff --git a/docs/thesis/chapters/5_cases/naive-bayes.tex b/docs/thesis/chapters/5_cases/naive-bayes.tex new file mode 100644 index 0000000..610fcf1 --- /dev/null +++ b/docs/thesis/chapters/5_cases/naive-bayes.tex @@ -0,0 +1,201 @@ +\section{Domain classification with Naïve Bayes} \label{section:simple-case} + +Using different models for slight variations of the same problem is commonplace in the industry. For instance, UberEats has a vast hierarchical set of models for every country, region, and city for calculating the estimated time of delivery \cite{li2017scaling}. We have also found that in order to best process an academic publication, knowing its domain is essential. One of the reasons for this can be the wildly different vocabularies of different domains. For example, the term \textit{framework} in computer science almost always refers to a software artifact (usually implying high tech-transfer potential). In contrast, in most other domains, \textit{framework} is used to describe theoretical models that are less central to practical applications. Of course, it is not merely the meaning of the terms but, more importantly, their distribution that varies significantly. Therefore, the topic of this section is to design and develop a domain prediction classifier for academic papers. + +\subsection{Background} + +Fortunately, this is one of the oldest text classification tasks. In fact, Maron introduced the Naïve Bayes classifier in 1961 \cite{maron1961automatic} for precisely this purpose: classifying documents' subjects. However, it is still an active problem when it comes to academic texts, as indicated by Elsevier-funded research carried out by Rivest et al. \cite{rivest2021level}. They created a 176-class classification problem for comparing bibliometric and deep-learning approaches. However, this comparison is made difficult because 44\% of the labels are \textit{assigned suboptimally} in the ground truth dataset. + +Prior work evaluated SciBERT \cite{beltagy2019scibert} --- a BERT \cite{devlin2018bert} model pretrained on academic publications --- on a simpler version of the task in which the domains of sentences\footnote{Sentences are more appropriate units for processing due to SciBERT's maximum token length of 512 which comes from its attention mechanism's quadratic complexity \cite{vaswani2017attention}.} have to be decided\footnote{\href{https://paperswithcode.com/sota/sentence-classification-on-paper-field}{paperswithcode.com/sota/sentence-classification-on-paper-field}}. It achieved an F1-score of $0.6571$ after being pretrained on the Semantic Scholar Corpus (SSC) \cite{Lo2020S2ORCTS} and fine-tuned on the train split of the Microsoft Academic Graph (MAG) dataset \cite{wang2019review}\footnote{SciBERT was applied to a preprocessed version of this dataset, available at: \\ \href{https://github.com/allenai/scibert/tree/master/data/text_classification/mag}{github.com/allenai/scibert/tree/master/data/text\_classification/mag}}. To our knowledge, no other published work exists on this sentence classification task. This may be explained by the task's lack of practical relevance and contrived nature (uniform label distribution), as we will see in the following subsection. + +\begin{displayquote} +\textbf{Design note} After getting familiar with the context, it is time to focus on experimenting and developing our domain prediction service. At the same time, the difficulties encountered should be noted and integrated into \textit{GreatAI}'s design. +\end{displayquote} + +\subsection{Data} + +\begin{figure} + \centering + \includegraphics[width=0.45\linewidth]{figures/mag-distribution.png} + \captionsetup{width=.9\linewidth} + \caption{Class distribution of the MAG \cite{wang2019review} dataset's 84000 sentences in its \textit{train} split.} + \label{fig:mag-distribtion} +\end{figure} + +Two datasets are considered for the experiments: SciBERT's MAG and the SSC. The former is used to compare the results with SciBERT's, while the latter is utilised for training a model for production purposes because it has 19 labels compared to MAG's 7, and it also contains abstracts instead of just sentences; thus, it is more fitting for our practical use case. + +SciBERT's version of the MAG dataset has 84,000 and 22,300 sentences in its train and test splits, respectively. These are mostly in English and have all punctuation and casing removed. Each sentence is classified as belonging to one of seven fields. Figure \ref{fig:mag-distribtion} shows that the classes have a uniform distribution. + +\begin{figure}[H] + \centering + \includegraphics[width=0.8\linewidth]{figures/ss-distribution.png} + \captionsetup{width=.9\linewidth} + \caption{Label distribution of the Semantic Scholar dataset \cite{Lo2020S2ORCTS}. Each publication may be assigned at most three labels.} + \label{fig:ss-distribution} +\end{figure} + +SSC is much larger: it contains over 80 million abstracts. Having more data certainly helps in sampling the term distribution more accurately; nonetheless, the law of diminishing returns applies, especially when using simple models. Therefore, the data are randomly downsampled to give us a more manageable couple of hundreds of megabytes of abstracts. We can see the distribution of class labels in Figure \ref{fig:ss-distribution}. The dataset is considerably less balanced: \textit{medicine} is by far the most voluminous field. + +\begin{displayquote} +\textbf{Where should we store this data?} ``On my machine'' seems like an easy answer. However, if we have a team working with the data or it has intrinsic value, it must be stored in an easy-to-access, potentially redundant way. Serban et al. \cite{serban2020adoption} expressed this need in the following best practice: \textit{Make Data Sets Available on Shared Infrastructure (private or public)}. Meanwhile, wherever data is stored, it should also be versioned to satisfy the next best practice: \textit{Use Versioning for Data, Model, Configurations, and Training Scripts}. +\end{displayquote} + +MAG needs no further preprocessing if we aim to match SciBERT's setup \cite{beltagy2019scibert}. However, since SSC contains heaps of metadata, the relevant parts have to be extracted and preprocessed. In this case, these are the concatenation of the abstract's text and the paper's title along with the paper's domains (there can be multiple domains for a single paper: it is a multi-label classification task). Lastly, the non-English entries are discarded because we only expect to process papers in English. + +\begin{displayquote} +\textbf{How should we preprocess the data?} These simple processing steps (filter, map, project) are almost always present in the data science lifecycle. For example, cleaning the input text from various HTML, OCR, PDF, or \LaTeX \hskip 0.12cm extraction artifacts is normally necessary for text analysis. This is captured in the \href{https://se-ml.github.io/practices}{AI best practices collection} under the following category: \textit{Write Reusable Scripts for Data Cleaning and Merging}. Also, the best practice of \textit{Test all Feature Extraction Code} is somewhat applicable: the applied processing steps must not introduce unwanted side-effects. +\end{displayquote} + +\subsection{Methods} + +Our aims are twofold: (1) to evaluate a sentence classification model on MAG and compare it with the prior art; and (2) to retrain and apply this model for classifying publication metadata (including abstracts). This would allow the ScoutinScience Platform to select an appropriate processing pipeline which has been trained on a matching vocabulary (and domain) for each publication. + +It seems reasonable that only considering the distribution (frequencies) of individual terms may be sufficient. For testing this hypothesis, a unigram language model --- Multinomial Naïve Bayes (MNB) --- is constructed, and its accuracy is compared with SciBERT's. The former definitely aligns with the advice to \textit{Use The Most Efficient Models}. Using the MNB implementation of scikit-learn \cite{pedregosa2011scikit}, it only took 71 lines of code to create, hyperparameter optimise, and test a text classifier.\footnote{The code is available at \href{https://great-ai.scoutinscience.com/tutorial/}{great-ai.scoutinscience.com/tutorial}.} This further proves how simple it is to use standard packages. The code can be considered for satisfying the \textit{Automate Hyper-Parameter Optimisation} best practice since it also implements an automated hyperparameter sweep. + +The sentences are tokenised into words and vectorised with TF-IDF (with logarithmic term frequency) \cite{buckley1985implementation}, the hyperparameters found via 10-fold cross-validation on the \textit{train} split lead to filtering out tokens which occur in fewer than five documents or more than 5\% of the documents. + +\begin{displayquote} +\textbf{What could be automated here?} As discussed in Section \ref{section:accessible-ai}, libraries exposing algorithms and even SOTA models can already be considered mature and accessible. In this case, only scikit-learn was utilised, but subjectively, most popular libraries have a similarly easy-to-use API. Therefore, there seems to be no urgent need for further action regarding the \textit{experimentation} step of the lifecycle in connection with the AI best practices. +\end{displayquote} + +\subsection{Results \& Discussion} + +\begin{figure} + \centering + \includegraphics[width=0.9\linewidth]{figures/mag-confusion.png} + \captionsetup{width=.9\linewidth} + \caption{Confusion matrix of a Naïve Bayes classifier on the MAG dataset's sentences. The matrix is normalised column-wise. Notice, how most mistakes happen between semantically similar classes, for instance: \textit{politics} -- \textit{sociology} or \textit{business} -- \textit{economics}.} + \label{fig:mag-confusion} +\end{figure} + +\begin{figure} + \centering + \includegraphics[width=\linewidth]{figures/ss-confusion.png} + \captionsetup{width=.9\linewidth} + \caption{Confusion matrix of a Naïve Bayes classifier on the SSC dataset's sentences. The matrix is normalised column-wise. Notice, how most mistakes happen between semantically similar classes, for instance: \textit{philosohpy} -- \textit{sociology} or \textit{history} -- \textit{art}.} + \label{fig:ss-confusion} +\end{figure} + +When this model is applied to the \textit{test} split of MAG, we get the confusion matrix of Figure \ref{fig:mag-confusion}. This Naïve Bayes classifier achieves a whopping $0.6795$ F1 score, which is $2.3\%$ more than SciBERT's on the same dataset. Thus, it seems that MNB clearly outperforms SciBERT for this particular use case: it is not only more accurate, but its model is magnitudes smaller. At the same time, it is also considerably faster to train (or fine-tune in the case of SciBERT) and use (its running time is in the order of milliseconds per publication). It also has no upper limit on the input length. Thus, this experiment validates choosing MNB for the task over SciBERT. + +It is, of course, not entirely surprising that the sophisticated transformer architecture of SciBERT is not necessary for a straightforward task like this. Apart from phrases, the relations between separate words of a sentence do not carry nearly as much discriminative power as the identity of the terms \cite{hand2001idiot}; hence, there is little reason for using an attention mechanism. The fact that SciBERT even works in any way on this task is already a testament to its general applicability. Nevertheless, this short experiment has proved that we can safely opt for using MNB for production. + +Since Multinomial Naïve Bayes is best at returning a single label and SSC has multiple labels per datapoint: for evaluation purposes, it is checked whether the returned label is contained in the labels of the ground truth. On this dataset, MNB achieves a lower macro-average than on MAG, with an F1-score of 0.59.\footnote{The code for this is available at \href{https://great-ai.scoutinscience.com/examples/simple/deploy}{great-ai.scoutinscience.com/examples/simple/deploy}.} The weighted-average F1 is 0.70, and the overall accuracy is also 70\%. The substantial difference between the macro and weighted averages comes from the unbalanced distribution of the labels. The lower F1-score is not surprising because this dataset has more than twice as many classes. Additionally, the mistakes made are defensible when we look at Figure \ref{fig:ss-confusion}: most of them are between related domains. + +\begin{displayquote} +This is the usual point where papers conclude: a proof-of-concept/prototype has been built, and its performance demonstrated, measured --- and usually --- explained. Nonetheless, in an industrial setting, our problem is far from being solved: it has yet to be deployed. +\end{displayquote} + +\subsection{Deployment} + +First, an inference function needs to be written to take input on the fly and calculate a corresponding prediction. Since we aim to follow the best practices \textit{Explain Results and Decisions to Users} and \textit{Employ Interpretable Models When Possible}, explaining the results is expected. Fortunately, with our simple model, it is easy to determine the most influential weights, thus, words. The explanations are derived by taking the top five tokens from the input text ranked by their feature weights. The last deployment step is to provide access to our model for others. + +\begin{displayquote} +\textbf{How do we provide an interface for the inference function?} We either have an offline or online inference workflow (or both). For the former, we have to provide a way to use it in batch processing; a simple Python function may be adequate for this purpose, though allowing it to be easily (or automatically) parallelised would improve its consumers' DX. If it is an online workflow, we must have a service running continuously and accepting input at any time. This can be achieved by a remote procedure call (RPC) interface or, more commonly, a web API. Developers usually refer to these as REST APIs, and sometimes, they even follow the conventions of REST. Either way, we must develop a wrapper over the service to make it available to other internal/external consumers. +\end{displayquote} + +According to the body of research on the adoption of best practices, this is where many real-world projects conclude. This also happens to be \textbf{the gap}. Believing that solely focusing on the research and experiments is good enough is a fallacy: when following this approach, the deployment step ends up being a rushed attempt of wrapping the \textit{AI} and putting it in the production environment. This is, inarguably, a deployment. However, it likely follows very few of the best practices, which can lead to suboptimal real-life performance, lack of accountability, lack of opportunity to improve, and possibly an overall negative societal impact. + +\begin{displayquote} +\textbf{How could we implement more best practices?} The most notable missing software/operations features are the lack of automated deployment, automated regression testing, online monitoring, persisting prediction traces, graceful error-handling, taking feedback on the results (if possible in the use case), calculating the online accuracy based on the feedback, and retraining the model if necessary using novel data. These all correspond to best practices. +\end{displayquote} + +\section{Bridging the gap with GreatAI} + +Let us first revisit the library's scope for clarification. As concluded in Section \ref{section:scope}, \textit{GreatAI} should ease the \textit{transition} step between prototypes and production-ready deployments. However, this leaves open the question of what constitutes this step. There are cross-cutting concerns; for example, feature extraction is implemented and used in the training phase, but it is also deployed alongside the model. The robustness criterion has to be met by this procedure even though its implementation is only in focus in the earlier stages of the project. Since having an untested function deployed into production can have severe repercussions, we can conclude that assuring its correctness lies within the scope of \textit{GreatAI}. Henceforth, cross-cutting concerns should be covered. + +This section briefly explores how the problems raised can be solved using \textit{GreatAI} and the API it provides to best fit the needs of its users. We first focus on the aspects of data, then we discuss the utility of helper functions, and lastly, the automated wrapping of services. + +\subsection{Handling data} \label{subsection:large-file} + +The obstacles coming from the intertwined nature of different models are widely recognised \cite{haakman2021ai,amershi2019software,sculley2015hidden}. This can lead to non-monotonic error propagation, meaning that improvements in one part of the system might decrease the overall system quality \cite{amershi2019software}. The importance of schema versioning in an environment of rapidly changing models and transformations is highlighted for a specific use case in \cite{van2017versioning} and more generally by the \textit{Use Versioning for Data, Model, Configurations and Training Scripts} best practice. These emphasise the requirement for versioning models and, in general, data. + +We must address two data storage needs: training data and trained models. Proper version control is one of the most basic expectations for commercial codebases. Based on developer surveys, it is likely that our code is already tracked under Git and synchronised with GitHub\footnote{\href{https://octoverse.github.com/\#lets-look-back-at-the-code-and-communities-built-on-git-hub-this-year}{octoverse.github.com/\#lets-look-back-at-the-code-and-communities-built-on-git-hub-this-year}}. Therefore, using Git Large File Storage (LFS) might seem intriguing. However, it is a paid (and surprisingly expensive) service of GitHub, especially when we factor in the expected sizes of the models and training data with the fact that the only way to remove files counting towards our quota is to delete the entire repository\footnote{\href{https://docs.github.com/en/repositories/working-with-files/managing-large-files/removing-files-from-git-large-file-storage\#git-lfs-objects-in-your-repository}{docs.github.com/en/repositories/working-with-files/managing-large-files/removing-files-from-git-large-file-storage}}. + +An open-source tool, the Data Version Control (DVC)\footnote{\href{https://dvc.org/}{dvc.org}} provides a nearly perfect alternative. It comes with a command-line interface (CLI) inspired by Git's and can be integrated with several backend storage servers. Its only downside is, of course, that it is one more tool that increases the complexity of the project and the initial setup time. If this is an acceptable price to pay, then we highly recommend opting for DVC. Nevertheless, if this may prohibit a team\footnote{As was the case with MLFlow tracking in an ING team described in Section \ref{section:industry}.} from properly handling data according to the best practices, we present a simpler solution. + +The complexity of an API can be decreased by relying on its users' preexisting knowledge, and known patterns \cite{hermans2021programmer,ousterhout2018philosophy}. Therefore, we can reuse familiar APIs, such as the \texttt{open()} method from Python. Therefore, a method is proposed which provides the same interface; however, the backing storage can be a mixture of local disk space, S3-compatible storage, MongoDB, or any other storage backend. It provides a superset of \texttt{open()}'s interface\footnote{\href{https://docs.python.org/3/library/functions.html\#open}{docs.python.org/3/library/functions.html\#open}}: the same parameters can be used with it resulting in similar observed behaviour. The expected features: versioning, progress bars, caching, garbage collecting the cache, and automatically deleting old remote versions are all present and come with recommended --- but easy to see and change --- configuration. + +Easing development is not merely about automating everything but also about making the code easy to change (which is the \textit{Viscosity} dimension of CDCB). Going from opening a local file on the disk with the built-in open method, to opening a file from S3 is as easy as changing \texttt{open(`file.txt', `w')} to \texttt{LargeFileS3(`file.txt', `w')}. In the case of the latter, an additional \texttt{version} keyword argument can also be given to lock ourselves in using a specific version which can be desirable in the case of models. + +\subsection{Utilities} + +It is easy to notice multiple recurring tasks when it comes to processing text. Cleaning it from various extraction artifacts and normalising characters are some of the most common. But splitting sentences, language tagging, and robustly lemmatising are also often recurring tasks. Because having reusable and tested feature extraction code covers two best practices, it seems straightforward that a utility module could be created for this, which could be extensively tested through unit testing. + +This is exactly the motivation behind \texttt{great\_ai.utilities}. Extra care has to be taken not to overfit these utilities on the cases considered in this chapter; however, we believe these are versatile enough to be helpful in many text-related contexts. A conclusive answer to this assumption will be found during the interviews. + +Implementing the unit tests uncovered multiple edge cases and even runtime errors; hence, the merit of \textit{Test all Feature Extraction Code} best practice is unequivocal. There is one more best practice that could be partially covered here, especially because its solution also helps both during batch inference but also at training/feature extraction time: \textit{Enable Parallel Training Experiments}. + +A function called \texttt{parallel\_map()} is also implemented which closely mimics the API of the built-in Python function: \texttt{map}. Furthermore, it exemplifies how even a close to trivial function can improve the DX by magnitudes. Rooted in the global interpreter lock (GIL)\footnote{\href{https://wiki.python.org/moin/GlobalInterpreterLock}{wiki.python.org/moin/GlobalInterpreterLock}} of CPython, in almost all cases, multi-threading does not lead to higher performance of CPU-bound tasks. For this purpose, multiprocessing has to be used. Fortunately, the standard \texttt{multiprocessing} library has a great API. However, doing a parallel mapping task with a progress bar still takes about a dozen lines. This can deter people (at least me) from taking advantage of more than just a single CPU core during exploratory experimentation. With \texttt{parallel\_map()}, this challenge becomes a one-liner routine task. + +\subsection{Deployment approach} + +Some of the expectations one might have for data-intensive (such as AI) software are similar to that for software in general. These are also captured by the best practices: \textit{Use Continuous Integration}, \textit{Automate Model Deployment}, and \textit{Enable Automatic Roll Backs for Production Model} to name a few. It is important to notice that these have already been solved by software engineering, more specifically, by the DevOps paradigm \cite{leite2019survey}. +In line with the findings of John et al. \cite{john2020architecting} on the SOTA of AI deployments, we suggest wrapping the applications in a format more compatible with existing DevOps toolkits. Instead of reinventing the wheel, we should rely on more established DevOps best practices for implementing the SE4ML deployment best practices. Besides, organisations are expected to have their deployment processes for classical applications; thus, allowing them to reuse those for AI applications seems to be the most convenient approach. + +Based on personal experiences, three types of software artifacts are identified (in the context of Python) for which a wide range of established practices exist. WSGI server\footnote{\href{https://peps.python.org/pep-3333/}{peps.python.org/pep-3333}} compatible applications, executable scripts, and Docker Images\footnote{\href{https://docs.docker.com/registry/spec/manifest-v2-2/}{docs.docker.com/registry/spec/manifest-v2-2}}. To achieve this, \textit{GreatAI} provides a compatibility layer between simple Python inference functions and all the abovementioned common artifacts. Taking functions as input for the first step also satisfies the requirement to be \textbf{General}. Nevertheless, to also allow customisation, additional configuration, metadata, and behavioural specification can be given as well. + +\begin{listing}[h] +\begin{minted}[ +frame=lines, +framesep=2mm, +baselinestretch=1, +linenos +]{python} +from great_ai import GreatAI + +@GreatAI.create +def greeter(name: str) -> str: + return f"Hello {name}!" +\end{minted} +\captionsetup{width=.9\linewidth} +\caption{Simplest example using \textit{GreatAI} for wrapping a function. In practice, \texttt{greeter} could be the inference function of an ML model.} +\label{listing:hello-world} +\end{listing} + +The main advantage of the wrapping approach is that it does not require any input from the clients (by default). We opted for a decorator \cite{gamma1995design}, which lets users wrap their function by adding a single additional line of code as shown in Listing \ref{listing:hello-world}. After which, the created WSGI application can be accessed through the \texttt{greeter.app} property where \texttt{greeter} is the identifier of the user-defined function. A CLI script (\texttt{great-ai}), along with a \texttt{Dockerfile} are also provided to cover the other two deployment artifacts. + +\begin{listing}[h] +\begin{minted}[ +frame=lines, +framesep=2mm, +baselinestretch=1, +linenos +]{python} +from great_ai import save_model, GreatAI, parameter, use_model, log_metric + +# this could have been called in another script +save_model('special_number', 405) + +@GreatAI.create +@parameter('positive_number', validate=lambda n: n > 0) +@use_model('special_number', version='latest', model_kwarg_name='special') +def add_to_special_number(positive_number: int, special: int) -> int: + """This docstring will be parsed and exported as documentation.""" + log_metric('log directly into the Trace', positive_number ** 2) + return special + positive_number + +assert add_number(12).output == 417 +\end{minted} +\captionsetup{width=.9\linewidth,position=top,skip=-20pt} +\caption{A simple \textit{GreatAI} service with behavioural customisations.} +\label{listing:complex} +\end{listing} + +\newpage + +Coincidentally, deployment best practices can be easily implemented in this wrapper layer. In the first iteration, these are input validation, persisting traces, online monitoring, and generating documentation. Input validation may be used to \textit{Check that Input Data is Complete, Balanced and Well Distributed}. Traces are essential for both \textit{Log Production Predictions with the Model's Version and Input Data} and \textit{Provide Audit Trails}. However, traces can also indirectly help \textbf{Robustness} because even production systems cannot be expected to be perfect. Saving and letting the users filter on encountered errors while allowing them to correlate those with the inputs producing them is imperative for facilitating debugging. Lastly, monitoring and documentation correspond with helping best practices: \textit{Continuously Monitor the Behaviour of Deployed Models} and \textit{Communicate, Align, and Collaborate With Others} respectively. + +To allow customising the service's behaviour to fit different use cases, the default configurations can be overridden by calling some library functions. An example of this can be seen in Listing \ref{listing:complex}, while more details of the semantics can be found in the documentation\footnote{\href{https://great-ai.scoutinscience.com/how-to-guides/create-service/}{great-ai.scoutinscience.com/how-to-guides/create-service}}. + +\subsection{Summary} + +\begin{figure}[H] + \centering + \includegraphics[width=0.8\linewidth]{figures/dashboard-domains.png} + \captionsetup{width=.9\linewidth} + \caption{Screenshot of the domain prediction integrated into the ScoutinScience Dashboard, where it is used as a filtering option.} + \label{fig:dashboard-domains} +\end{figure} + +After implementing some features of the library, it can already be used for deploying the previously discussed domain prediction model. In this case, online prediction is expected; hence, the REST API-based deployment is chosen, which is created by \texttt{@GreatAI.create} and packaged into a Docker image. This image can be instantiated by the company's existing DevOps pipeline and cloud infrastructure. In the end, users can see one more tag in the header section of publication evaluations, where they can also see the explanation behind the model's decision as demonstrated in Figure \ref{fig:dashboard-domains}. Let us now explore how the framework fares in a more complex case. diff --git a/docs/thesis/chapters/5_cases/scibert.tex b/docs/thesis/chapters/5_cases/scibert.tex new file mode 100644 index 0000000..6600681 --- /dev/null +++ b/docs/thesis/chapters/5_cases/scibert.tex @@ -0,0 +1,168 @@ +\newpage +\section{Text summarisation with SciBERT} \label{section:complex-case} + +The ScoutinScience Dashboard contains a full-page evaluation view for academic publications. On this, the known metadata, historical trends about the paper's topics, social media mentions, a PDF viewer showing the document, and other augmentation tools are displayed. One of these is the \textit{Highlights} section, which aims to summarise the paper from a technology-transfer perspective. + +The current approach uses a simple heuristic based on a set of phrases selected by business developers and extended with the help of a word2vec model \cite{mikolov2013efficient}. The user feedback deemed this implementation slightly helpful but inadequate for providing an accurate overview. Thus, this is the baseline we attempt to improve on in this section. + +\begin{displayquote} +Compared with Section \ref{section:simple-case}, this time around, the toolset of \textit{GreatAI} is available at our disposal. Hopefully, this will streamline the development and --- especially --- the deployment. Given its arguably higher complexity, the experiment falls closer to industrial use cases and hence, can give more accurate feedback on how to further improve the API. +\end{displayquote} + +\subsection{Background} + +Automatic text summarisation (ATS) is also one of the earliest established tasks of text analysis and boasts numerous promising results \cite{el2021automatic}. Text summarisation is usually divided into extractive and abstractive approaches. Even though the latter can lead to more fluent summaries, it is also prone to hallucinate content that is unfaithful to the input \cite{maynez2020faithfulness}. For this reason, extractive techniques are preferred in this case. + +Our problem requires generating a special type of summary: it must only concern a single aspect (tech-transfer) of the document. Aspect-based text summarisation has also seen some progress over the last decades \cite{berkovsky2008aspect,hayashi2021wikiasp}, but these methods require concretely defined topics. Unfortunately, \textit{tech-transfer potential} is anything but a clear topic definition. + +Numerous discussions and interviews with business developers over the last two years made it clear that there is no universally agreed-on definition of it. At least all of them agree that they know it when they see it. Additionally, most of them agree that they can confidently make a decision on the granularity of sentences. This gives rise to an obvious idea: show the experts something they can annotate. Because experts' time is valuable, and relevant sentences are few and far between, extra care needs to be taken to improve the ratio of positive examples in the dataset. The research of Iwatsuki Kenichi on formulaic expressions (FEs) \cite{iwatsuki2020evaluation,iwatsuki2021extraction,iwatsuki2021communicative,iwatsuki2022extraction} provides a promising direction to do so. + +A formulaic expression is a phrase with zero or more ``slots'' which, when filled appropriately, leads to expressing a certain intent. In the context of scientific text, an example\footnote{Taken from the ground truth data available at \href{https://github.com/Alab-NII/FECFevalDataset/blob/master/human_evaluation/background.tsv}{github.com/Alab-NII/FECFevalDataset}.} could be: \texttt{it was not until * that}. The asterisk can be substituted with multiple terms, and the intention of this expression is (likely) to describe the \textit{History of the related topics}. Iwatsuki et al. identified a set of 39 intentions, compiled a manually labelled dataset \cite{iwatsuki2020evaluation}, and developed multiple approaches for automatically extracting and classifying formulaic expressions in large corpora \cite{iwatsuki2021communicative,iwatsuki2022extraction}. + +\subsection{Methods} + +In order to compile a new dataset, experts are asked to judge sentences that passed an \textit{intention check}. This pooling approach is commonly used in information retrieval \cite{schutze2008introduction}. The filtering is expected to sieve out sentences that are probably not relevant from a technology-transfer perspective using Iwatsuki's formulaic expression intention classes. Subsequently, relevance judgements --- in the form of \textit{interesting} or \textit{not interesting} labels --- are gathered for the remaining sentences. Figure \ref{fig:annotator} shows an example of the annotation task. Our method turns the extractive summarisation into a binary classification task for which a SciBERT model \cite{beltagy2019scibert} can be fine-tuned. Ultimately, the summaries are derived from sentences selected by the classifier trained on the experts' annotations. + +\begin{figure}[h] + \centering + \includegraphics[width=0.75\linewidth]{figures/annotator.png} + \captionsetup{width=.9\linewidth} + \caption{The annotator GUI showing a single sentence and the two labels that can be assigned based on its relevance to technology-transfer.} + \label{fig:annotator} +\end{figure} + +We have to note two possible shortcomings of this setup: firstly, the FE intentions are assumed to be strongly correlated with the sought-after \textit{tech-transfer opportunities} aspect. This may or may not be true. Secondly, only the individual relevance of the sentences is considered instead of the overall relevance (utility) of the summary. Nonetheless, we expect that stemming from the length of the documents, and the sparseness of the selected sentences, any combination of them is likely to have low redundancy. + +\subsection{Results} + +For the first iteration, 1500 sentences were selected for two experts to annotate in a binary fashion according to strict guidelines. Afterwards, for measuring the interrater agreement, we calculated Cohen's kappa \cite{cohen1960coefficient} as shown in Equation \ref{equation:kappa}, which turned out to be \textbf{0.43} for the two annotators. This happens to be just above the lower end of \textit{moderate agreement}. Even though the original quality ranges are sometimes criticised for being too relaxed for the medical domain \cite{mchugh2012interrater}, some leniency is acceptable for many NLP tasks due to their subjectiveness. Regardless, in the case of summarisation, Verberne et al. \cite{verberne2018creating} argue that reasonable end-quality can be reached even when the interrater agreement is relatively low. The ground truth is determined by taking the logical disjunction of the annotations. This is reasonable because the annotators have dissimilar backgrounds and likely judged slightly different aspects of the sentences. + +\begin{equation} \label{equation:kappa} +\kappa_{agreement} \equiv \frac{p_{observed} - p_{expected}}{1 - p_{expected}} = 1 - \frac{1 - p_{observed}}{1 - p_{expected}} +\end{equation} + +\begin{displayquote} +\textbf{Reproducibility} Reproducible experiments are generally preferred. It is easy to forget to set some seed values and, for example, end up with different data points in the test-train splits during training and validation in a Continuous Integration (CI) pipeline, thus, data leakage. For facilitating reproducibility, it would be useful to reset the seeds of each imported library's random number generators (RNGs) when \textit{GreatAI} is configured. Thus, a feature has been added to detect and reset RNGs of installed and imported libraries. This certainly will not solve the reproducibility crisis \cite{hutson2018artificial} on its own; however, in some cases, it can result in one fewer step to miss. +\end{displayquote} + +\begin{figure}[h] + \centering + \includegraphics[width=0.7\linewidth]{figures/scibert-confusion.png} + \captionsetup{width=.9\linewidth} + \caption{Confusion matrix of the fine-tuned SciBERT model on the \textit{summary candidate sentences} dataset.} + \label{fig:scibert-confusion} +\end{figure} + +The next step is fine-tuning SciBERT with the help of Hugging Face \texttt{transformers} \cite{wolf2019huggingface}. The data are divided into training and test splits with a ratio of 4:1. A validation split, used for early stopping, is also derived from the train split. The objective function is the F1-score of the positive class, and the early stopping patience is five epochs. The learning rate is $5 \times 10^{-5}$ and AdamW \cite{loshchilov2017decoupled} is used for optimisation with a weight decay of 0.05. The code can be found in the documentation\footnote{\href{https://great-ai.scoutinscience.com/examples/scibert/train/}{great-ai.scoutinscience.com/examples/scibert/train}}, it is surprisingly slightly shorter than the code of Section \ref{section:simple-case}. + +\begin{displayquote} +\textbf{Utility of LargeFiles} For the purposes of the documentation, the fine-tuning was conducted in the Google Colab online environment, which is excellent for providing anyone with GPU time for free. However, notebook environments are ephemeral, resulting in the need to manually upload and download all relevant data whenever a new virtual machine instance is granted. The \texttt{LargeFile} implementation alleviated this problem by automatically handling the uploads and downloads. Of course, first, backwards compatibility had to be solved for Python 3.7, the only available environment in Colab. +\end{displayquote} + +\begin{table}[ht] + \centering + \begin{threeparttable} + \caption{Accuracty metrics of the fine-tuned SciBERT model on the \textit{summary candidate sentences} dataset.} + \label{table:scibert-pr} + \setlength{\tabcolsep}{0.75em} % for the horizontal padding + {\renewcommand{\arraystretch}{1.2} % for the vertical padding + \begin{tabular}{|l|r|r|r|} + \hline + {} & \textbf{Precision} & \textbf{Recall} & \textbf{Support} \\\hline + \textsc{non-relevant} & 0.93 & 0.83 & 191 \\\hline + \textsc{relevant} & 0.73 & 0.88 & 109 \\\hline + \end{tabular}} + \end{threeparttable} +\end{table} + +Let us check how well the selected sentences correspond with the tech-transfer potential. Users and in-house experts can rate publications (from a tech-transfer perspective) by assigning them to one of four categories: \texttt{A}, \texttt{B}, \texttt{C}, and \texttt{D} with \texttt{A} being the most and \texttt{D} the least promising. This feedback is stored and used for analytic and training purposes. Since both the feedback grade and the relevant (summary candidate) sentences are supposed to reflect the same aspect of papers, we can reasonably expect some correlation between the grades and relevant sentence counts. + +\begin{figure}[h] + \centering + \includegraphics[width=0.9\linewidth]{figures/highlights-histograms.png} + \captionsetup{width=.9\linewidth} + \caption{Distribution of mean predicted summary candidate sentence counts (refered to as \textit{highlights}) in 4 categories. Category \texttt{A} corresponds to the most, while \texttt{D} to the least interesting papers based on mean user feedback. The sample size is 1406 (\texttt{D}=715, \texttt{C}=309, \texttt{B}=198, \texttt{A}=184). The histograms are on the same scale but shifted vertically according to the grade to which they correspond.} + \label{fig:histograms} +\end{figure} + +The best validation results were achieved after eight epochs which is slightly more than expected but is presumably due to the weight decay. The confusion matrix on the test split can be seen in Figure \ref{fig:scibert-confusion}, and the per class accuracy metrics in Table \ref{table:scibert-pr}. Despite the task's subjective definition, SciBERT achieves good quality, indicated by an F1-score of \textbf{0.80}. + +Figure \ref{fig:histograms} shows the ratio of summary candidate sentences as predicted by the fine-tuned model in 4 categories (grades) of papers. This dataset does not overlap with the training data; hence, the results come solely from the model's ability to generalise. It is interesting to see that the Spearman's rank correlation coefficient \cite{spearman1961proof} between the normalised ``highlights'' counts and the ratings of papers is \textbf{0.4784} and is statistically significant ($P = 5.4 \times 10^{-74}$). This proves the presence of a monotonic association. For context, the correlation between the grades and the number of sentences chosen by the baseline approach is 0.06597 ($P = 0.03$). We can conclude that the classifier's output is indicative of publications' tech-transfer potential. + +\begin{figure}[t] + \centering + \includegraphics[width=\linewidth]{figures/dashboard-highlights.png} + \captionsetup{width=.9\linewidth} + \caption{The tech-transfer summary of an academic publication (\cite{bruns2022deep}). The titles and sentences can be clicked to navigate the paper on the right. Meanwhile, some explanation is provided by the highlighted words, the opacity of which corresponds to their attention weights.} + \label{fig:dashboard-highlights} +\end{figure} + +\subsection{Deployment} + +To implement the summarisation, at most, the top 7 selected sentences are chosen as ranked by their log probabilities. They are subsequently reordered according to their position in the text. As a quasi-explanation, the tokens' attention scores are visualised and overlaid on the highlighted sentences. The \textit{i}-th token's visualised attention comes from summing up the attention weights of each of the last layer's heads between the \texttt{[CLS]} and the \textit{i}-th token. To improve the end-user experience, a high-pass filter and a stop-word list are applied to the scores to avoid highlighting the syntax-related tokens (punctuation, determiners). The service --- after being integrated into the Dashboard --- can be seen in Figure \ref{fig:dashboard-highlights}. + +\begin{displayquote} +\textbf{Design inspiration} In order to get insights into their inner workings, Hugging Face models can be given \texttt{output\_attentions=True} in their constructor, which results in a new property becoming accessible on the results for querying the attentions. The only issue with it is that it is a 5-dimensional matrix which makes exploring and understanding it non-obvious. In short, it has very low \textit{Discoveribility}. For example, the attention weights for the GUI are calculated with this expression: +\begin{minted}[ +baselinestretch=1, +]{python} +np.sum(result.attentions[-1].numpy()[0], axis=0)[0][1:-1] +\end{minted} +Even though the operation is conceptually simple, because of the opaque data structure, this is anything but obvious to comprehend. Therefore, it is clear that this needs to be avoided in our library design; it has to have an explicit and discoverable API that can be achieved using type hints, descriptive property names, and docstrings. +\end{displayquote} + +\section{Improving GreatAI} + +After having solved two problems by implementing two standalone services and integrating them into an existing ecosystem while relying on \textit{GreatAI} as a primary tool, a wide variety of insights have been gained. In the next couple of subsections, the extra features and design decisions that were motivated by the \textit{Highlights (summarisation) service} are presented. After which, the final surface of the API is described, which will be evaluated by its relation to the deployment best practices \cite{serban2020adoption,serban2021practices,john2020architecting,john2020ai} in the next chapter. + +\subsection{Caching} + +Sustainability is an increasingly crucial concern of ethical AI \cite{van2021sustainable}. Without discussing the pros and cons of the green computing movement \cite{10.1145/1400181.1400186}, we can still agree that computing time should not be wasted. To this end, caching the results of expensive operations has to be considered in any AI deployment. In this case, the \textit{Highlights service} is often called multiple times from different other services with the same parameters. With each operation taking up to a couple of seconds, implementing caching can lead to vastly faster response times and an overall more socially conscious deployment. + +\subsection{Revisiting \texttt{parallel\_map}} + +Even though most inference functions are CPU-bound (or GPU-bound), it turns out that sometimes they involve IO, especially when relying on the results of other remote models. This means a significant performance improvement can be achieved by implementing some inference functions asynchronously \cite{tilkov2010node}. Thus, \textit{GreatAI} also has to support decorating both regular (synchronous) and asynchronous functions. One notable consequence is that the batch processing feature must also be compatible with \texttt{async} inference functions. Batch processing is still a helpful feature since it is likely that async inference functions are both IO (remote calls) and CPU (local evaluation) constrained at the same time. Thus, they can benefit from multi-core parallelisation. + +However, the standard library's \texttt{multiprocessing}, the third party \texttt{multiprocess} \cite{mckerns2012building}, and, another popular library, \texttt{joblib}\footnote{\href{https://joblib.readthedocs.io/en/latest/}{joblib.readthedocs.io/en/latest}} all lack the support for efficiently parallelising async functions. For this reason, \texttt{parallel\_map} was reimplemented to create an event-loop in each worker process to keep the efficiency of non-blocking IO while also providing parallelisation for the CPU-bound sections of code. + +\subsection{Human integration} + +\begin{figure} + \centering + \includegraphics[width=\textwidth]{figures/greatai-header.png} + \captionsetup{width=.9\linewidth} + \caption{The header of the automatically generated dashboard of the service from Section \ref{section:simple-case}. A generated documentation is shown on the left, while the histogram of response times is rendered on the right. The current configuration is prominently displayed on the bottom.} + \label{fig:greatai-header} +\end{figure} + +Even though the REST API of \textit{GreatAI} services exposes all necessary features\footnote{Such as providing feedback per prediction, complexly filtering and sorting traces, create-read-update-delete (CRUD) operations for the feedbacks and traces, accessing live monitoring info (current configuration, versions, cache statistics), etc.} which are great for programmatic access, these are not ideal for direct human consumption. To ease the introduction of \textit{GreatAI} services, a rudimentary dashboard is --- optionally --- generated. The dashboard's main features can be observed in Figures \ref{fig:greatai-header}, \ref{fig:greatai-table}, and \ref{fig:greatai-parallel}. The diagrams and filterable/sortable table are interconnected and are automatically updated; the reactive behaviour is provided by the Dash framework \cite{shammamah_hossain-proc-scipy-2019}. + +\begin{figure} + \centering + \includegraphics[width=\textwidth]{figures/greatai-table.png} + \captionsetup{width=.9\linewidth} + \caption{A dynamically updating, tabular view of traces matching a user-defined filter. Useful for exploring historical predictions or debugging the cause of exceptions (which are also searchable). The filters set in the table affect the other diagrams of the dashboard.} + \label{fig:greatai-table} +\end{figure} + +\begin{figure} + \centering + \includegraphics[width=\textwidth]{figures/greatai-parallel.png} + \captionsetup{width=.9\linewidth} + \caption{A parallel coordinates view of the traces displayed in the table above. Adding new axes is as easy as calling \texttt{log\_metric} inside the inference function.} + \label{fig:greatai-parallel} +\end{figure} + +\subsection{Programmatic integration} + +Apart from supporting \texttt{async} calls, a couple more steps can be taken to help integrate any service with a \textit{GreatAI} deployment. This is implemented by the \texttt{call\_remote\_great\_ai} function which hides the networking required to call a \textit{GreatAI} instance's REST API. It takes care of validation, automatic retries, serialisation, and deserialisation. It comes with the added benefit of encouraging decoupled services because the friction of integrating them is no longer noticeable, which is beneficial for human collaboration \cite{hasselbring2002component}. + +Additionally, a REST API is generated with its accompanying OpenAPI schema\footnote{\href{https://swagger.io/specification}{swagger.io/specification}} and served with a \href{https://swagger.io/}{Swagger} template. It also contains metadata about the function, for instance, its docstring, version, and version of its registered models concatenated in order to be SemVer\footnote{\href{https://semver.org/}{semver.org}} compatible. These can be seen in Figure \ref{fig:greatai-api}. This, combined with a \texttt{/version} HTTP endpoint for programmatic access and validation of the service's metadata, proved to be valuable features when integrating the \textit{Highlights service} into ScoutinScience's service-based architecture. + +\begin{figure} + \centering + \includegraphics[width=\linewidth]{figures/greatai-api.png} + \captionsetup{width=.9\linewidth} + \caption{Documentation of the automatically scaffolded REST API of a \textit{GreatAI} service. Notice, how its version string includes its registered models in a SemVer compliant way: \texttt{0.0.1+small-domain-prediction-v11}.} + \label{fig:greatai-api} +\end{figure} diff --git a/docs/thesis/chapters/6_interviews.tex b/docs/thesis/chapters/6_interviews.tex deleted file mode 100644 index d3c192a..0000000 --- a/docs/thesis/chapters/6_interviews.tex +++ /dev/null @@ -1,3 +0,0 @@ -\chapter{Interviews} \label{chapter:interviews} - -\section{Threats to validity} diff --git a/docs/thesis/chapters/6_results.tex b/docs/thesis/chapters/6_results.tex new file mode 100644 index 0000000..c5c6480 --- /dev/null +++ b/docs/thesis/chapters/6_results.tex @@ -0,0 +1,199 @@ +\chapter{Results \& discussion} \label{chapter:interviews} + +It should not be surprising that neither data scientists nor software engineers can be replaced by software libraries. However, a non-negligible subset of their processes can be partially or fully automated, especially when it comes to packaging and deploying AI/ML services. The objective was to design a library with an API that finds the balance between being simple enough to adopt without friction yet useful enough to be adopted. Simplicity is subjective and will be discussed separately in Section \ref{section:interviews}. For now, let us look at the utility of \textit{GreatAI}. + +\section{Features} \label{section:features} + +For answering \textbf{RQ3} --- \textit{To what extent can \textit{GreatAI} automatically implement AI deployment best practices?} --- a comparison is presented in the following, demonstrating a subset of best practices that can be implemented/scaffolded/configured with little user input; hence, through a simple and streamlined API. Tables \ref{table:best-practices-1} and \ref{table:best-practices-2} summarise the implemented best practices in the context of methods found by prior surveys of scientific and grey literature \cite{serban2020adoption,serban2021practices,john2020architecting}. + +In order to show an accurately nuanced representation, a \textit{Level of support} is determined for each best practice on a scale of \textit{Partially supported}, \textit{Supported}, and \textit{Fully automated}. For instance, \textit{Use static analysis to check code quality} from Table \ref{table:best-practices-1} is \textit{Supported} because the entire public interface of \textit{GreatAI} is correctly typed (including generics and asynchronous coroutines) and compatible with \href{https://mypy.readthedocs.io/en/stable/index.html#}{\texttt{mypy}} and \href{https://marketplace.visualstudio.com/items?itemName=ms-python.vscode-pylance}{\texttt{Pylance}}. This means that when \textit{GreatAI} is used in any Python project, various tools can be applied to statically check the soundness of the project's integration with \textit{GreatAI}. However, if the library's user does not use type hints in their code and it contains a more complex control flow, it can only be partially type-checked. In short, this best practice is supported, and a considerable part of it is already implemented by \textit{GreatAI}, but clients should still keep in mind that they might also need to make an effort to implement it fully. + +This is not the case for \textit{Log production predictions with the model's version and input data} because, by default, it is automatically implemented when calling \texttt{@GreatAI.create}. Users can still specify the exact expected behaviour, e.g., where to store traces, additional metrics to log, or disabling the logging of sensitive input. Nevertheless, the best practice is already implemented reasonably well without input from the library's user. + +\begin{table} +\centering +\begin{threeparttable} +\caption{A subset of AI lifecycle best practices and the level of support \textit{GreatAI} provides for them. The level of support is one of \textit{Fully automated} (\checkmark\checkmark), which means that no action is required from the user, \textit{Supported} (\checkmark) only automates the reasonably automatable aspects, while \textit{Partially supported} ($\sim$) provides some useful features, but the client is expected to build on top of these.} + +\label{table:best-practices-1} +{\renewcommand{\arraystretch}{1.2} % for the vertical padding +\begin{tabular}{P{7cm}@{\hskip 0.5cm}l@{\hskip 0cm}c} \hline + +\textbf{Best practice} & \textbf{Implementation} & \textbf{Support} \\\hline +Use sanity checks for all external data sources\textsuperscript{1} & \texttt{@parameter} & \checkmark \\\hline +Check that input data is complete, balanced, and well-distributed\textsuperscript{1} & \texttt{@parameter} & $\sim$ \\\hline +Write reusable scripts for data cleaning and merging (for NLP)\textsuperscript{1} & \texttt{utilities} & \checkmark\checkmark \\\hline +Make datasets available on shared infrastructure\textsuperscript{1} & \texttt{large\_file} & \checkmark\checkmark \\\hline +Test all feature extraction code (for NLP)\textsuperscript{1} & \texttt{utilities} & \checkmark\checkmark \\\hline +Employ interpretable models when possible\textsuperscript{1} & \texttt{views} & $\sim$ \\\hline +Continuously measure model quality and performance\textsuperscript{1, 2} & Feedback API & \checkmark \\\hline +Use versioning for data, model, configurations and training scripts\textsuperscript{1, 2} & \texttt{@use\_model}, versioning & \checkmark\checkmark \\\hline +Run automated regression tests\textsuperscript{1} & \texttt{*\_ground\_truth} & \checkmark \\\hline +Use continuous integration\textsuperscript{1} & Docker Image, WSGI application & \checkmark \\\hline +Use static analysis to check code quality\textsuperscript{1} & Fully typed API with generics & \checkmark \\\hline +Assure application security\textsuperscript{1} & Code is automatically audited & $\sim$ \\\hline +Automate model deployment, enable shadow deployment\textsuperscript{1, 2} & Docker Image \& scripts & \checkmark \\\hline +Enable automatic rollbacks for production models\textsuperscript{1, 2} & Docker Image \& scripts & $\sim$ \\\hline +Continuously monitor the behaviour of deployed models\textsuperscript{1, 2} & Dashboard, metrics endpoints & \checkmark\checkmark \\\hline +Log production predictions with the model's version and input data\textsuperscript{1} & \texttt{@GreatAI.create} & \checkmark\checkmark \\\hline + +\end{tabular}} +\begin{tablenotes} + \item[1] SE4ML best practices from Table 2 of \cite{serban2020adoption}, and Table 1 of \cite{serban2021practices}. + \item[2] Reported state-of-the-art and state-of-practice practices from Tables 2, 3, and 4 of \cite{john2020architecting}. +\end{tablenotes} +\end{threeparttable} +\end{table} + +\begin{table} +\centering +\begin{threeparttable} +\caption{A subset of AI lifecycle best practices and the level of support \textit{GreatAI} provides for them. The level of support is one of \textit{Fully automated} (\checkmark\checkmark), which means that no action is required from the user, \textit{Supported} ($\checkmark$) only automates the reasonably automatable aspects, while \textit{Partially supported} ($\sim$) provides some useful features but the client is expected to build on top of these.} + +\label{table:best-practices-2} +{\renewcommand{\arraystretch}{1.2} % for the vertical padding +\begin{tabular}{P{7cm}@{\hskip 0.5cm}l@{\hskip 0cm}c} \hline + +\textbf{Best practice} & \textbf{Implementation} & \textbf{Support} \\\hline +Execute validation techniques: error rates and cross-validation\textsuperscript{2} & \texttt{*\_ground\_truth} & \checkmark \\\hline +% Track models, dependencies, experiments, versions\textsuperscript{2} & \texttt{great\_ai.use\_model}, Dashboard & \checkmark\checkmark \\\hline +Store models in a single format for ease of use\textsuperscript{2} & \texttt{save\_model} & \checkmark\checkmark \\\hline +Rewrite from data analysis to industrial development language\textsuperscript{2} & Jupyter Notebook deployment & \checkmark \\\hline +Equip with web interface, package image, provide REST API\textsuperscript{2} & \texttt{@GreatAI.create} & \checkmark\checkmark \\\hline +Provide simple API for serving batch and real-time requests\textsuperscript{2} & \texttt{@GreatAI.create} & \checkmark\checkmark \\\hline +For reproducibility, use standard runtime and configuration files\textsuperscript{2} & \texttt{utilities.ConfigFile}, Dockerfile & \checkmark \\\hline +Integration with existing data infrastructure\textsuperscript{2} & GridFS, S3 support & \checkmark\checkmark \\\hline +Select ML solution fully integrated with databases\textsuperscript{2} & MongoDB, PostgreSQL support & \checkmark\checkmark \\\hline +Querying, visualising and understanding metrics and event logging\textsuperscript{2} & Dashboard, Traces API & \checkmark\checkmark \\\hline +% Monitor status and performance\textsuperscript{1, 2} & Dashboard, Status (metadata) API & \checkmark\checkmark \\\hline +Measure accuracy of deployed model to ensure data drifts are noticed\textsuperscript{2} & Feedback API & \checkmark \\\hline +Apply automation to trigger model retraining\textsuperscript{2} & Feedback API & $\sim$ \\\hline +% Employ Agile, DevOps-style workflows, allow automatic rollback\textsuperscript{2} & Docker Image, WSGI application & \checkmark \\\hline +% Deploy different versions of same application\textsuperscript{2} & Complex versioning support & $\sim$ \\\hline +Allow experimentation with the inference code\textsuperscript{3} & Development mode \& auto-reload & \checkmark\checkmark \\\hline +Keep the model and its documentation together\textsuperscript{3} & Dashboard and Swagger & \checkmark\checkmark \\\hline +Parallelise feature extraction\textsuperscript{3} & \texttt{parallel\_map} & \checkmark\checkmark \\\hline +Cache predictions\textsuperscript{3} & \texttt{@GreatAI.create} & \checkmark\checkmark \\\hline +Allow robustly composing inference functions\textsuperscript{3} & All decorators support async & \checkmark\checkmark \\\hline +Implement standard schemas for common prediction tasks\textsuperscript{3} & \texttt{views} & \checkmark \\\hline + +\end{tabular}} +\begin{tablenotes} + \item[2] Reported state-of-the-art and state-of-practice practices from Tables 2, 3, and 4 of \cite{john2020architecting}. + \item[3] Additional software engineering best practices applicable to AI/ML deployments encountered while designing and using \textit{GreatAI}. +\end{tablenotes} +\end{threeparttable} +\end{table} + +\FloatBarrier + +In Table \ref{table:best-practices-2}, we added six additional best practices, which are generally well-known software engineering considerations that are also applicable to AI/ML deployments. These had not explicitly made it into the aforementioned surveys; however, according to the insights gained from Sections \ref{section:simple-case} and \ref{section:complex-case}, implementing them has a positive effect on deployment quality. In future research, attention could be given to their level of industry-wide adoption and quantitative utility. + +Quantifying the number of implemented best practices would be misleading since their scope and importance cover a wide range; furthermore, there is some overlap between the different studies and even within the studies. However, it is still clear that a large number of best practices (17) can be given a \textit{Fully automated} implementation by \textit{GreatAI}'s design, and many others (16) can be augmented by the library. This proves the feasibility of designing simple APIs using the techniques of Chapter \ref{chapter:design} for decreasing the complexity of correctly deploying AI services while still implementing various best practices (\textbf{RQ2}). + +\section{Interviews} \label{section:interviews} + +One of the central takeaways of Section \ref{section:existing} is that, for example, Seldon Core is useful for implementing or helping to implement most of the best practices. Regardless, it also has an initial threshold that must be surmounted before implementing even a single one. According to the adoption rate surveys, this may discourage a large portion of practitioners from using it or other similar frameworks. The presented solution offers a different mix of features: the initial threshold is virtually non-existent; hence, best practices can be applied immediately. But at the same time, it only covers a more limited range of practices. + +Our hypothesis is that the latter approach aligns better with the expectations of professionals. To verify this, we conducted a series of interviews with the cooperation of ten industry practitioners with varying levels of Software Engineering (SE) and Data Science (DS) experience. In this section, the question of generalisability (\textbf{RQ4}) is investigated using the interview methodology described in Section \ref{section:interview-setup}. The participants were gathered through the recommendations of my friends and colleagues. All of the final interviewees have had at least some expertise in both DS (with a median of 2.5 years) and SE (with a median of 2 years). + +\subsection{Best practices survey} \label{subsection:best-practices-survey-results} + +The practitioners were first asked to fill out a questionnaire about their latest AI/ML project involving deployment. This point-in-time measurement (shown in Appendix \ref{appendix:practices}) served as a baseline for the deployment quality they are used to. Analysing the results show that the amount of software engineering experience has a moderately strong correlation ($r_{Pearson} = 0.67$ with $p = 0.0033$) with the overall number and extent of implemented deployment best practices. This is illustrated in Figure \ref{fig:adoption}. Interestingly but unsurprisingly, there is no similar statistically significant relationship regarding the amount of data science experience. + +The y-axis of Figure \ref{fig:adoption} is calculated by discarding the \textit{Not applicable} answers and projecting the 5-point Likert scale to a range from 0 to 1, which is subsequently averaged over all questions. The overall mean adoption rate/extent is just above 0.5, which equates to the \textit{Neither agree nor disagree} label. These data are in line with the findings of Serban et al. \cite{serban2020adoption}. + +Because the survey's 15 questions were compiled from the \textit{Fully automated} rows of Tables \ref{table:best-practices-1} and \ref{table:best-practices-2}, that means that when using \textit{GreatAI}, they are all implemented automatically. Consequently, the adoption rate/extent is doubled immediately just by wrapping the inference function with \texttt{@GreatAI.create}: this is the added value of \textit{GreatAI}\footnote{As explained earlier, measuring quality as a function of best practice count would be dubious. Thus, the achieved magnitude of the doubling is irrelevant; however, the direction of change is not.}. Moreover, this provides further evidence for answering \textbf{RQ3} showing the extent of automatically implemented practices over non-\textit{GreatAI} deployments. + +\begin{figure} + \centering + \includegraphics[width=0.6\linewidth]{figures/best-practices.png} + \captionsetup{width=.9\linewidth} + \caption{Best practices adoption rate as a function of Software Engineering (SE) and Data Science (DS) experience. SE experience is shown on the horizontal axis, while the point sizes denote the practitioners' experience in DS. The correlation between the axes is significant ($r_{Pearson} = 0.67$ with $p = 0.0033$).} + \label{fig:adoption} +\end{figure} + +\subsection{Technology acceptance} + +\begin{table}[H] +\centering +\captionsetup{width=.9\linewidth} +\caption{Technology acceptance model survey (presented in Appendix \ref{appendix:questions}, sample size = 10) results per variable. The input values range from 1 to 7.} +\label{table:tam} +{\renewcommand{\arraystretch}{1.1} % for the vertical padding +\begin{tabular}{|r|l|l|l|} \hline + & \textbf{Perceived ease of use} & \textbf{Perceived utility} & \textbf{Intention to use} \\\hline +\textbf{Median} & 5.8 & 6.4 & 6.3 \\\hline +\textbf{Mean} & 5.5 & 6.1 & 6.0 \\\hline +\textbf{Standard deviation} & 1.0 & 0.9 & 1.3 \\\hline +\textbf{Cronbach's alpha} & 0.77 & 0.88 & 0.95 \\\hline +\end{tabular}} +\end{table} + +The participants filled out a form (shown in Appendix \ref{appendix:questions}) after finishing their first deployment with \textit{GreatAI} to provide data for creating the technology acceptance model of the problem context. The survey contained ten questions from three categories, which could be rated on a 7-point Likert scale. The summary of the answers is presented in Table \ref{table:tam}. The high Cronbach's alpha values indicate strong internal consistency \cite{nunnally1994psychometric} for each TAM dimension; thus, averaging the responses per category is semantically meaningful. + +Following the methodology of \cite{cruz2019catalog}, the connections between the Perceived Utility (PU), Perceived Ease Of Use (PEOU), and Intention To Use (ITU) dimensions of TAM were analysed. Two statistically significant ($P \leq 0.05$) correlations were uncovered: between PU and ITU ($r_{Pearson} = 0.81$ with $p = 0.0048$); and PEOU and ITU ($r_{Pearson} = 0.80$ with $p = 0.0068$). Learning from the findings of prior case studies, it is reasonable to believe that both the \textit{perceived utility} and the \textit{perceived ease of use} play an equally important role in influencing professionals' \textit{intention to use} the deployment framework. + +The assessment of \textit{ease of use} lags behind the rest, but it is still quite high. It may be possible that PEOU would go up with further use. Nevertheless, the high \textit{perceived utility} implies that \textit{GreatAI} shows its value early on. This, combined with the correlations uncovered within the context's technology acceptance model, validates the hypothesis that focusing on good API design is just as necessary as providing practical features. + +\subsection{Task solving \& exit interviews} + +In order to give qualitative depth to the previously presented quantitative results, it is time to discuss the main segment of the interviews. The participants' backgrounds covered a vast and fascinating cross-section of industrial AI/ML. The financial sector was represented by a researcher working on market prediction models for the Hungarian State Treasury and two people building an upcoming digital bank's core services. Image processing contexts were illustrated by professionals predicting Sun activity at the European Space Agency and different ones creating pose-recognition at a startup for people with disabilities using 3D cameras. Moreover, investigating companies' AI use as part of due diligence processes and intrusion detection from network packet traces are just some of the other core activities the interviewees had been doing recently. + +Stemming from this diversity, these semi-structured interviews could be expected to provide valuable insights into the generalisability of \textit{GreatAI}. The methodology of Section \ref{section:interview-setup} was followed by applying reflective journaling and thematic analysis. After labelling each aspect of the feedback, and two iterations of merging redundant or related topics, we ended up with three overarching themes: \textit{Functionality}, \textit{API}, and \textit{Responsibility to adopt}. As we will soon see, these correspond to the \textit{perceived utility}, \textit{perceived ease of use}, and \textit{intention to use} components of TAM fairly well. + +\paragraph{Functionality} The library's feature-set was complimented during most interviews, with one participant noting that, although the overall number of features is relatively small, most of them are utilised in most cases. Similarly, the \texttt{utilities} submodule was appreciated for helping greatly in the interview task, but non-NLP researchers noted its likely inadequacy for their area. Still, they would like to see ``bundle'' or ``toolbox''-style modules for their fields because it would save them from a lot of copy-pasting. + +The effortless parallel feature extraction and large file handling support were highlighted multiple times for the reason that the particular interviewees had not encountered other libraries providing these features. Other concrete features, such as the searchable \textit{exceptions} column in the Dashboard's table and the \textit{feedback} mechanism, were also popular. One professional highlighted the latter for coercing users to consider a human-in-the-loop approach which was said to be often expected in modern systems. + +When reflecting on the framework from a bird's eye view, the generality and extensibility of the API were emphasised. As explained by a senior engineer, this is mainly because once you commit to using it, it is important not to find yourself at a dead end for a specific use case forcing you to look for a different library. However, two participants also noted that for complete generality, \texttt{MATLAB} support would be necessary. Regarding non-functional features, private hosting (especially in banking and government), open-source auditability, and good scalability (by means of an external database) were the top subjects of praise. + +\paragraph{API} Regarding the surface through which clients interact with the library, the feedback is also positive but more nuanced. Many participants liked that the functions' behaviour is easy to guess from their names. The decorator syntax caused minor confusion but consulting the documentation solved the issues in all three cases. The CLI app \texttt{great-ai} was appreciated for having a close to trivial signature; the participant noted that she strives to use as few CLI commands as feasible. Surprisingly, even the practitioners with more data science background appreciated the Docker support. Nonetheless, one expert had a feature request for a configuration GUI because his colleagues are used to handling MATLAB App Designer applications. + +The recurring theme of the discussions focused on the question of ``\textit{How simple is too simple?}''. The argument is that an API cannot be simpler than the domain in which it exists. More precisely, it can only be simpler at the cost of losing transparency. Let us take the example of saving models using \texttt{save\_model()}. If a project is set up correctly, it either has an initial \texttt{configure()} call to the storage provider backend, or it has an appropriately named credentials file in the project's root, for instance, \texttt{s3.ini} or \texttt{mongo.ini}. Once set up, it is trivial to use as long as we do not divert from the happy path. However, if an issue arises, such as an upgrade or migration of MongoDB, debugging the application is non-trivial for its lack of transparency. + +In other words, we could say that the average (cognitive) complexity is low while the worst-case is as high --- if not higher --- than without using \texttt{save\_model()}. This proved to be somewhat controversial. However, ultimately, optimising the happy path of the AI/ML development lifecycle was deemed worthwhile by the participants in most cases. With the argument that the majority of the time spent during a project is spent on this path anyway. However, this raises the question of who exactly are the target users of \textit{GreatAI} and who will fix arising issues? + +\paragraph{Responsibility to adopt} Let us first look at some insightful anecdotes that surfaced during the interviews. Especially in more research-oriented environments, production deployment pipelines can be of questionable robustness. This phenomenon was demonstrated by one account of a simple single-machine deployment pipeline: it is an interplay of \texttt{cron} jobs calling a series of shell and MATLAB scripts resembling a Rube Goldberg machine. But connecting a couple of Google Colab accounts to a GitHub repository and Weights\&Biases\footnote{\href{https://wandb.ai/site}{wandb.ai}} to implement parallel model training can also be found in the wild. + +Moreover, various research companies were mentioned that for multiple years used to or still have an R\&D department consisting solely of data scientists. In one extreme case, the staff was described as more than 30 data scientists and 0 other technical employees. In such a setup, it is unreasonable to expect even professionals to have the capabilities and focus to set up the required foundation for handling all best practices. All but one interviewee verified this assumption. They also referred to their previous projects, which usually required many researchers and experts from various fields, and too often, software engineers had not been prioritised to be included. + +Doing software engineering without software engineers is difficult. \textit{GreatAI} is not a viable replacement for any well-trained expert, though it is still better than nothing. During the interviews, we realised that the likely underlying reason for not employing AI engineers or software engineers as part of AI/ML projects is a lack of awareness. This was theorised by some and demonstrated by six participants who had, even though followed some, not explicitly sought out information on AI deployment best practices. Thus, raising awareness --- especially by presenting a value proposition, e.g. lower maintenance costs and better long-term quality --- might be crucial for improving AI deployments in general. Verifying this hypothesis could be a worthwhile direction for future research. + +During the larger discussions, \textit{GreatAI} was deemed appropriate for raising awareness since it showcases how even a simple library is able to implement a lot of best practices. Additionally, it was noted that it could also be considered for one-person projects where --- by definition --- it is admissible to have no SE expert on the ``team''. To further help such cases, integrating a one-click Heroku\footnote{\href{https://www.heroku.com/}{heroku.com}} app deployment was also recommended to simplify the entire last portion of the lifecycle. + +\subsection{Discussion of interviews} + +The overall takeaway from this is that most features were well-received, and the high mean value of \textit{perceived utility} is credible. The criticism of being NLP-centric is also justified: the initial scope of the proof-of-principle framework was limited to this domain. Nonetheless, learning the experts' opinion that they wish to have a similarly specific solution to their problem contexts is reassuring because it proves that the API is not only generalisable but is expected to be generalised. At the same time, it is crucial to admit that no one-size-fits-all solution can exist for such a diverse domain. Therefore, allowing customisability and easy extension of the system must remain central design questions. + +Regarding the API's level of abstraction, we have to agree with the experts that the problem of deployment cannot be ``magically'' solved by a trivial API. However, solving deployment problems can be streamlined, at least in simpler cases. At the same time, the complex ones can be left to the professionals with relevant knowledge. This parallels the AI-libraries that have inspired \textit{GreatAI}. For instance, Hugging Face \texttt{transformers} streamlines fine-tuning and applying SOTA models, but it does not provide any facilities to help you create the next SOTA architecture because that is a vastly more complex task that most users are not expected to tackle. + +In order to reach its goal of improving best practice adoption, \textit{GreatAI} can help raise awareness by presenting a verifiable value proposition, i.e. a couple of lines of code can already result in more maintainable, robust, high-quality deployments. This might prompt users or technical decision-makers to invest more in software engineering in AI/ML projects. Additionally, it can help the effectiveness of AI/software engineers by handling the grunt work of implementing some best practices, leaving them with more resources to focus on the complex and creative aspects of \textit{GREAT} deployments. + +In summary, the answer to \textit{How suitable is the design of GreatAI for helping to apply best practices in other contexts?} (\textbf{RQ4}) is --- unsurprisingly --- subjective. Combining the high value of \textit{intention to use} from Table \ref{table:tam}, the generally positive feedback regarding the library's added value, and the numerous feature requests for fitting it to specific needs, we conclude that there is some chance of suitability for generalisability. The existence of this potential is already exciting and presents an opportunity for experimenting with building on the design of \textit{GreatAI}. + +\subsection{Threats to validity} + +Two potential threats to the validity of the experiments and their results are identified. Firstly, the claimed utility of the framework derived in Subsection \ref{subsection:best-practices-survey-results} does not take into account the practical significance of the implemented features and, therefore, may be subject to bias. However, the \textit{perceived utility} evaluations indicate that the participating engineers and scientists identify practical value in the features of \textit{GreatAI}. Nevertheless, in the future, we intend to extend the range of implemented best practices, which would in turn, give higher confidence about the achievable quantitative improvement through using the library. + +Secondly, the survey answers and, in general, the interviewees may be subject to bias. The small sample size of practitioners can reasonably lead to some groups being over- or under-represented. The presence of selection bias is also plausible. These could be mitigated by gathering more data in future research. Coming from the exploratory nature of this analysis, many insights could be gained from the collected data. However, for confidently generalising the results, more data are needed. + +\section{Future work} + +The primary purpose of the library was to serve as a proxy through which its design decisions could be tested and evaluated in their practical context. For this reason, its design aimed to be a proof-of-principle for validating hypotheses and answering research questions. After successfully doing that, it has been turned into a practical software library suitable for production-use\footnote{Available at \href{https://pypi.org/project/great-ai/}{pypi.org/project/great-ai} and \href{https://hub.docker.com/repository/docker/schmelczera/great-ai}{hub.docker.com/repository/docker/schmelczera/great-ai}.}. + +The library's main limitations come from its bias toward NLP deployments. This is not unreasonable given the design's exploratory nature and the context of the case studies. Nevertheless, future work must focus on introducing and balancing support for many more fields' deployments. Although \textit{GreatAI} has already proved its utility, it has also shown that generalising and extending its functionality would be worthwhile. Therefore, many potential improvements are presented below. + +\subsection{More ML domains and modalities} + +The cases presented in Chapter \ref{chapter:case} revolved around NLP. This, of course, heavily influenced the design process. The two most notable effects can be found in the REST API's \texttt{/predict} endpoint and some \texttt{utilities} functions. The former is streamlined to accept JSON-compatible data (which caters to textual and tabular data), while the latter gives robust feature extraction support only for textual input. However, in practice, sound, image, and video are also widely taken as input. Furthermore, with the rise of multimodal models \cite{gao2020survey}, even different combinations of them may be simultaneously taken as input. + +Supporting the easy, direct upload of larger non-JSON files --- e.g. by saving them to S3 and showing a preview of them on the Dashboard's traces table --- and extending \texttt{utilities} to handle multimedia formats should be sufficient for counteracting the NLP bias. Hence, widely expanding the scope of applicability of \textit{GreatAI}. As we have seen in Section \ref{section:architecture}, the architecture is otherwise adequately general; therefore, incremental extensions can be applied. + +\subsection{More best practices} + +In order to greatly simplify its API, each \textit{GreatAI} Trace is a single document with a well-defined schema that clients can also extend by calling \texttt{log\_metric}. MongoDB provides a convenient (and popular) method for persisting such documents; however, if there is some existing database in the environment, storing Traces in that can be favourable. PostgreSQL \cite{momjian2001postgresql} is a popular choice, and it also features good JSON document support. Hence, introducing first-class integration for PostgreSQL could benefit some clients. + +Data-intensive services can fall into three broad categories: online systems, batch processing, and stream processing (near-teal-time systems) \cite{kleppmann2017designing}. As of yet, \textit{GreatAI} only provides streamlined support for the first two. Thus, developer experience could be improved by providing simple, direct integration with popular message queues/protocols, such as \href{https://kafka.apache.org/}{Apache Kafka} \cite{kreps2011kafka}, \href{https://aws.amazon.com/sqs/}{AWS SQS} \cite{garfinkel2007evaluation}, or \href{https://www.amqp.org/}{AMQP} \cite{vinoski2006advanced}. Moreover, some metrics of \textit{GreatAI}, such as the cache statistics, versions, and derived data from traces, can already be conveniently queried from its REST API. Nevertheless, adding support for the de facto standard metric gathering tool, Prometheus\footnote{\href{https://prometheus.io/}{prometheus.io}}, could save the library's users from one more integration step. + +The common theme among the opportunities mentioned above is that they could be implemented reasonably well without any user input, which aligns with the library's philosophy. Of course, the open-source nature of \textit{GreatAI} already allows anyone to provide support for a wide range of integrations. Additionally, the scope could be reasonably extended, i.e. more practices could be incorporated by including more criteria next to the \textit{GREAT} ones. diff --git a/docs/thesis/chapters/7_conclusion.tex b/docs/thesis/chapters/7_conclusion.tex index 30580ea..f096d4e 100644 --- a/docs/thesis/chapters/7_conclusion.tex +++ b/docs/thesis/chapters/7_conclusion.tex @@ -1,7 +1,15 @@ -\chapter{Conclusion} \label{chapter:conclusion} +\chapter{Conclusion} \label{chapter:conclusion} -% even if you already implemented these solutions by hand, you no longer have to -> you have more time -> you can spend that time implementing more advanced best practices +Concerned by the asymmetry between the industry's adoption of accessible AI/ML-libraries and existing solutions for their robust deployment, we investigated this phenomenon's causes and potential resolution. When looking at various recent case studies, a recurring theme was revealed: \textit{transitioning} from prototypes to production-ready AI/ML deployments is a source of adversity for small and large enterprises alike. Even though several frameworks and platforms exist for facilitating this step, surveys on the execution of best practices continue to expose the industry's shortcomings. This signals that existing libraries are underutilised, which may lead to poor deployments that underperform or develop issues that go unnoticed and might inflict societal harm. -\section{Future work} +We hypothesised that presenting a library which implements best practices and is also optimised for ease of adoption could help increase the overall quality of industrial AI/ML deployments. To test this, we designed and implemented a framework based on the principles of cognitive science and the prior art of software design. Subsequently, we tested and refined the design in an iterative process. First, we developed and deployed a model for classifying the domains of academic publications. Then, we fine-tuned and deployed a SciBERT model for generating publications' technology-transfer summaries. \textit{GreatAI} had been proven helpful; therefore, after feeding back the insights gained into its design, we turned it into an open-source library. Furthermore, \textit{GreatAI} has been successfully integrated into every production deployment of ScoutinScience since then and receives thousands of monthly downloads. -\section{Concluding remarks} +During the refinement of the framework, six previously unaddressed AI/ML deployment best practices were identified. Including these, the framework fully implements 17 best practices while it provides support for another 16. We validated the value provided by implementing or helping to implement these practices through interviews with ten industry professionals from various subfields. + +The interview participants completed two questionnaires, the results of one of which indicated that using \textit{GreatAI} in an example task increased the number of implemented best practices, on average, by 49\% compared with their latest project. We also calculated the technology acceptance model of the context; a significantly strong correlation was measured between the \textit{perceived ease of use}, the \textit{perceived utility} and the \textit{intention to use} dimensions. Overall, proving that ease of use is just as important as core functionality when adopting AI deployment frameworks. + +The open-ended exit interviews revealed that value can be derived from the library even in its current form and that the API's design has the opportunity to generalise to other fields of industrial AI/ML applications. However, they also highlighted that adoption issues do not necessarily come from a lack of willingness but a lack of awareness. Even if the returns achievable from good deployments are well worth the investment. Nevertheless, this value proposition needs to be conveyed and proved to data science professionals and technical decision-makers; and \textit{GreatAI} might just be the ideal candidate for doing that. + +\textit{GreatAI} may have the potential to bridge the gap between data science and software engineering. Stemming from the bidirectional nature of bridges, we can look at the framework from two perspectives: for professionals closer to the field of data science, it provides an automatic scaffolding of software facilities that are required for deploying, monitoring, and iterating on their models. For software engineers, it highlights the necessary steps needed for robust and improvable deployments. At the same time, it also saves them from the menial work of manually implementing these constructs. While most importantly, it proves that increasing the adoption rate of AI/ML deployment best practices is feasible by designing narrower and deeper APIs. + +Good deployments benefit all of us. Accordingly, continued research into the means of good deployments remains crucial. However, next to that --- as the presented results have shown --- better deployments can also be achieved by facilitating the \textit{transition} step of the AI lifecycle with a focus on adoptability. Having automated implementations, even if for just the straightforward best practices, leaves professionals additional time to tackle the more complex deployment challenges and fewer opportunities to miss critical steps. Overall, resulting in more general, robust, end-to-end, automated, and trustworthy AI deployments. diff --git a/docs/thesis/chapters/appendix.tex b/docs/thesis/chapters/appendix.tex new file mode 100644 index 0000000..5c724f8 --- /dev/null +++ b/docs/thesis/chapters/appendix.tex @@ -0,0 +1,52 @@ +\appendix + +\chapter{Best practices assessment} \label{appendix:practices} + +Similarly to the approach of \cite{serban2020adoption}, participants are asked about their team's level of adoption of AI/ML deployment best practices. The questions come from the entries of Tables \ref{table:best-practices-1} and \ref{table:best-practices-2} where \textit{GreatAI} was determined to provide a support level of \textit{Fully automated}. + +\textbf{How well did the previous AI deployment that you collaborated on implement the following best practices?} \textit{Each statement can be rated on a 5-point Likert scale or as ``Not applicable''.} + +\begin{enumerate} +\item Write reusable scripts for data cleaning and merging +\item Make datasets available on shared infrastructure +\item Use versioning for data, model, configurations and training scripts +\item Continuously monitor the behaviour of deployed models +\item Log production predictions with the model's version and input data +\item Store models in a single format for ease of use +\item Equip with a web interface, package image, provide REST API +\item Provide simple API for serving batch and real-time requests +\item Integration with existing data infrastructure +\item Querying, visualising and understanding metrics and event logging +\item Allow experimentation with the inference code +\item Keep the model and its documentation together +\item Parallelise feature extraction +\item Cache predictions +\item Allow robustly composing inference functions +\end{enumerate} + +\chapter{TAM questionnaire} \label{appendix:questions} + +Following the methodology for the parsimonious technology acceptance model of Wu et al. \cite{wu2011user}, each statement can be rated on a 7-point Likert scale. + +\paragraph{Perceived usefulness (PU)} +\begin{enumerate} + \item I believe the use of \textit{GreatAI} improves the quality of AI deployments. + \item I believe the use of \textit{GreatAI} would increase my productivity. + \item I believe the use of \textit{GreatAI} can lead to robust and trustworthy deployments. + \item Overall, I found \textit{GreatAI} useful when working with AI. +\end{enumerate} + +\paragraph{Perceived ease of use (PEOU)} +\begin{enumerate} + \item I found the \textit{GreatAI} easy to learn. + \item I found it is easy to employ \textit{GreatAI} in practice. + \item I found it is easy to integrate \textit{GreatAI} into an existing project. + \item Overall, I found \textit{GreatAI} easy to use. +\end{enumerate} + +\paragraph{Intention to use (ITU)} +\begin{enumerate} + \item Assuming \textit{GreatAI} is applicable to my task, I predict that I will use it on a regular basis in the future. + \item Overall, I intend to use the \textit{GreatAI} in my personal or professional projects. +\end{enumerate} + diff --git a/docs/thesis/figures/annotator.png b/docs/thesis/figures/annotator.png new file mode 100644 index 0000000..9bad80c Binary files /dev/null and b/docs/thesis/figures/annotator.png differ diff --git a/docs/thesis/figures/architecture.png b/docs/thesis/figures/architecture.png new file mode 100644 index 0000000..1797db0 Binary files /dev/null and b/docs/thesis/figures/architecture.png differ diff --git a/docs/thesis/figures/best-practices.png b/docs/thesis/figures/best-practices.png new file mode 100644 index 0000000..4f69066 Binary files /dev/null and b/docs/thesis/figures/best-practices.png differ diff --git a/docs/thesis/figures/confusion-matrix.png b/docs/thesis/figures/confusion-matrix.png deleted file mode 100644 index b152adf..0000000 Binary files a/docs/thesis/figures/confusion-matrix.png and /dev/null differ diff --git a/docs/thesis/figures/dashboard-domains.png b/docs/thesis/figures/dashboard-domains.png new file mode 100644 index 0000000..cb8b332 Binary files /dev/null and b/docs/thesis/figures/dashboard-domains.png differ diff --git a/docs/thesis/figures/dashboard-highlights.png b/docs/thesis/figures/dashboard-highlights.png new file mode 100644 index 0000000..7ed3ffe Binary files /dev/null and b/docs/thesis/figures/dashboard-highlights.png differ diff --git a/docs/thesis/figures/design-cycle.drawio.png b/docs/thesis/figures/design-cycle.drawio.png new file mode 100644 index 0000000..cd2973a Binary files /dev/null and b/docs/thesis/figures/design-cycle.drawio.png differ diff --git a/docs/thesis/figures/design-cycle2.drawio.png b/docs/thesis/figures/design-cycle2.drawio.png new file mode 100644 index 0000000..bd6cbf5 Binary files /dev/null and b/docs/thesis/figures/design-cycle2.drawio.png differ diff --git a/docs/thesis/figures/greatai-api.png b/docs/thesis/figures/greatai-api.png new file mode 100644 index 0000000..f0cc494 Binary files /dev/null and b/docs/thesis/figures/greatai-api.png differ diff --git a/docs/thesis/figures/greatai-header.png b/docs/thesis/figures/greatai-header.png new file mode 100644 index 0000000..0fb5e38 Binary files /dev/null and b/docs/thesis/figures/greatai-header.png differ diff --git a/docs/thesis/figures/greatai-parallel.png b/docs/thesis/figures/greatai-parallel.png new file mode 100644 index 0000000..1001b14 Binary files /dev/null and b/docs/thesis/figures/greatai-parallel.png differ diff --git a/docs/thesis/figures/greatai-table.png b/docs/thesis/figures/greatai-table.png new file mode 100644 index 0000000..a2cf3d9 Binary files /dev/null and b/docs/thesis/figures/greatai-table.png differ diff --git a/docs/thesis/figures/highlights-histograms.png b/docs/thesis/figures/highlights-histograms.png new file mode 100644 index 0000000..fea0044 Binary files /dev/null and b/docs/thesis/figures/highlights-histograms.png differ diff --git a/docs/thesis/figures/UL_PMS-kleur.eps b/docs/thesis/figures/leiden-logo.eps similarity index 100% rename from docs/thesis/figures/UL_PMS-kleur.eps rename to docs/thesis/figures/leiden-logo.eps diff --git a/docs/thesis/figures/mag-confusion.png b/docs/thesis/figures/mag-confusion.png new file mode 100644 index 0000000..a687e40 Binary files /dev/null and b/docs/thesis/figures/mag-confusion.png differ diff --git a/docs/thesis/figures/mag-distribution.png b/docs/thesis/figures/mag-distribution.png index a724ab1..ffc24f5 100644 Binary files a/docs/thesis/figures/mag-distribution.png and b/docs/thesis/figures/mag-distribution.png differ diff --git a/docs/thesis/figures/scibert-confusion.png b/docs/thesis/figures/scibert-confusion.png new file mode 100644 index 0000000..015f44f Binary files /dev/null and b/docs/thesis/figures/scibert-confusion.png differ diff --git a/docs/thesis/figures/scope.drawio.png b/docs/thesis/figures/scope.drawio.png index 9385a4e..6e786d0 100644 Binary files a/docs/thesis/figures/scope.drawio.png and b/docs/thesis/figures/scope.drawio.png differ diff --git a/docs/thesis/figures/ss-confusion.png b/docs/thesis/figures/ss-confusion.png index 4610198..08f1069 100644 Binary files a/docs/thesis/figures/ss-confusion.png and b/docs/thesis/figures/ss-confusion.png differ diff --git a/docs/thesis/figures/ss-distribution.png b/docs/thesis/figures/ss-distribution.png index 721684d..3c08e34 100644 Binary files a/docs/thesis/figures/ss-distribution.png and b/docs/thesis/figures/ss-distribution.png differ diff --git a/docs/thesis/figures/technologies.png b/docs/thesis/figures/technologies.png new file mode 100644 index 0000000..e72e92d Binary files /dev/null and b/docs/thesis/figures/technologies.png differ diff --git a/docs/thesis/frontpage/frontpage.pdf b/docs/thesis/frontpage/frontpage.pdf index 97c31fb..ab8b484 100644 Binary files a/docs/thesis/frontpage/frontpage.pdf and b/docs/thesis/frontpage/frontpage.pdf differ diff --git a/docs/thesis/frontpage/frontpage.tex b/docs/thesis/frontpage/frontpage.tex index cfa350a..65d95c8 100644 --- a/docs/thesis/frontpage/frontpage.tex +++ b/docs/thesis/frontpage/frontpage.tex @@ -25,7 +25,7 @@ \begin{tabular}[t]{p{3.5cm}@{\hspace{4mm}\vrule width 1.5pt\hspace{4mm}}l} %Logo Leiden University -\makebox(20,0)[t]{\includegraphics{../figures/UL_PMS-kleur.eps}} +\makebox(20,0)[t]{\includegraphics{../figures/leiden-logo.eps}} & \begin{minipage}[t]{12.25cm} \begin{Huge} @@ -38,7 +38,7 @@ \vspace*{4cm} \begin{Large} -\hfill GreatAI: An easy-to-use framework for robust end-to-end AI deployments +\hfill GreatAI: An easy-to-adopt framework for robust end-to-end AI deployments \vspace*{3mm} @@ -53,7 +53,7 @@ András Schmelczer s3052249 \\[1ex] \bree{Date}% -\today +30/09/2022 \\[1ex] \bree{Specialisation}% Advanced Computing and Systems diff --git a/docs/thesis/llncs.cls b/docs/thesis/llncs.cls deleted file mode 100644 index d49aaa8..0000000 --- a/docs/thesis/llncs.cls +++ /dev/null @@ -1,1107 +0,0 @@ -% LLNCS DOCUMENT CLASS -- version 2.20 (10-Mar-2018) -% Springer Verlag LaTeX2e support for Lecture Notes in Computer Science -% -%% -%% \CharacterTable -%% {Upper-case \A\B\C\D\E\F\G\H\I\J\K\L\M\N\O\P\Q\R\S\T\U\V\W\X\Y\Z -%% Lower-case \a\b\c\d\e\f\g\h\i\j\k\l\m\n\o\p\q\r\s\t\u\v\w\x\y\z -%% Digits \0\1\2\3\4\5\6\7\8\9 -%% Exclamation \! Double quote \" Hash (number) \# -%% Dollar \$ Percent \% Ampersand \& -%% Acute accent \' Left paren \( Right paren \) -%% Asterisk \* Plus \+ Comma \, -%% Minus \- Point \. Solidus \/ -%% Colon \: Semicolon \; Less than \< -%% Equals \= Greater than \> Question mark \? -%% Commercial at \@ Left bracket \[ Backslash \\ -%% Right bracket \] Circumflex \^ Underscore \_ -%% Grave accent \` Left brace \{ Vertical bar \| -%% Right brace \} Tilde \~} -%% -\NeedsTeXFormat{LaTeX2e}[1995/12/01] -\ProvidesClass{llncs}[2018/03/10 v2.20 -^^J LaTeX document class for Lecture Notes in Computer Science] -% Options -\let\if@envcntreset\iffalse -\DeclareOption{envcountreset}{\let\if@envcntreset\iftrue} -\DeclareOption{citeauthoryear}{\let\citeauthoryear=Y} -\DeclareOption{oribibl}{\let\oribibl=Y} -\let\if@custvec\iftrue -\DeclareOption{orivec}{\let\if@custvec\iffalse} -\let\if@envcntsame\iffalse -\DeclareOption{envcountsame}{\let\if@envcntsame\iftrue} -\let\if@envcntsect\iffalse -\DeclareOption{envcountsect}{\let\if@envcntsect\iftrue} -\let\if@runhead\iffalse -\DeclareOption{runningheads}{\let\if@runhead\iftrue} - -\let\if@openright\iftrue -\let\if@openbib\iffalse -\DeclareOption{openbib}{\let\if@openbib\iftrue} - -% languages -\let\switcht@@therlang\relax -\def\ds@deutsch{\def\switcht@@therlang{\switcht@deutsch}} -\def\ds@francais{\def\switcht@@therlang{\switcht@francais}} - -\DeclareOption*{\PassOptionsToClass{\CurrentOption}{article}} - -\ProcessOptions - -\LoadClass[twoside]{article} -\RequirePackage{multicol} % needed for the list of participants, index -\RequirePackage{aliascnt} - -\usepackage[a4paper, - bindingoffset=0, - left=3cm, - right=3cm, - top=3cm, - bottom=4cm, - footskip=1.5cm]{geometry} - -\renewcommand\@pnumwidth{2em} -\renewcommand\@tocrmarg{3.5em} -\setcounter{tocdepth}{1} - -\setlength{\parskip}{0.55em} -\linespread{1.2} - -\def\@dottedtocline#1#2#3#4#5{% - \ifnum #1>\c@tocdepth \else - \vskip \z@ \@plus.2\p@ - {\leftskip #2\relax \rightskip \@tocrmarg \advance\rightskip by 0pt plus 2cm - \parfillskip -\rightskip \pretolerance=10000 - \parindent #2\relax\@afterindenttrue - \interlinepenalty\@M - \leavevmode - \@tempdima #3\relax - \advance\leftskip \@tempdima \null\nobreak\hskip -\leftskip - {#4}\nobreak - \leaders\hbox{$\m@th - \mkern \@dotsep mu\hbox{.}\mkern \@dotsep - mu$}\hfill - \nobreak - \hb@xt@\@pnumwidth{\hfil\normalfont \normalcolor #5}% - \par}% - \fi} -% -\def\switcht@albion{% -\def\ackname{Acknowledgement.} -\def\andname{and} -\def\lastandname{\unskip, and} -\def\appendixname{Appendix} -\def\chaptername{Chapter} -\def\claimname{Claim} -\def\conjecturename{Conjecture} -\def\contentsname{Table of Contents} -\def\corollaryname{Corollary} -\def\definitionname{Definition} -\def\examplename{Example} -\def\exercisename{Exercise} -\def\figurename{Fig.} -\def\keywordname{{\bf Keywords:}} -\def\indexname{Index} -\def\lemmaname{Lemma} -\def\contriblistname{List of Contributors} -\def\listfigurename{List of Figures} -\def\listtablename{List of Tables} -\def\mailname{{\it Correspondence to\/}:} -\def\noteaddname{Note added in proof} -\def\notename{Note} -\def\partname{Part} -\def\problemname{Problem} -\def\proofname{Proof} -\def\propertyname{Property} -\def\propositionname{Proposition} -\def\questionname{Question} -\def\remarkname{Remark} -\def\seename{see} -\def\solutionname{Solution} -\def\subclassname{{\it Subject Classifications\/}:} -\def\tablename{Table} -\def\theoremname{Theorem}} -\switcht@albion -% Names of theorem like environments are already defined -% but must be translated if another language is chosen -% -% Ragged bottom for the actual page -% \def\thisbottomragged{\def\@textbottom{\vskip\z@ plus.0001fil -% \global\let\@textbottom\relax}} - -\renewcommand\small{% - \@setfontsize\small\@ixpt{11}% - \abovedisplayskip 8.5\p@ \@plus3\p@ \@minus4\p@ - \abovedisplayshortskip \z@ \@plus2\p@ - \belowdisplayshortskip 4\p@ \@plus2\p@ \@minus2\p@ - \def\@listi{\leftmargin\leftmargini - \parsep 0\p@ \@plus1\p@ \@minus\p@ - \topsep 8\p@ \@plus2\p@ \@minus4\p@ - \itemsep0\p@}% - \belowdisplayskip \abovedisplayskip -} - -\frenchspacing -\widowpenalty=10000 -\clubpenalty=10000 - -\setlength\footnotesep{12\p@} -\setlength\textfloatsep{8mm\@plus 2\p@ \@minus 4\p@} -\setlength\intextsep {8mm\@plus 2\p@ \@minus 2\p@} - -\setcounter{secnumdepth}{2} - -\newcounter {chapter} -\renewcommand\thechapter {\@arabic\c@chapter} - -\newif\if@mainmatter \@mainmattertrue -\newcommand\frontmatter{\cleardoublepage - \@mainmatterfalse\pagenumbering{Roman}} -\newcommand\mainmatter{\cleardoublepage - \@mainmattertrue\pagenumbering{arabic}} -\newcommand\backmatter{\if@openright\cleardoublepage\else\clearpage\fi - \@mainmatterfalse} - -\def\@part[#1]#2{% - \ifnum \c@secnumdepth >-2\relax - \refstepcounter{part}% - \addcontentsline{toc}{part}{\thepart\hspace{1em}#1}% - \else - \addcontentsline{toc}{part}{#1}% - \fi - \markboth{}{}% - {\centering - \interlinepenalty \@M - \normalfont - \ifnum \c@secnumdepth >-2\relax - \huge\bfseries \partname~\thepart - \par - \vskip 20\p@ - \fi - \Huge \bfseries #2\par}% - \@endpart} -\def\@spart#1{% - {\centering - \interlinepenalty \@M - \normalfont - \Huge \bfseries #1\par}% - \@endpart} -\def\@endpart{\vfil\newpage - \if@twoside - \null - \newpage - \fi - \if@tempswa - \twocolumn - \fi} - -\newcommand\chapter{\clearpage - \global\@topnum\z@ - \@afterindentfalse - \secdef\@chapter\@schapter} -\def\@chapter[#1]#2{\ifnum \c@secnumdepth >\m@ne - \if@mainmatter - \refstepcounter{chapter}% - \typeout{\@chapapp\space\thechapter.}% - \addcontentsline{toc}{chapter}% - {\protect\numberline{\thechapter}#1}% - \else - \addcontentsline{toc}{chapter}{#1}% - \fi - \else - \addcontentsline{toc}{chapter}{#1}% - \fi - \chaptermark{#1}% - \addtocontents{lof}{\protect\addvspace{10\p@}}% - \addtocontents{lot}{\protect\addvspace{10\p@}}% - \if@twocolumn - \@topnewpage[\@makechapterhead{#2}]% - \else - \@makechapterhead{#2}% - \@afterheading - \fi} -\def\@makechapterhead#1{% -% \vspace*{50\p@}% - {\centering - \ifnum \c@secnumdepth >\m@ne - \if@mainmatter - \large\bfseries \@chapapp{} \thechapter - \par\nobreak - \vskip 20\p@ - \fi - \fi - \interlinepenalty\@M - \Large \bfseries #1\par\nobreak - \vskip 40\p@ - }} -\def\@schapter#1{\if@twocolumn - \@topnewpage[\@makeschapterhead{#1}]% - \else - \@makeschapterhead{#1}% - \@afterheading - \fi} -\def\@makeschapterhead#1{% -% \vspace*{50\p@}% - {\centering - \normalfont - \interlinepenalty\@M - \Large \bfseries #1\par\nobreak - \vskip 40\p@ - }} - -\renewcommand\section{\@startsection{section}{1}{\z@}% - {-18\p@ \@plus -4\p@ \@minus -4\p@}% - {12\p@ \@plus 4\p@ \@minus 4\p@}% - {\normalfont\large\bfseries\boldmath - \rightskip=\z@ \@plus 8em\pretolerance=10000 }} -\renewcommand\subsection{\@startsection{subsection}{2}{\z@}% - {-18\p@ \@plus -4\p@ \@minus -4\p@}% - {8\p@ \@plus 4\p@ \@minus 4\p@}% - {\normalfont\normalsize\bfseries\boldmath - \rightskip=\z@ \@plus 8em\pretolerance=10000 }} -\renewcommand\subsubsection{\@startsection{subsubsection}{3}{\z@}% - {-18\p@ \@plus -4\p@ \@minus -4\p@}% - {-0.5em \@plus -0.22em \@minus -0.1em}% - {\normalfont\normalsize\bfseries\boldmath}} -\renewcommand\paragraph{\@startsection{paragraph}{4}{\z@}% - {-12\p@ \@plus -4\p@ \@minus -4\p@}% - {-0.5em \@plus -0.22em \@minus -0.1em}% - {\normalfont\normalsize\itshape}} -\renewcommand\subparagraph[1]{\typeout{LLNCS warning: You should not use - \string\subparagraph\space with this class}\vskip0.5cm -You should not use \verb|\subparagraph| with this class.\vskip0.5cm} - -\DeclareMathSymbol{\Gamma}{\mathalpha}{letters}{"00} -\DeclareMathSymbol{\Delta}{\mathalpha}{letters}{"01} -\DeclareMathSymbol{\Theta}{\mathalpha}{letters}{"02} -\DeclareMathSymbol{\Lambda}{\mathalpha}{letters}{"03} -\DeclareMathSymbol{\Xi}{\mathalpha}{letters}{"04} -\DeclareMathSymbol{\Pi}{\mathalpha}{letters}{"05} -\DeclareMathSymbol{\Sigma}{\mathalpha}{letters}{"06} -\DeclareMathSymbol{\Upsilon}{\mathalpha}{letters}{"07} -\DeclareMathSymbol{\Phi}{\mathalpha}{letters}{"08} -\DeclareMathSymbol{\Psi}{\mathalpha}{letters}{"09} -\DeclareMathSymbol{\Omega}{\mathalpha}{letters}{"0A} - -\let\footnotesize\small - -\if@custvec -\def\vec#1{\mathchoice{\mbox{\boldmath$\displaystyle#1$}} -{\mbox{\boldmath$\textstyle#1$}} -{\mbox{\boldmath$\scriptstyle#1$}} -{\mbox{\boldmath$\scriptscriptstyle#1$}}} -\fi - -\def\squareforqed{\hbox{\rlap{$\sqcap$}$\sqcup$}} -\def\qed{\ifmmode\squareforqed\else{\unskip\nobreak\hfil -\penalty50\hskip1em\null\nobreak\hfil\squareforqed -\parfillskip=0pt\finalhyphendemerits=0\endgraf}\fi} - -\def\getsto{\mathrel{\mathchoice {\vcenter{\offinterlineskip -\halign{\hfil -$\displaystyle##$\hfil\cr\gets\cr\to\cr}}} -{\vcenter{\offinterlineskip\halign{\hfil$\textstyle##$\hfil\cr\gets -\cr\to\cr}}} -{\vcenter{\offinterlineskip\halign{\hfil$\scriptstyle##$\hfil\cr\gets -\cr\to\cr}}} -{\vcenter{\offinterlineskip\halign{\hfil$\scriptscriptstyle##$\hfil\cr -\gets\cr\to\cr}}}}} -\def\lid{\mathrel{\mathchoice {\vcenter{\offinterlineskip\halign{\hfil -$\displaystyle##$\hfil\cr<\cr\noalign{\vskip1.2pt}=\cr}}} -{\vcenter{\offinterlineskip\halign{\hfil$\textstyle##$\hfil\cr<\cr -\noalign{\vskip1.2pt}=\cr}}} -{\vcenter{\offinterlineskip\halign{\hfil$\scriptstyle##$\hfil\cr<\cr -\noalign{\vskip1pt}=\cr}}} -{\vcenter{\offinterlineskip\halign{\hfil$\scriptscriptstyle##$\hfil\cr -<\cr -\noalign{\vskip0.9pt}=\cr}}}}} -\def\gid{\mathrel{\mathchoice {\vcenter{\offinterlineskip\halign{\hfil -$\displaystyle##$\hfil\cr>\cr\noalign{\vskip1.2pt}=\cr}}} -{\vcenter{\offinterlineskip\halign{\hfil$\textstyle##$\hfil\cr>\cr -\noalign{\vskip1.2pt}=\cr}}} -{\vcenter{\offinterlineskip\halign{\hfil$\scriptstyle##$\hfil\cr>\cr -\noalign{\vskip1pt}=\cr}}} -{\vcenter{\offinterlineskip\halign{\hfil$\scriptscriptstyle##$\hfil\cr ->\cr -\noalign{\vskip0.9pt}=\cr}}}}} -\def\grole{\mathrel{\mathchoice {\vcenter{\offinterlineskip -\halign{\hfil -$\displaystyle##$\hfil\cr>\cr\noalign{\vskip-1pt}<\cr}}} -{\vcenter{\offinterlineskip\halign{\hfil$\textstyle##$\hfil\cr ->\cr\noalign{\vskip-1pt}<\cr}}} -{\vcenter{\offinterlineskip\halign{\hfil$\scriptstyle##$\hfil\cr ->\cr\noalign{\vskip-0.8pt}<\cr}}} -{\vcenter{\offinterlineskip\halign{\hfil$\scriptscriptstyle##$\hfil\cr ->\cr\noalign{\vskip-0.3pt}<\cr}}}}} -\def\bbbr{{\rm I\!R}} %reelle Zahlen -\def\bbbm{{\rm I\!M}} -\def\bbbn{{\rm I\!N}} %natuerliche Zahlen -\def\bbbf{{\rm I\!F}} -\def\bbbh{{\rm I\!H}} -\def\bbbk{{\rm I\!K}} -\def\bbbp{{\rm I\!P}} -\def\bbbone{{\mathchoice {\rm 1\mskip-4mu l} {\rm 1\mskip-4mu l} -{\rm 1\mskip-4.5mu l} {\rm 1\mskip-5mu l}}} -\def\bbbc{{\mathchoice {\setbox0=\hbox{$\displaystyle\rm C$}\hbox{\hbox -to0pt{\kern0.4\wd0\vrule height0.9\ht0\hss}\box0}} -{\setbox0=\hbox{$\textstyle\rm C$}\hbox{\hbox -to0pt{\kern0.4\wd0\vrule height0.9\ht0\hss}\box0}} -{\setbox0=\hbox{$\scriptstyle\rm C$}\hbox{\hbox -to0pt{\kern0.4\wd0\vrule height0.9\ht0\hss}\box0}} -{\setbox0=\hbox{$\scriptscriptstyle\rm C$}\hbox{\hbox -to0pt{\kern0.4\wd0\vrule height0.9\ht0\hss}\box0}}}} -\def\bbbq{{\mathchoice {\setbox0=\hbox{$\displaystyle\rm -Q$}\hbox{\raise -0.15\ht0\hbox to0pt{\kern0.4\wd0\vrule height0.8\ht0\hss}\box0}} -{\setbox0=\hbox{$\textstyle\rm Q$}\hbox{\raise -0.15\ht0\hbox to0pt{\kern0.4\wd0\vrule height0.8\ht0\hss}\box0}} -{\setbox0=\hbox{$\scriptstyle\rm Q$}\hbox{\raise -0.15\ht0\hbox to0pt{\kern0.4\wd0\vrule height0.7\ht0\hss}\box0}} -{\setbox0=\hbox{$\scriptscriptstyle\rm Q$}\hbox{\raise -0.15\ht0\hbox to0pt{\kern0.4\wd0\vrule height0.7\ht0\hss}\box0}}}} -\def\bbbt{{\mathchoice {\setbox0=\hbox{$\displaystyle\rm -T$}\hbox{\hbox to0pt{\kern0.3\wd0\vrule height0.9\ht0\hss}\box0}} -{\setbox0=\hbox{$\textstyle\rm T$}\hbox{\hbox -to0pt{\kern0.3\wd0\vrule height0.9\ht0\hss}\box0}} -{\setbox0=\hbox{$\scriptstyle\rm T$}\hbox{\hbox -to0pt{\kern0.3\wd0\vrule height0.9\ht0\hss}\box0}} -{\setbox0=\hbox{$\scriptscriptstyle\rm T$}\hbox{\hbox -to0pt{\kern0.3\wd0\vrule height0.9\ht0\hss}\box0}}}} -\def\bbbs{{\mathchoice -{\setbox0=\hbox{$\displaystyle \rm S$}\hbox{\raise0.5\ht0\hbox -to0pt{\kern0.35\wd0\vrule height0.45\ht0\hss}\hbox -to0pt{\kern0.55\wd0\vrule height0.5\ht0\hss}\box0}} -{\setbox0=\hbox{$\textstyle \rm S$}\hbox{\raise0.5\ht0\hbox -to0pt{\kern0.35\wd0\vrule height0.45\ht0\hss}\hbox -to0pt{\kern0.55\wd0\vrule height0.5\ht0\hss}\box0}} -{\setbox0=\hbox{$\scriptstyle \rm S$}\hbox{\raise0.5\ht0\hbox -to0pt{\kern0.35\wd0\vrule height0.45\ht0\hss}\raise0.05\ht0\hbox -to0pt{\kern0.5\wd0\vrule height0.45\ht0\hss}\box0}} -{\setbox0=\hbox{$\scriptscriptstyle\rm S$}\hbox{\raise0.5\ht0\hbox -to0pt{\kern0.4\wd0\vrule height0.45\ht0\hss}\raise0.05\ht0\hbox -to0pt{\kern0.55\wd0\vrule height0.45\ht0\hss}\box0}}}} -\def\bbbz{{\mathchoice {\hbox{$\mathsf\textstyle Z\kern-0.4em Z$}} -{\hbox{$\mathsf\textstyle Z\kern-0.4em Z$}} -{\hbox{$\mathsf\scriptstyle Z\kern-0.3em Z$}} -{\hbox{$\mathsf\scriptscriptstyle Z\kern-0.2em Z$}}}} - -\let\ts\, - -\setlength\leftmargini {17\p@} -\setlength\leftmargin {\leftmargini} -\setlength\leftmarginii {\leftmargini} -\setlength\leftmarginiii {\leftmargini} -\setlength\leftmarginiv {\leftmargini} -\setlength \labelsep {.5em} -\setlength \labelwidth{\leftmargini} -\addtolength\labelwidth{-\labelsep} - -\def\@listI{\leftmargin\leftmargini - \parsep 0\p@ \@plus1\p@ \@minus\p@ - \topsep 8\p@ \@plus2\p@ \@minus4\p@ - \itemsep0\p@} -\let\@listi\@listI -\@listi -\def\@listii {\leftmargin\leftmarginii - \labelwidth\leftmarginii - \advance\labelwidth-\labelsep - \topsep 0\p@ \@plus2\p@ \@minus\p@} -\def\@listiii{\leftmargin\leftmarginiii - \labelwidth\leftmarginiii - \advance\labelwidth-\labelsep - \topsep 0\p@ \@plus\p@\@minus\p@ - \parsep \z@ - \partopsep \p@ \@plus\z@ \@minus\p@} - -\renewcommand\labelitemi{\normalfont\bfseries --} -\renewcommand\labelitemii{$\m@th\bullet$} - -\setlength\arraycolsep{1.4\p@} -\setlength\tabcolsep{1.4\p@} - -\def\tableofcontents{\chapter*{\contentsname\@mkboth{{\contentsname}}% - {{\contentsname}}} - \def\authcount##1{\setcounter{auco}{##1}\setcounter{@auth}{1}} - \def\lastand{\ifnum\value{auco}=2\relax - \unskip{} \andname\ - \else - \unskip \lastandname\ - \fi}% - \def\and{\stepcounter{@auth}\relax - \ifnum\value{@auth}=\value{auco}% - \lastand - \else - \unskip, - \fi}% - \@starttoc{toc}\if@restonecol\twocolumn\fi} - -\def\l@part#1#2{\addpenalty{\@secpenalty}% - \addvspace{2em plus\p@}% % space above part line - \begingroup - \parindent \z@ - \rightskip \z@ plus 5em - \hrule\vskip5pt - \large % same size as for a contribution heading - \bfseries\boldmath % set line in boldface - \leavevmode % TeX command to enter horizontal mode. - #1\par - \vskip5pt - \hrule - \vskip1pt - \nobreak % Never break after part entry - \endgroup} - -\def\@dotsep{2} - -\let\phantomsection=\relax - -\def\hyperhrefextend{\ifx\hyper@anchor\@undefined\else -{}\fi} - -\def\addnumcontentsmark#1#2#3{% -\addtocontents{#1}{\protect\contentsline{#2}{\protect\numberline - {\thechapter}#3}{\thepage}\hyperhrefextend}}% -\def\addcontentsmark#1#2#3{% -\addtocontents{#1}{\protect\contentsline{#2}{#3}{\thepage}\hyperhrefextend}}% -\def\addcontentsmarkwop#1#2#3{% -\addtocontents{#1}{\protect\contentsline{#2}{#3}{0}\hyperhrefextend}}% - -\def\@adcmk[#1]{\ifcase #1 \or -\def\@gtempa{\addnumcontentsmark}% - \or \def\@gtempa{\addcontentsmark}% - \or \def\@gtempa{\addcontentsmarkwop}% - \fi\@gtempa{toc}{chapter}% -} -\def\addtocmark{% -\phantomsection -\@ifnextchar[{\@adcmk}{\@adcmk[3]}% -} - -\def\l@chapter#1#2{\addpenalty{-\@highpenalty} - \vskip 1.0em plus 1pt \@tempdima 1.5em \begingroup - \parindent \z@ \rightskip \@tocrmarg - \advance\rightskip by 0pt plus 2cm - \parfillskip -\rightskip \pretolerance=10000 - \leavevmode \advance\leftskip\@tempdima \hskip -\leftskip - {\large\bfseries\boldmath#1}\ifx0#2\hfil\null - \else - \nobreak - \leaders\hbox{$\m@th \mkern \@dotsep mu.\mkern - \@dotsep mu$}\hfill - \nobreak\hbox to\@pnumwidth{\hss #2}% - \fi\par - \penalty\@highpenalty \endgroup} - -\def\l@title#1#2{\addpenalty{-\@highpenalty} - \addvspace{8pt plus 1pt} - \@tempdima \z@ - \begingroup - \parindent \z@ \rightskip \@tocrmarg - \advance\rightskip by 0pt plus 2cm - \parfillskip -\rightskip \pretolerance=10000 - \leavevmode \advance\leftskip\@tempdima \hskip -\leftskip - #1\nobreak - \leaders\hbox{$\m@th \mkern \@dotsep mu.\mkern - \@dotsep mu$}\hfill - \nobreak\hbox to\@pnumwidth{\hss #2}\par - \penalty\@highpenalty \endgroup} - -\def\l@author#1#2{\addpenalty{\@highpenalty} - \@tempdima=15\p@ %\z@ - \begingroup - \parindent \z@ \rightskip \@tocrmarg - \advance\rightskip by 0pt plus 2cm - \pretolerance=10000 - \leavevmode \advance\leftskip\@tempdima %\hskip -\leftskip - \textit{#1}\par - \penalty\@highpenalty \endgroup} - -\newdimen\tocchpnum -\newdimen\tocsecnum -\newdimen\tocsectotal -\newdimen\tocsubsecnum -\newdimen\tocsubsectotal -\newdimen\tocsubsubsecnum -\newdimen\tocsubsubsectotal -\newdimen\tocparanum -\newdimen\tocparatotal -\newdimen\tocsubparanum -\tocchpnum=\z@ % no chapter numbers -\tocsecnum=15\p@ % section 88. plus 2.222pt -\tocsubsecnum=23\p@ % subsection 88.8 plus 2.222pt -\tocsubsubsecnum=27\p@ % subsubsection 88.8.8 plus 1.444pt -\tocparanum=35\p@ % paragraph 88.8.8.8 plus 1.666pt -\tocsubparanum=43\p@ % subparagraph 88.8.8.8.8 plus 1.888pt -\def\calctocindent{% -\tocsectotal=\tocchpnum -\advance\tocsectotal by\tocsecnum -\tocsubsectotal=\tocsectotal -\advance\tocsubsectotal by\tocsubsecnum -\tocsubsubsectotal=\tocsubsectotal -\advance\tocsubsubsectotal by\tocsubsubsecnum -\tocparatotal=\tocsubsubsectotal -\advance\tocparatotal by\tocparanum} -\calctocindent - -\def\l@section{\@dottedtocline{1}{\tocchpnum}{\tocsecnum}} -\def\l@subsection{\@dottedtocline{2}{\tocsectotal}{\tocsubsecnum}} -\def\l@subsubsection{\@dottedtocline{3}{\tocsubsectotal}{\tocsubsubsecnum}} -\def\l@paragraph{\@dottedtocline{4}{\tocsubsubsectotal}{\tocparanum}} -\def\l@subparagraph{\@dottedtocline{5}{\tocparatotal}{\tocsubparanum}} - -\def\listoffigures{\@restonecolfalse\if@twocolumn\@restonecoltrue\onecolumn - \fi\section*{\listfigurename\@mkboth{{\listfigurename}}{{\listfigurename}}} - \@starttoc{lof}\if@restonecol\twocolumn\fi} -\def\l@figure{\@dottedtocline{1}{0em}{1.5em}} - -\def\listoftables{\@restonecolfalse\if@twocolumn\@restonecoltrue\onecolumn - \fi\section*{\listtablename\@mkboth{{\listtablename}}{{\listtablename}}} - \@starttoc{lot}\if@restonecol\twocolumn\fi} -\let\l@table\l@figure - -\renewcommand\listoffigures{% - \section*{\listfigurename - \@mkboth{\listfigurename}{\listfigurename}}% - \@starttoc{lof}% - } - -\renewcommand\listoftables{% - \section*{\listtablename - \@mkboth{\listtablename}{\listtablename}}% - \@starttoc{lot}% - } - -\ifx\oribibl\undefined -\ifx\citeauthoryear\undefined -\renewenvironment{thebibliography}[1] - {\section*{\refname} - \def\@biblabel##1{##1.} - \small - \list{\@biblabel{\@arabic\c@enumiv}}% - {\settowidth\labelwidth{\@biblabel{#1}}% - \leftmargin\labelwidth - \advance\leftmargin\labelsep - \if@openbib - \advance\leftmargin\bibindent - \itemindent -\bibindent - \listparindent \itemindent - \parsep \z@ - \fi - \usecounter{enumiv}% - \let\p@enumiv\@empty - \renewcommand\theenumiv{\@arabic\c@enumiv}}% - \if@openbib - \renewcommand\newblock{\par}% - \else - \renewcommand\newblock{\hskip .11em \@plus.33em \@minus.07em}% - \fi - \sloppy\clubpenalty4000\widowpenalty4000% - \sfcode`\.=\@m} - {\def\@noitemerr - {\@latex@warning{Empty `thebibliography' environment}}% - \endlist} -\def\@lbibitem[#1]#2{\item[{[#1]}\hfill]\if@filesw - {\let\protect\noexpand\immediate - \write\@auxout{\string\bibcite{#2}{#1}}}\fi\ignorespaces} -\newcount\@tempcntc -\def\@citex[#1]#2{\if@filesw\immediate\write\@auxout{\string\citation{#2}}\fi - \@tempcnta\z@\@tempcntb\m@ne\def\@citea{}\@cite{\@for\@citeb:=#2\do - {\@ifundefined - {b@\@citeb}{\@citeo\@tempcntb\m@ne\@citea\def\@citea{,}{\bfseries - ?}\@warning - {Citation `\@citeb' on page \thepage \space undefined}}% - {\setbox\z@\hbox{\global\@tempcntc0\csname b@\@citeb\endcsname\relax}% - \ifnum\@tempcntc=\z@ \@citeo\@tempcntb\m@ne - \@citea\def\@citea{,}\hbox{\csname b@\@citeb\endcsname}% - \else - \advance\@tempcntb\@ne - \ifnum\@tempcntb=\@tempcntc - \else\advance\@tempcntb\m@ne\@citeo - \@tempcnta\@tempcntc\@tempcntb\@tempcntc\fi\fi}}\@citeo}{#1}} -\def\@citeo{\ifnum\@tempcnta>\@tempcntb\else - \@citea\def\@citea{,\,\hskip\z@skip}% - \ifnum\@tempcnta=\@tempcntb\the\@tempcnta\else - {\advance\@tempcnta\@ne\ifnum\@tempcnta=\@tempcntb \else - \def\@citea{--}\fi - \advance\@tempcnta\m@ne\the\@tempcnta\@citea\the\@tempcntb}\fi\fi} -\else -\renewenvironment{thebibliography}[1] - {\section*{\refname} - \small - \list{}% - {\settowidth\labelwidth{}% - \leftmargin\parindent - \itemindent=-\parindent - \labelsep=\z@ - \if@openbib - \advance\leftmargin\bibindent - \itemindent -\bibindent - \listparindent \itemindent - \parsep \z@ - \fi - \usecounter{enumiv}% - \let\p@enumiv\@empty - \renewcommand\theenumiv{}}% - \if@openbib - \renewcommand\newblock{\par}% - \else - \renewcommand\newblock{\hskip .11em \@plus.33em \@minus.07em}% - \fi - \sloppy\clubpenalty4000\widowpenalty4000% - \sfcode`\.=\@m} - {\def\@noitemerr - {\@latex@warning{Empty `thebibliography' environment}}% - \endlist} - \def\@cite#1{#1}% - \def\@lbibitem[#1]#2{\item[]\if@filesw - {\def\protect##1{\string ##1\space}\immediate - \write\@auxout{\string\bibcite{#2}{#1}}}\fi\ignorespaces} - \fi -\else -\@cons\@openbib@code{\noexpand\small} -\fi - -\def\idxquad{\hskip 10\p@}% space that divides entry from number - -\def\@idxitem{\par\hangindent 10\p@} - -\def\subitem{\par\setbox0=\hbox{--\enspace}% second order - \noindent\hangindent\wd0\box0}% index entry - -\def\subsubitem{\par\setbox0=\hbox{--\,--\enspace}% third - \noindent\hangindent\wd0\box0}% order index entry - -\def\indexspace{\par \vskip 10\p@ plus5\p@ minus3\p@\relax} - -\renewenvironment{theindex} - {\@mkboth{\indexname}{\indexname}% - \parindent\z@ - \parskip\z@ \@plus .3\p@\relax - \let\item\par - \def\,{\relax\ifmmode\mskip\thinmuskip - \else\hskip0.2em\ignorespaces\fi}% - \normalfont\small - \begin{multicols}{2}[\@makeschapterhead{\indexname}]% - } - {\end{multicols}} - -\renewcommand\footnoterule{% - \kern-3\p@ - \hrule\@width 2truecm - \kern2.6\p@} - \newdimen\fnindent - \fnindent1em -\long\def\@makefntext#1{% - \parindent \fnindent% - \leftskip \fnindent% - \noindent - \llap{\hb@xt@1em{\hss\@makefnmark\ }}\ignorespaces#1} - -\long\def\@makecaption#1#2{% - \small - \vskip\abovecaptionskip - \sbox\@tempboxa{{\bfseries #1.} #2}% - \ifdim \wd\@tempboxa >\hsize - {\bfseries #1.} #2\par - \else - \global \@minipagefalse - \hb@xt@\hsize{\hfil\box\@tempboxa\hfil}% - \fi - \vskip\belowcaptionskip} - -\def\fps@figure{htbp} -\def\fnum@figure{\figurename\thinspace\thefigure} -\def \@floatboxreset {% - \reset@font - \small - \@setnobreak - \@setminipage -} -\def\fps@table{htbp} -\def\fnum@table{\tablename~\thetable} -\renewenvironment{table} - {\setlength\abovecaptionskip{0\p@}% - \setlength\belowcaptionskip{10\p@}% - \@float{table}} - {\end@float} -\renewenvironment{table*} - {\setlength\abovecaptionskip{0\p@}% - \setlength\belowcaptionskip{10\p@}% - \@dblfloat{table}} - {\end@dblfloat} - -\long\def\@caption#1[#2]#3{\par\addcontentsline{\csname - ext@#1\endcsname}{#1}{\protect\numberline{\csname - the#1\endcsname}{\ignorespaces #2}}\begingroup - \@parboxrestore - \@makecaption{\csname fnum@#1\endcsname}{\ignorespaces #3}\par - \endgroup} - -% LaTeX does not provide a command to enter the authors institute -% addresses. The \institute command is defined here. - -\newcounter{@inst} -\newcounter{@auth} -\newcounter{auco} -\newdimen\instindent -\newbox\authrun -\newtoks\authorrunning -\newtoks\tocauthor -\newbox\titrun -\newtoks\titlerunning -\newtoks\toctitle - -\def\clearheadinfo{\gdef\@author{No Author Given}% - \gdef\@title{No Title Given}% - \gdef\@subtitle{}% - \gdef\@institute{No Institute Given}% - \gdef\@thanks{}% - \global\titlerunning={}\global\authorrunning={}% - \global\toctitle={}\global\tocauthor={}} - -\def\institute#1{\gdef\@institute{#1}} - -\def\institutename{\par - \begingroup - \parskip=\z@ - \parindent=\z@ - \setcounter{@inst}{1}% - \def\and{\par\stepcounter{@inst}% - \noindent$^{\the@inst}$\enspace\ignorespaces}% - \setbox0=\vbox{\def\thanks##1{}\@institute}% - \ifnum\c@@inst=1\relax - \gdef\fnnstart{0}% - \else - \xdef\fnnstart{\c@@inst}% - \setcounter{@inst}{1}% - \noindent$^{\the@inst}$\enspace - \fi - \ignorespaces - \@institute\par - \endgroup} - -\def\@fnsymbol#1{\ensuremath{\ifcase#1\or\star\or{\star\star}\or - {\star\star\star}\or \dagger\or \ddagger\or - \mathchar "278\or \mathchar "27B\or \|\or **\or \dagger\dagger - \or \ddagger\ddagger \else\@ctrerr\fi}} - -\def\inst#1{\unskip$^{#1}$} -\def\orcidID#1{\unskip$^{[#1]}$} % added MR 2018-03-10 -\def\fnmsep{\unskip$^,$} -\def\email#1{{\tt#1}} - -\AtBeginDocument{\@ifundefined{url}{\def\url#1{#1}}{}% -\@ifpackageloaded{babel}{% -\@ifundefined{extrasenglish}{}{\addto\extrasenglish{\switcht@albion}}% -\@ifundefined{extrasfrenchb}{}{\addto\extrasfrenchb{\switcht@francais}}% -\@ifundefined{extrasgerman}{}{\addto\extrasgerman{\switcht@deutsch}}% -\@ifundefined{extrasngerman}{}{\addto\extrasngerman{\switcht@deutsch}}% -}{\switcht@@therlang}% -\providecommand{\keywords}[1]{\def\and{{\textperiodcentered} }% -\par\addvspace\baselineskip -\noindent\keywordname\enspace\ignorespaces#1}% -\@ifpackageloaded{hyperref}{% -\def\doi#1{\href{https://doi.org/#1}{https://doi.org/#1}}}{ -\def\doi#1{https://doi.org/#1}} -} -\def\homedir{\~{ }} - -\def\subtitle#1{\gdef\@subtitle{#1}} -\clearheadinfo -% -%%% to avoid hyperref warnings -\providecommand*{\toclevel@author}{999} -%%% to make title-entry parent of section-entries -\providecommand*{\toclevel@title}{0} -% -\renewcommand\maketitle{\newpage -\phantomsection - \refstepcounter{chapter}% - \stepcounter{section}% - \setcounter{section}{0}% - \setcounter{subsection}{0}% - \setcounter{figure}{0} - \setcounter{table}{0} - \setcounter{equation}{0} - \setcounter{footnote}{0}% - \begingroup - \parindent=\z@ - \renewcommand\thefootnote{\@fnsymbol\c@footnote}% - \if@twocolumn - \ifnum \col@number=\@ne - \@maketitle - \else - \twocolumn[\@maketitle]% - \fi - \else - \newpage - \global\@topnum\z@ % Prevents figures from going at top of page. - \@maketitle - \fi - \@thanks -% - \def\\{\unskip\ \ignorespaces}\def\inst##1{\unskip{}}% - \def\thanks##1{\unskip{}}\def\fnmsep{\unskip}% - \instindent=\hsize - \advance\instindent by-\headlineindent - \if!\the\toctitle!\addcontentsline{toc}{title}{\@title}\else - \addcontentsline{toc}{title}{\the\toctitle}\fi - \if@runhead - \if!\the\titlerunning!\else - \edef\@title{\the\titlerunning}% - \fi - \global\setbox\titrun=\hbox{\small\rm\unboldmath\ignorespaces\@title}% - \ifdim\wd\titrun>\instindent - \typeout{Title too long for running head. Please supply}% - \typeout{a shorter form with \string\titlerunning\space prior to - \string\maketitle}% - \global\setbox\titrun=\hbox{\small\rm - Title Suppressed Due to Excessive Length}% - \fi - \xdef\@title{\copy\titrun}% - \fi -% - \if!\the\tocauthor!\relax - {\def\and{\noexpand\protect\noexpand\and}% - \def\inst##1{}% added MR 2017-09-20 to remove inst numbers from the TOC - \def\orcidID##1{}% added MR 2017-09-20 to remove ORCID ids from the TOC - \protected@xdef\toc@uthor{\@author}}% - \else - \def\\{\noexpand\protect\noexpand\newline}% - \protected@xdef\scratch{\the\tocauthor}% - \protected@xdef\toc@uthor{\scratch}% - \fi - \addtocontents{toc}{\noexpand\protect\noexpand\authcount{\the\c@auco}}% - \addcontentsline{toc}{author}{\toc@uthor}% - \if@runhead - \if!\the\authorrunning! - \value{@inst}=\value{@auth}% - \setcounter{@auth}{1}% - \else - \edef\@author{\the\authorrunning}% - \fi - \global\setbox\authrun=\hbox{\def\inst##1{}% added MR 2017-09-20 to remove inst numbers from the runninghead - \def\orcidID##1{}% added MR 2017-09-20 to remove ORCID ids from the runninghead - \small\unboldmath\@author\unskip}% - \ifdim\wd\authrun>\instindent - \typeout{Names of authors too long for running head. Please supply}% - \typeout{a shorter form with \string\authorrunning\space prior to - \string\maketitle}% - \global\setbox\authrun=\hbox{\small\rm - Authors Suppressed Due to Excessive Length}% - \fi - \xdef\@author{\copy\authrun}% - \markboth{\@author}{\@title}% - \fi - \endgroup - \setcounter{footnote}{\fnnstart}% - \clearheadinfo} -% -\def\@maketitle{\newpage - \markboth{}{}% - \def\lastand{\ifnum\value{@inst}=2\relax - \unskip{} \andname\ - \else - \unskip \lastandname\ - \fi}% - \def\and{\stepcounter{@auth}\relax - \ifnum\value{@auth}=\value{@inst}% - \lastand - \else - \unskip, - \fi}% - \begin{center}% - \let\newline\\ - {\Large \bfseries\boldmath - \pretolerance=10000 - \@title \par}\vskip .8cm -\if!\@subtitle!\else {\large \bfseries\boldmath - \vskip -.65cm - \pretolerance=10000 - \@subtitle \par}\vskip .8cm\fi - \setbox0=\vbox{\setcounter{@auth}{1}\def\and{\stepcounter{@auth}}% - \def\thanks##1{}\@author}% - \global\value{@inst}=\value{@auth}% - \global\value{auco}=\value{@auth}% - \setcounter{@auth}{1}% -{\lineskip .5em -\noindent\ignorespaces -\@author\vskip.35cm} - {\small\institutename} - \end{center}% - } - -% definition of the "\spnewtheorem" command. -% -% Usage: -% -% \spnewtheorem{env_nam}{caption}[within]{cap_font}{body_font} -% or \spnewtheorem{env_nam}[numbered_like]{caption}{cap_font}{body_font} -% or \spnewtheorem*{env_nam}{caption}{cap_font}{body_font} -% -% New is "cap_font" and "body_font". It stands for -% fontdefinition of the caption and the text itself. -% -% "\spnewtheorem*" gives a theorem without number. -% -% A defined spnewthoerem environment is used as described -% by Lamport. -% -%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% - -\def\@thmcountersep{} -\def\@thmcounterend{.} - -\def\spnewtheorem{\@ifstar{\@sthm}{\@Sthm}} - -% definition of \spnewtheorem with number - -\def\@spnthm#1#2{% - \@ifnextchar[{\@spxnthm{#1}{#2}}{\@spynthm{#1}{#2}}} -\def\@Sthm#1{\@ifnextchar[{\@spothm{#1}}{\@spnthm{#1}}} - -\def\@spxnthm#1#2[#3]#4#5{\expandafter\@ifdefinable\csname #1\endcsname - {\@definecounter{#1}\@addtoreset{#1}{#3}% - \expandafter\xdef\csname the#1\endcsname{\expandafter\noexpand - \csname the#3\endcsname \noexpand\@thmcountersep \@thmcounter{#1}}% - \expandafter\xdef\csname #1name\endcsname{#2}% - \global\@namedef{#1}{\@spthm{#1}{\csname #1name\endcsname}{#4}{#5}}% - \global\@namedef{end#1}{\@endtheorem}}} - -\def\@spynthm#1#2#3#4{\expandafter\@ifdefinable\csname #1\endcsname - {\@definecounter{#1}% - \expandafter\xdef\csname the#1\endcsname{\@thmcounter{#1}}% - \expandafter\xdef\csname #1name\endcsname{#2}% - \global\@namedef{#1}{\@spthm{#1}{\csname #1name\endcsname}{#3}{#4}}% - \global\@namedef{end#1}{\@endtheorem}}} - -\def\@spothm#1[#2]#3#4#5{% - \@ifundefined{c@#2}{\@latexerr{No theorem environment `#2' defined}\@eha}% - {\expandafter\@ifdefinable\csname #1\endcsname - {\newaliascnt{#1}{#2}% - \expandafter\xdef\csname #1name\endcsname{#3}% - \global\@namedef{#1}{\@spthm{#1}{\csname #1name\endcsname}{#4}{#5}}% - \global\@namedef{end#1}{\@endtheorem}}}} - -\def\@spthm#1#2#3#4{\topsep 7\p@ \@plus2\p@ \@minus4\p@ -\refstepcounter{#1}% -\@ifnextchar[{\@spythm{#1}{#2}{#3}{#4}}{\@spxthm{#1}{#2}{#3}{#4}}} - -\def\@spxthm#1#2#3#4{\@spbegintheorem{#2}{\csname the#1\endcsname}{#3}{#4}% - \ignorespaces} - -\def\@spythm#1#2#3#4[#5]{\@spopargbegintheorem{#2}{\csname - the#1\endcsname}{#5}{#3}{#4}\ignorespaces} - -\def\@spbegintheorem#1#2#3#4{\trivlist - \item[\hskip\labelsep{#3#1\ #2\@thmcounterend}]#4} - -\def\@spopargbegintheorem#1#2#3#4#5{\trivlist - \item[\hskip\labelsep{#4#1\ #2}]{#4(#3)\@thmcounterend\ }#5} - -% definition of \spnewtheorem* without number - -\def\@sthm#1#2{\@Ynthm{#1}{#2}} - -\def\@Ynthm#1#2#3#4{\expandafter\@ifdefinable\csname #1\endcsname - {\global\@namedef{#1}{\@Thm{\csname #1name\endcsname}{#3}{#4}}% - \expandafter\xdef\csname #1name\endcsname{#2}% - \global\@namedef{end#1}{\@endtheorem}}} - -\def\@Thm#1#2#3{\topsep 7\p@ \@plus2\p@ \@minus4\p@ -\@ifnextchar[{\@Ythm{#1}{#2}{#3}}{\@Xthm{#1}{#2}{#3}}} - -\def\@Xthm#1#2#3{\@Begintheorem{#1}{#2}{#3}\ignorespaces} - -\def\@Ythm#1#2#3[#4]{\@Opargbegintheorem{#1} - {#4}{#2}{#3}\ignorespaces} - -\def\@Begintheorem#1#2#3{#3\trivlist - \item[\hskip\labelsep{#2#1\@thmcounterend}]} - -\def\@Opargbegintheorem#1#2#3#4{#4\trivlist - \item[\hskip\labelsep{#3#1}]{#3(#2)\@thmcounterend\ }} - -\if@envcntsect - \def\@thmcountersep{.} - \spnewtheorem{theorem}{Theorem}[section]{\bfseries}{\itshape} -\else - \spnewtheorem{theorem}{Theorem}{\bfseries}{\itshape} - \if@envcntreset - \@addtoreset{theorem}{section} - \else - \@addtoreset{theorem}{chapter} - \fi -\fi - -%definition of divers theorem environments -\spnewtheorem*{claim}{Claim}{\itshape}{\rmfamily} -\spnewtheorem*{proof}{Proof}{\itshape}{\rmfamily} -\if@envcntsame % alle Umgebungen wie Theorem. - \def\spn@wtheorem#1#2#3#4{\@spothm{#1}[theorem]{#2}{#3}{#4}} -\else % alle Umgebungen mit eigenem Zaehler - \if@envcntsect % mit section numeriert - \def\spn@wtheorem#1#2#3#4{\@spxnthm{#1}{#2}[section]{#3}{#4}} - \else % nicht mit section numeriert - \if@envcntreset - \def\spn@wtheorem#1#2#3#4{\@spynthm{#1}{#2}{#3}{#4} - \@addtoreset{#1}{section}} - \else - \def\spn@wtheorem#1#2#3#4{\@spynthm{#1}{#2}{#3}{#4} - \@addtoreset{#1}{chapter}}% - \fi - \fi -\fi -\spn@wtheorem{case}{Case}{\itshape}{\rmfamily} -\spn@wtheorem{conjecture}{Conjecture}{\itshape}{\rmfamily} -\spn@wtheorem{corollary}{Corollary}{\bfseries}{\itshape} -\spn@wtheorem{definition}{Definition}{\bfseries}{\itshape} -\spn@wtheorem{example}{Example}{\itshape}{\rmfamily} -\spn@wtheorem{exercise}{Exercise}{\itshape}{\rmfamily} -\spn@wtheorem{lemma}{Lemma}{\bfseries}{\itshape} -\spn@wtheorem{note}{Note}{\itshape}{\rmfamily} -\spn@wtheorem{problem}{Problem}{\itshape}{\rmfamily} -\spn@wtheorem{property}{Property}{\itshape}{\rmfamily} -\spn@wtheorem{proposition}{Proposition}{\bfseries}{\itshape} -\spn@wtheorem{question}{Question}{\itshape}{\rmfamily} -\spn@wtheorem{solution}{Solution}{\itshape}{\rmfamily} -\spn@wtheorem{remark}{Remark}{\itshape}{\rmfamily} - -\def\@takefromreset#1#2{% - \def\@tempa{#1}% - \let\@tempd\@elt - \def\@elt##1{% - \def\@tempb{##1}% - \ifx\@tempa\@tempb\else - \@addtoreset{##1}{#2}% - \fi}% - \expandafter\expandafter\let\expandafter\@tempc\csname cl@#2\endcsname - \expandafter\def\csname cl@#2\endcsname{}% - \@tempc - \let\@elt\@tempd} - -\def\theopargself{\def\@spopargbegintheorem##1##2##3##4##5{\trivlist - \item[\hskip\labelsep{##4##1\ ##2}]{##4##3\@thmcounterend\ }##5} - \def\@Opargbegintheorem##1##2##3##4{##4\trivlist - \item[\hskip\labelsep{##3##1}]{##3##2\@thmcounterend\ }} - } - -\renewenvironment{abstract}{% - \list{}{\advance\topsep by0.35cm\relax\small - \leftmargin=1cm - \labelwidth=\z@ - \listparindent=\z@ - \itemindent\listparindent - \rightmargin\leftmargin} - \item[\labelsep\bfseries] - \section*{Abstract} -} - {\endlist} - -\newdimen\headlineindent % dimension for space between -\headlineindent=1.166cm % number and text of headings. - -\setlength\arraycolsep{1.4\p@} -\setlength\tabcolsep{1.4\p@} - -\endinput diff --git a/docs/thesis/main.pdf b/docs/thesis/main.pdf new file mode 100644 index 0000000..32bdc11 Binary files /dev/null and b/docs/thesis/main.pdf differ diff --git a/docs/thesis/main.tex b/docs/thesis/main.tex index 71c6a3d..d6f77b7 100644 --- a/docs/thesis/main.tex +++ b/docs/thesis/main.tex @@ -1,5 +1,6 @@ -\documentclass[runningheads]{llncs} +\documentclass{report} +\usepackage{placeins} \usepackage{graphicx} \usepackage{pdfpages} \usepackage{hyperref} @@ -8,11 +9,25 @@ \usepackage{enumitem} \usepackage{threeparttable} \usepackage{multicol} +\usepackage[super]{nth} \usepackage[compact]{titlesec} \usepackage{framed} \usepackage{quoting} +\usepackage{caption} \usepackage{xcolor} +\usepackage{minted} +\usepackage{tocloft} +\usepackage[a4paper, + bindingoffset=0cm, + left=2.5cm, + right=2.5cm, + top=2.5cm, + bottom=2.65cm]{geometry} +\usepackage{array} +\usepackage{ragged2e} +% Left-aligned fixed-width table column +\newcolumntype{P}[1]{>{\RaggedRight\hspace{0pt}}p{#1}} % Header & footer \pagestyle{fancy} @@ -20,10 +35,15 @@ \renewcommand{\headrulewidth}{0pt} \fancyfoot[C]{\thepage} +% set chapter title margins +\titleformat{\chapter}[display] +{\normalfont\huge\bfseries}{\chaptertitlename\ \thechapter}{20pt}{\Huge} +\titlespacing*{\chapter}{0pt}{20pt}{20pt} + +% 2-column bibliography \makeatletter \renewenvironment{thebibliography}[1] - {\begin{multicols}{2}[\section*{\refname}]% - \@mkboth{\MakeUppercase\refname}{\MakeUppercase\refname}% + {\begin{multicols}{2}[\chapter*{References}]% \small \list{\@biblabel{\@arabic\c@enumiv}}% {\settowidth\labelwidth{\@biblabel{#1}}% @@ -63,32 +83,100 @@ % Block quote \definecolor{bg}{RGB}{186, 233, 255} \colorlet{shadecolor}{bg} -\usepackage{lipsum} \newenvironment{displayquote} - {\begin{shaded*} +{\begin{samepage}\begin{shaded*} \quoting[leftmargin=0pt, vskip=0pt] - } - {\endquoting - \end{shaded*} +} +{\endquoting + \end{shaded*}\end{samepage} } +% Section numbering +\renewcommand\thechapter{\arabic{chapter}} +\renewcommand\thesection{\thechapter.\arabic{section}} +\renewcommand\thesubsection{\thesection.\arabic{subsection}} + +\makeatletter +\renewcommand\small{% + \@setfontsize\small\@ixpt{11}% + \abovedisplayskip 8.5\p@ \@plus3\p@ \@minus4\p@ + \abovedisplayshortskip \z@ \@plus2\p@ + \belowdisplayshortskip 4\p@ \@plus2\p@ \@minus2\p@ + \def\@listi{\leftmargin\leftmargini + \parsep 0\p@ \@plus1\p@ \@minus\p@ + \topsep 8\p@ \@plus2\p@ \@minus4\p@ + \itemsep0\p@}% + \belowdisplayskip \abovedisplayskip +} + +\frenchspacing +\widowpenalty=10000 +\clubpenalty=10000 + +\setlength\footnotesep{12\p@} +\setlength\textfloatsep{8mm\@plus 2\p@ \@minus 4\p@} +\setlength\intextsep {8mm\@plus 2\p@ \@minus 2\p@} + +\setcounter{secnumdepth}{2} + +\renewcommand\@pnumwidth{2em} +\setcounter{tocdepth}{1} +\setlength{\parskip}{0.55em} +\linespread{1.2} + +\def\@dottedtocline#1#2#3#4#5{% + \ifnum #1>\c@tocdepth \else + \vskip \z@ \@plus.2\p@ + {\leftskip #2\relax \rightskip \@tocrmarg \advance\rightskip by 0pt plus 2cm + \parfillskip -\rightskip \pretolerance=10000 + \parindent #2\relax\@afterindenttrue + \interlinepenalty\@M + \leavevmode + \@tempdima #3\relax + \advance\leftskip \@tempdima \null\nobreak\hskip -\leftskip + {#4}\nobreak + \leaders\hbox{$\m@th + \mkern \@dotsep mu\hbox{.}\mkern \@dotsep + mu$}\hfill + \nobreak + \hb@xt@\@pnumwidth{\hfil\normalfont \normalcolor #5}% + \par}% + \fi} +\makeatother \begin{document} \includepdf[pages=-]{frontpage/frontpage.pdf} \include{chapters/0_abstract} + +\setcounter{page}{3} \tableofcontents +\chapter*{Acknowledgements} +I wish to extend my special thanks to my supervisors, Prof. dr. ir. Joost Visser and Dr. Suzan Verberne, for their invaluable assistance and guidance. I would also like to thank ScoutinScience B.V. for our fruitful collaboration and for allowing me to use their software for experimentation, validation, and demonstration purposes. Last but not least, I would like to individually thank +Ádám Kovács, +Balázs Csomor, +Bálint Bakcsa, +Bendegúz Bendicsek, +Joana Trashlieva, +Leonardo Pohl, +Lion Cassens, +László Radnai, +Máté Wolf, +and Olivér Angyal +for participating and providing insightful feedback in our interviews. + \input{chapters/1_introduction} \input{chapters/2_background} \input{chapters/3_methods} \input{chapters/4_design} -\input{chapters/5_case/main} -\input{chapters/6_interviews} +\input{chapters/5_cases/main} +\input{chapters/6_results} \input{chapters/7_conclusion} -\clearpage \bibliographystyle{splncs04} \bibliography{ref} +\input{chapters/appendix} + \end{document} diff --git a/docs/thesis/ref.bib b/docs/thesis/ref.bib index b307cf3..9a419d3 100644 --- a/docs/thesis/ref.bib +++ b/docs/thesis/ref.bib @@ -527,3 +527,393 @@ year={2009}, publisher={Pearson Education} } + +@inproceedings{Chen_2016, + doi = {10.1145/2939672.2939785}, + year = 2016, + month = {aug}, + publisher = {{ACM}}, + author = {Tianqi Chen and Carlos Guestrin}, + title = {{XGBoost}}, + booktitle = {Proceedings of the 22nd {ACM} {SIGKDD} International Conference on Knowledge Discovery and Data Mining} +} + +@article{food2019proposed, + title={Proposed regulatory framework for modifications to artificial intelligence/machine learning (AI/ML)-based software as a medical device (SaMD)}, + author={Food and Drug Administration and others}, + journal={APO}, + year={2019}, + publisher={Department of Health and Human Services (United States)} +} + +@inproceedings{moritz2018ray, + title={Ray: A distributed framework for emerging $\{$AI$\}$ applications}, + author={Moritz, Philipp and Nishihara, Robert and Wang, Stephanie and Tumanov, Alexey and Liaw, Richard and Liang, Eric and Elibol, Melih and Yang, Zongheng and Paul, William and Jordan, Michael I and others}, + booktitle={13th USENIX Symposium on Operating Systems Design and Implementation (OSDI 18)}, + pages={561--577}, + year={2018} +} + +@article{rivest2021level, + title={level classification of scientific publications: A comparison of deep learning, direct citation and bibliographic coupling}, + author={Rivest, Maxime and Vignola-Gagn{\'e}, Etienne and Archambault, {\'E}ric}, + journal={PloS one}, + volume={16}, + number={5}, + pages={e0251493}, + year={2021}, + publisher={Public Library of Science San Francisco, CA USA} +} + +@article{maron1961automatic, + title={Automatic indexing: an experimental inquiry}, + author={Maron, Melvin Earl}, + journal={Journal of the ACM (JACM)}, + volume={8}, + number={3}, + pages={404--417}, + year={1961}, + publisher={ACM New York, NY, USA} +} + +@article{vaswani2017attention, + title={Attention is all you need}, + author={Vaswani, Ashish and Shazeer, Noam and Parmar, Niki and Uszkoreit, Jakob and Jones, Llion and Gomez, Aidan N and Kaiser, {\L}ukasz and Polosukhin, Illia}, + journal={Advances in neural information processing systems}, + volume={30}, + year={2017} +} + +@misc{Procida_Diataxis_documentation_framework, + author = {Procida, Daniele}, + title = {{Diátaxis documentation framework}}, + url = {https://diataxis.fr/} +} + +@article{davis1989perceived, + title={Perceived usefulness, perceived ease of use, and user acceptance of information technology}, + author={Davis, Fred D}, + journal={MIS quarterly}, + pages={319--340}, + year={1989}, + publisher={JSTOR} +} + +@article{marangunic2015technology, + title={Technology acceptance model: a literature review from 1986 to 2013}, + author={Maranguni{\'c}, Nikola and Grani{\'c}, Andrina}, + journal={Universal access in the information society}, + volume={14}, + number={1}, + pages={81--95}, + year={2015}, + publisher={Springer} +} + +@article{wu2011user, + title={User acceptance of wireless technology in organizations: A comparison of alternative models}, + author={Wu, Chin-Shan and Cheng, Fei-Fei and Yen, David C and Huang, Yu-Wen}, + journal={Computer Standards \& Interfaces}, + volume={33}, + number={1}, + pages={50--58}, + year={2011}, + publisher={Elsevier} +} + +@article{riemenschneider2002explaining, + title={Explaining software developer acceptance of methodologies: a comparison of five theoretical models}, + author={Riemenschneider, Cynthia K. and Hardgrave, Bill C. and Davis, Fred D.}, + journal={IEEE transactions on Software Engineering}, + volume={28}, + number={12}, + pages={1135--1145}, + year={2002}, + publisher={IEEE} +} + +@article{bland1997statistics, + title={Statistics notes: Cronbach's alpha}, + author={Bland, J Martin and Altman, Douglas G}, + journal={Bmj}, + volume={314}, + number={7080}, + pages={572}, + year={1997}, + publisher={British Medical Journal Publishing Group} +} + +@article{halcomb2006verbatim, + title={Is verbatim transcription of interview data always necessary?}, + author={Halcomb, Elizabeth J and Davidson, Patricia M}, + journal={Applied nursing research}, + volume={19}, + number={1}, + pages={38--42}, + year={2006}, + publisher={Elsevier} +} + +@article{fereday2006demonstrating, + title={Demonstrating rigor using thematic analysis: A hybrid approach of inductive and deductive coding and theme development}, + author={Fereday, Jennifer and Muir-Cochrane, Eimear}, + journal={International journal of qualitative methods}, + volume={5}, + number={1}, + pages={80--92}, + year={2006}, + publisher={SAGE Publications Sage CA: Los Angeles, CA} +} + +@article{leite2019survey, + title={A survey of DevOps concepts and challenges}, + author={Leite, Leonardo and Rocha, Carla and Kon, Fabio and Milojicic, Dejan and Meirelles, Paulo}, + journal={ACM Computing Surveys (CSUR)}, + volume={52}, + number={6}, + pages={1--35}, + year={2019}, + publisher={ACM New York, NY, USA} +} + +@article{mckerns2012building, + title={Building a framework for predictive science}, + author={McKerns, Michael M and Strand, Leif and Sullivan, Tim and Fang, Alta and Aivazis, Michael AG}, + journal={arXiv preprint arXiv:1202.1056}, + year={2012} +} + +@article{tilkov2010node, + title={Node. js: Using JavaScript to build high-performance network programs}, + author={Tilkov, Stefan and Vinoski, Steve}, + journal={IEEE Internet Computing}, + volume={14}, + number={6}, + pages={80--83}, + year={2010}, + publisher={IEEE} +} + +@inproceedings{john2020architecting, + title={Architecting AI Deployment: A Systematic Review of State-of-the-art and State-of-practice Literature}, + author={John, Meenu Mary and Holmstr{\"o}m Olsson, Helena and Bosch, Jan}, + booktitle={International Conference on Software Business}, + pages={14--29}, + year={2020}, + organization={Springer} +} + +@article{maynez2020faithfulness, + title={On faithfulness and factuality in abstractive summarization}, + author={Maynez, Joshua and Narayan, Shashi and Bohnet, Bernd and McDonald, Ryan}, + journal={arXiv preprint arXiv:2005.00661}, + year={2020} +} + +@article{mchugh2012interrater, + title={Interrater reliability: the kappa statistic}, + author={McHugh, Mary L}, + journal={Biochemia medica}, + volume={22}, + number={3}, + pages={276--282}, + year={2012}, + publisher={Medicinska naklada} +} + +@article{verberne2018creating, + title={Creating a reference data set for the summarization of discussion forum threads}, + author={Verberne, Suzan and Krahmer, Emiel and Hendrickx, Iris and Wubben, Sander and van Den Bosch, Antal}, + journal={Language Resources and Evaluation}, + volume={52}, + number={2}, + pages={461--483}, + year={2018}, + publisher={Springer} +} + +@article{loshchilov2017decoupled, + title={Decoupled weight decay regularization}, + author={Loshchilov, Ilya and Hutter, Frank}, + journal={arXiv preprint arXiv:1711.05101}, + year={2017} +} + +@article{spearman1961proof, + title={The proof and measurement of association between two things.}, + author={Spearman, Charles}, + journal={The American Journal of Psychology}, + year={1961}, + publisher={Appleton-Century-Crofts} +} + +@article{bruns2022deep, + title={Deep learning-based whole-heart segmentation in 4D contrast-enhanced cardiac CT}, + author={Bruns, Steffen and Wolterink, Jelmer M and van den Boogert, Thomas PW and Runge, Jurgen H and Bouma, Berto J and Henriques, Jos{\'e} P and Baan, Jan and Viergever, Max A and Planken, R Nils and I{\v{s}}gum, Ivana}, + journal={Computers in biology and medicine}, + volume={142}, + pages={105191}, + year={2022}, + publisher={Elsevier} +} + +@misc{hutson2018artificial, + title={Artificial intelligence faces reproducibility crisis}, + author={Hutson, Matthew}, + year={2018}, + publisher={American Association for the Advancement of Science} +} + +@article{van2021sustainable, + title={Sustainable AI: AI for sustainability and the sustainability of AI}, + author={van Wynsberghe, Aimee}, + journal={AI and Ethics}, + volume={1}, + number={3}, + pages={213--218}, + year={2021}, + publisher={Springer} +} + +@article{10.1145/1400181.1400186, +author = {Kurp, Patrick}, +title = {Green Computing}, +year = {2008}, +issue_date = {October 2008}, +publisher = {Association for Computing Machinery}, +address = {New York, NY, USA}, +volume = {51}, +number = {10}, +issn = {0001-0782}, +doi = {10.1145/1400181.1400186}, +abstract = {Are you ready for a personal energy meter?}, +journal = {Commun. ACM}, +month = {oct}, +pages = {11–13}, +numpages = {3} +} + +@incollection{hasselbring2002component, + title={Component-based software engineering}, + author={Hasselbring, Wilhelm}, + booktitle={Handbook of Software Engineering and Knowledge Engineering: Volume II: Emerging Technologies}, + pages={289--305}, + year={2002}, + publisher={World Scientific} +} + +@InProceedings{ shammamah_hossain-proc-scipy-2019, + author = { {S}hammamah {H}ossain }, + title = { {V}isualization of {B}ioinformatics {D}ata with {D}ash {B}io }, + booktitle = { {P}roceedings of the 18th {P}ython in {S}cience {C}onference }, + pages = { 126 - 133 }, + year = { 2019 }, + editor = { {C}hris {C}alloway and {D}avid {L}ippa and {D}illon {N}iederhut and {D}avid {S}hupe }, + doi = { 10.25080/Majora-7ddc1dd1-012 } +} + +@inproceedings{kreps2011kafka, + title={Kafka: A distributed messaging system for log processing}, + author={Kreps, Jay and Narkhede, Neha and Rao, Jun and others}, + booktitle={Proceedings of the NetDB}, + volume={11}, + pages={1--7}, + year={2011} +} + +@article{garfinkel2007evaluation, + title={An evaluation of Amazon's grid computing services: EC2, S3, and SQS}, + author={Garfinkel, Simson}, + journal={Harvard Computer Science Group Technical Report}, + year={2007} +} + +@article{vinoski2006advanced, + title={Advanced message queuing protocol}, + author={Vinoski, Steve}, + journal={IEEE Internet Computing}, + volume={10}, + number={6}, + pages={87--89}, + year={2006}, + publisher={IEEE} +} + +@book{gamma1995design, + title={Design patterns: elements of reusable object-oriented software}, + author={Gamma, Erich and Helm, Richard and Johnson, Ralph and Johnson, Ralph E and Vlissides, John and others}, + year={1995}, + publisher={Pearson Deutschland GmbH} +} + +@article{alhojailan2012thematic, + title={Thematic analysis: A critical review of its process and evaluation}, + author={Alhojailan, Mohammed Ibrahim}, + journal={West east journal of social sciences}, + volume={1}, + number={1}, + pages={39--47}, + year={2012} +} + +@article{cruz2019catalog, + title={Catalog of energy patterns for mobile applications}, + author={Cruz, Luis and Abreu, Rui}, + journal={Empirical Software Engineering}, + volume={24}, + number={4}, + pages={2209--2235}, + year={2019}, + publisher={Springer} +} + +@book{Rumbaugh2004, + title = {Unified Modeling Language Reference Manual, The (2nd Edition)}, + publisher = {Pearson Higher Education}, + year = {2004}, + author = {Rumbaugh, James and Jacobson, Ivar and Booch, Grady}, + isbn = {0321245628} +} + +@inproceedings{wang2020producer, + title={Producer-consumer model based thread pool design}, + author={Wang, Liangzhou and Wang, Chaobin}, + booktitle={Journal of Physics: Conference Series}, + volume={1616}, + pages={012073}, + year={2020}, + organization={IOP Publishing} +} + +@book{nunnally1994psychometric, + title={Psychometric theory 3E}, + author={Nunnally, Jum C}, + year={1994}, + publisher={Tata McGraw-hill education} +} + +@article{gao2020survey, + title={A survey on deep learning for multimodal data fusion}, + author={Gao, Jing and Li, Peng and Chen, Zhikui and Zhang, Jianing}, + journal={Neural Computation}, + volume={32}, + number={5}, + pages={829--864}, + year={2020}, + publisher={MIT Press One Rogers Street, Cambridge, MA 02142-1209, USA journals} +} + +@book{russell2010artificial, + title={Artificial intelligence a modern approach}, + author={Russell, Stuart J}, + year={2010}, + publisher={Pearson Education, Inc.} +} + +@book{momjian2001postgresql, + title={PostgreSQL: introduction and concepts}, + author={Momjian, Bruce}, + volume={192}, + year={2001}, + publisher={Addison-Wesley New York} +} diff --git a/docs/simple-mag/mag/dev.txt b/docs/tutorial/data/dev.txt similarity index 100% rename from docs/simple-mag/mag/dev.txt rename to docs/tutorial/data/dev.txt diff --git a/docs/simple-mag/mag/test.txt b/docs/tutorial/data/test.txt similarity index 100% rename from docs/simple-mag/mag/test.txt rename to docs/tutorial/data/test.txt diff --git a/docs/simple-mag/mag/train.txt b/docs/tutorial/data/train.txt similarity index 100% rename from docs/simple-mag/mag/train.txt rename to docs/tutorial/data/train.txt diff --git a/docs/tutorial/deploy.ipynb b/docs/tutorial/deploy.ipynb new file mode 100644 index 0000000..63f353f --- /dev/null +++ b/docs/tutorial/deploy.ipynb @@ -0,0 +1,179 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Harden and deploy your app\n", + "\n", + "Finally, it's time to deploy your model. But before that, you have to make sure you follow AI deployment [best practices](https://se-ml.github.io/). In the past, this step was too often either the source of unexpected struggle, or worse, simply ignored.\n", + "\n", + "With `GreatAI`, it has become a matter of 4 lines of code." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[38;5;226mEnvironment variable ENVIRONMENT is not set, defaulting to development mode ‼️\u001b[0m\n", + "\u001b[38;5;226mCannot find credentials files, defaulting to using ParallelTinyDbDriver\u001b[0m\n", + "\u001b[38;5;226mThe selected tracing database (ParallelTinyDbDriver) is not recommended for production\u001b[0m\n", + "\u001b[38;5;226mCannot find credentials files, defaulting to using LargeFileLocal\u001b[0m\n", + "\u001b[38;5;39mGreatAI (v0.1.4): configured ✅\u001b[0m\n", + "\u001b[38;5;39m 🔩 tracing_database: ParallelTinyDbDriver\u001b[0m\n", + "\u001b[38;5;39m 🔩 large_file_implementation: LargeFileLocal\u001b[0m\n", + "\u001b[38;5;39m 🔩 is_production: False\u001b[0m\n", + "\u001b[38;5;39m 🔩 should_log_exception_stack: True\u001b[0m\n", + "\u001b[38;5;39m 🔩 prediction_cache_size: 512\u001b[0m\n", + "\u001b[38;5;39m 🔩 dashboard_table_size: 50\u001b[0m\n", + "\u001b[38;5;226mYou still need to check whether you follow all best practices before trusting your deployment.\u001b[0m\n", + "\u001b[38;5;226m> Find out more at https://se-ml.github.io/practices\u001b[0m\n", + "\u001b[38;5;39mFetching cached versions of my-domain-predictor\u001b[0m\n", + "\u001b[38;5;39mLatest version of my-domain-predictor is 9 (from versions: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9)\u001b[0m\n", + "\u001b[38;5;39mFile my-domain-predictor-9 found in cache\u001b[0m\n" + ] + } + ], + "source": [ + "from great_ai import GreatAI, use_model\n", + "from great_ai.utilities import clean\n", + "\n", + "\n", + "@GreatAI.create\n", + "@use_model(\"my-domain-predictor\")\n", + "def predict_domain(sentence, model):\n", + " inputs = [clean(sentence)]\n", + " return str(model.predict(inputs)[0])" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Trace[str]({'created': '2022-07-12T13:34:26.743292',\n", + " 'exception': None,\n", + " 'feedback': None,\n", + " 'logged_values': { 'arg:sentence:length': 29,\n", + " 'arg:sentence:value': 'Mountains are just big rocks.'},\n", + " 'models': [{'key': 'my-domain-predictor', 'version': 9}],\n", + " 'original_execution_time_ms': 6.9699,\n", + " 'output': 'geography',\n", + " 'tags': ['predict_domain', 'online', 'development'],\n", + " 'trace_id': 'c80bdee3-602b-49dd-a84d-6eef80127e5a'})" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "predict_domain(\"Mountains are just big rocks.\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Notice how the original return value is under the `.output` key. Additionally, a plethora of metadata has been added which will be useful later on.\n", + "\n", + "Running your app in development-mode is as easy as executing `great-ai deploy.ipynb` from your terminal." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[38;5;39m2022-07-12 15:34:28 | INFO | Converting notebook to Python script\u001b[0m\n", + "\u001b[38;5;39m2022-07-12 15:34:29 | INFO | Found `predict_domain` to be the GreatAI app \u001b[0m\n", + "\u001b[38;5;39m2022-07-12 15:34:29 | INFO | Uvicorn running on http://0.0.0.0:6060 (Press CTRL+C to quit)\u001b[0m\n", + "\u001b[38;5;226m2022-07-12 15:34:31 | WARNING | Environment variable ENVIRONMENT is not set, defaulting to development mode ‼️\u001b[0m\n", + "\u001b[38;5;226m2022-07-12 15:34:31 | WARNING | Cannot find credentials files, defaulting to using ParallelTinyDbDriver\u001b[0m\n", + "\u001b[38;5;226m2022-07-12 15:34:31 | WARNING | The selected tracing database (ParallelTinyDbDriver) is not recommended for production\u001b[0m\n", + "\u001b[38;5;226m2022-07-12 15:34:31 | WARNING | Cannot find credentials files, defaulting to using LargeFileLocal\u001b[0m\n", + "\u001b[38;5;39m2022-07-12 15:34:31 | INFO | GreatAI (v0.1.4): configured ✅\u001b[0m\n", + "\u001b[38;5;39m2022-07-12 15:34:31 | INFO | 🔩 tracing_database: ParallelTinyDbDriver\u001b[0m\n", + "\u001b[38;5;39m2022-07-12 15:34:31 | INFO | 🔩 large_file_implementation: LargeFileLocal\u001b[0m\n", + "\u001b[38;5;39m2022-07-12 15:34:31 | INFO | 🔩 is_production: False\u001b[0m\n", + "\u001b[38;5;39m2022-07-12 15:34:31 | INFO | 🔩 should_log_exception_stack: True\u001b[0m\n", + "\u001b[38;5;39m2022-07-12 15:34:31 | INFO | 🔩 prediction_cache_size: 512\u001b[0m\n", + "\u001b[38;5;39m2022-07-12 15:34:31 | INFO | 🔩 dashboard_table_size: 50\u001b[0m\n", + "\u001b[38;5;226m2022-07-12 15:34:31 | WARNING | You still need to check whether you follow all best practices before trusting your deployment.\u001b[0m\n", + "\u001b[38;5;226m2022-07-12 15:34:31 | WARNING | > Find out more at https://se-ml.github.io/practices\u001b[0m\n", + "\u001b[38;5;39m2022-07-12 15:34:31 | INFO | Fetching cached versions of my-domain-predictor\u001b[0m\n", + "\u001b[38;5;39m2022-07-12 15:34:31 | INFO | Latest version of my-domain-predictor is 9 (from versions: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9)\u001b[0m\n", + "\u001b[38;5;39m2022-07-12 15:34:31 | INFO | File my-domain-predictor-9 found in cache\u001b[0m\n", + "\u001b[38;5;39m2022-07-12 15:34:31 | INFO | Started server process [199794]\u001b[0m\n", + "\u001b[38;5;39m2022-07-12 15:34:31 | INFO | Waiting for application startup.\u001b[0m\n", + "\u001b[38;5;39m2022-07-12 15:34:31 | INFO | Application startup complete.\u001b[0m\n", + "^C\n", + "\u001b[38;5;39m2022-07-12 15:34:33 | INFO | Shutting down\u001b[0m\n", + "\u001b[38;5;39m2022-07-12 15:34:33 | INFO | Waiting for application shutdown.\u001b[0m\n", + "\u001b[38;5;39m2022-07-12 15:34:33 | INFO | Application shutdown complete.\u001b[0m\n", + "\u001b[38;5;39m2022-07-12 15:34:33 | INFO | Finished server process [199794]\u001b[0m\n" + ] + } + ], + "source": [ + "!great-ai deploy.ipynb\n", + "# leave this running and open http://127.0.0.1:6060" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Congrats, you've just created your first GreatAI service! 🎉\n", + "\n", + "Now that you've made sure your application is hardened enough for the intended use case, it is time to deploy it. The responsibilities of GreatAI end when it wraps your inference function and model into a production-ready service. You're given the freedom and responsibility to deploy this service. Fortunately, you (or your organisation) probably already have an established routine for deploying services.\n", + "\n", + "There are three main approaches to deploy a GreatAI service: For more info about them, check out [the deployment how-to](/how-to-guides/use-service).\n", + "\n", + "For more thorough examples, see the [examples page](/examples/simple/data).\n", + "\n", + "### [Go back to the summary](/tutorial/#summary)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.10.4 ('.env': venv)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.4" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "02dd6d3afbfa9fbbe1037d64ad9014965528a1ccad21929d6e72f466389a68ad" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/docs/tutorial/index.md b/docs/tutorial/index.md new file mode 100644 index 0000000..b9055d6 --- /dev/null +++ b/docs/tutorial/index.md @@ -0,0 +1,79 @@ +# Train and deploy a SOTA model + +Let's see `great-ai` in action by going over the lifecycle of a simple service. + +## Objectives + +1. You will see how the [great_ai.utilities](/reference/utilities) can integrate into your Data Science workflow. +2. You will use [great_ai.large_file](/reference/large-file) to version and store your trained model. +3. You will use [GreatAI][great_ai.GreatAI] to prepare your model for a robust and responsible deployment. + +## Overview + +You will train a field of study (domain) classifier for scientific sentences. The exact task was proposed by the [SciBERT paper](https://arxiv.org/abs/1903.10676){ target=_blank } in which SciBERT [achieved an F1-score of 0.6571](https://paperswithcode.com/sota/sentence-classification-on-paper-field){ target=_blank }. We are going to outperform it using a trivial text classification model: a [Linear SVM](https://scikit-learn.org/stable/modules/generated/sklearn.svm.LinearSVC.html){ target=_blank }. + +We use the same synthetic dataset derived from the [Microsoft Academic Graph](https://www.microsoft.com/en-us/research/project/microsoft-academic-graph/){ target=_blank }. The dataset is [available here](https://github.com/allenai/scibert/tree/master/data/text_classification/mag){ target=_blank }. + +!!! success + You are ready to start the tutorial. Feel free to return to the [summary](#summary) section once you're finished. + +
+[:fontawesome-solid-chart-simple: Train it](train.ipynb){ .md-button .md-button--primary } + +[:material-cloud-tags: Deploy it](deploy.ipynb){ .md-button .md-button--primary } +
+ +## Summary + +### [Training notebook](train.ipynb) + +We load and preprocess the dataset while relying on [great_ai.utilities.clean][great_ai.utilities.clean.clean] for doing the heavy-lifting. Additionally, the preprocessing is parallelised using [great_ai.utilities.simple_parallel_map][] + +After training and evaluating a model, it is exported using [great_ai.save_model][]. + +??? tip "Remote storage" + To store your model remotely, you must set your credentials before calling `save_model`. + + For example, to use [AWS S3](https://aws.amazon.com/s3){ target=_blank }: + ```python + from great_ai.large_file import LargeFileS3 + + LargeFileS3.configure( + aws_region_name='eu-west-2', + aws_access_key_id='MY_AWS_ACCESS_KEY', + aws_secret_access_key='MY_AWS_SECRET_KEY', + large_files_bucket_name='my_bucket_for_models' + ) + + from great_ai import save_model + + save_model(model, key='my-domain-predictor') + ``` + + For more info, checkout [the configuration how-to page](/how-to-guides/configure-service). + +### [Deployment notebook](deploy.ipynb) + +We create an inference function that can be hardened by wrapping it in a [GreatAI][great_ai.GreatAI] instance. + +```python +from great_ai import GreatAI, use_model +from great_ai.utilities import clean + +@GreatAI.create +@use_model('my-domain-predictor') #(1) +def predict_domain(sentence, model): + inputs = [clean(sentence)] + return str(model.predict(inputs)[0]) +``` + +1. [@use_model][great_ai.use_model] loads and injects your model into the `predict_domain` function's `model` argument. + You can freely reference it, knowing that the function is always provided with it. + +Finally, we test the model's inference function through the GreatAI dashboard. [The only thing left is to deploy the hardened service properly.](/how-to-guides/use-service) + +
+[:material-book: Learn about all the features](/how-to-guides/create-service){ .md-button .md-button--primary } + +[:material-test-tube: Look at more examples](/examples/simple/data){ .md-button .md-button--secondary } +
diff --git a/docs/tutorial/train.ipynb b/docs/tutorial/train.ipynb new file mode 100644 index 0000000..61b8e1e --- /dev/null +++ b/docs/tutorial/train.ipynb @@ -0,0 +1,326 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Train your model\n", + "\n", + "The first step is, of course, to install `great-ai` in your Python environment." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Note: you may need to restart the kernel to use updated packages.\n" + ] + } + ], + "source": [ + "%pip install great-ai > /dev/null" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "First, we have to get some data. After downloading it [from here](https://github.com/allenai/scibert/tree/master/data/text_classification/mag), we might notice that the dataset is in [JSON Lines](https://jsonlines.org/) format (each line is a separate JSON document). \n", + "\n", + "Let's write a function which takes a single line and returns the sentence and the corresponding label from it. Before returning, the sentence is also [cleaned](/reference/utilities/#great_ai.utilities.clean.clean) to remove any LaTeX, XML, unicode, PDF-extraction artifacts." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import json\n", + "from great_ai.utilities import clean\n", + "\n", + "\n", + "def preprocess(line):\n", + " data_point = json.loads(line)\n", + "\n", + " sentence = data_point[\"text\"]\n", + " label = data_point[\"label\"]\n", + "\n", + " return clean(sentence), label" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, we can load the dataset and extract the *training* samples from it. Since we're impatient, we can do it in parallel using the [`simple_parallel_map`](/reference/utilities/#great_ai.utilities.simple_parallel_map) function.\n", + "\n", + "> Open files in Python are iterable: in text mode, each iteration returns the next line." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 84000/84000 [00:09<00:00, 8960.63it/s] \n" + ] + } + ], + "source": [ + "from great_ai.utilities import simple_parallel_map\n", + "\n", + "with open(\"data/train.txt\", encoding=\"utf-8\") as f:\n", + " training_data = simple_parallel_map(preprocess, f)\n", + "\n", + "X_train = [d[0] for d in training_data]\n", + "y_train = [d[1] for d in training_data]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's do the same for the *test* data." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 22399/22399 [00:03<00:00, 6078.02it/s]\n" + ] + } + ], + "source": [ + "with open(\"data/test.txt\", encoding=\"utf-8\") as f:\n", + " test_data = simple_parallel_map(preprocess, f)\n", + "\n", + "X_test = [d[0] for d in test_data]\n", + "y_test = [d[1] for d in test_data]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "After obtaining some clean data, it's time to create and train a model on it. We are going to use [scikit-learn](https://scikit-learn.org/stable/auto_examples/classification/plot_classifier_comparison.html) for this purpose.\n", + "\n", + "In this case, we opted for a [linear Support Vector Machine](https://scikit-learn.org/stable/modules/generated/sklearn.svm.LinearSVC.html) because it's known to be an adequate baseline for simple classification tasks." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
Pipeline(steps=[('tfidfvectorizer', TfidfVectorizer()),\n",
+       "                ('linearsvc', LinearSVC())])
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ], + "text/plain": [ + "Pipeline(steps=[('tfidfvectorizer', TfidfVectorizer()),\n", + " ('linearsvc', LinearSVC())])" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from sklearn.pipeline import make_pipeline\n", + "from sklearn.feature_extraction.text import TfidfVectorizer\n", + "from sklearn.svm import LinearSVC\n", + "\n", + "model = make_pipeline(TfidfVectorizer(), LinearSVC())\n", + "# todo: hyperparameter-optimisation\n", + "model.fit(X_train, y_train)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "It's already finished. Let's see how well it performs. But first, we need to [configure matplotlib](https://matplotlib.org/stable/tutorials/introductory/customizing.html) to make the charts more legible. \n", + "> `ConfusionMatrixDisplay` relies on `matplotlib` for rendering." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "%matplotlib inline\n", + "plt.rcParams[\"figure.figsize\"] = (30, 15)\n", + "plt.rcParams[\"figure.facecolor\"] = \"white\"\n", + "plt.rcParams[\"font.size\"] = 12" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next, we check the quality of the model on the `test` split. We can use the classification report to check the common metrics, such as the macro F1-score. We also draw the confusion matrix to get some insights into the types of mistakes being made by the model." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " precision recall f1-score support\n", + "\n", + " business 0.67 0.69 0.68 3198\n", + " economics 0.69 0.71 0.70 3189\n", + " geography 0.70 0.73 0.72 3207\n", + " medicine 0.90 0.91 0.90 3187\n", + " politics 0.63 0.57 0.60 3169\n", + " psychology 0.73 0.73 0.73 3252\n", + " sociology 0.51 0.51 0.51 3197\n", + "\n", + " accuracy 0.69 22399\n", + " macro avg 0.69 0.69 0.69 22399\n", + "weighted avg 0.69 0.69 0.69 22399\n", + "\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from sklearn import metrics\n", + "\n", + "y_predicted = model.predict(X_test)\n", + "\n", + "print(metrics.classification_report(y_test, y_predicted))\n", + "metrics.ConfusionMatrixDisplay.from_predictions(y_test, y_predicted)\n", + "None" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Great work, we can be rightfully satisfied with our model. Seeing the results, we achieved an F1-score of 0.69 which is about **5% better than SciBERT's** 0.6571!\n", + "\n", + "You might wonder that *\"this is great, but besides some utility functions (`clean`, `simple_parallel_map`, ...) what more value does GreatAI add?\"*. This would be a valid argument because the scope of GreatAI actually only starts here.\n", + "\n", + "> Not coincidentally, this is the point where the scope of Data Science ends but it's still a grey zone for software engineering.\n", + "\n", + "In order to use this model in production, we have to make it available on some possibly shared infrastructure." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[38;5;226mEnvironment variable ENVIRONMENT is not set, defaulting to development mode ‼️\u001b[0m\n", + "\u001b[38;5;226mCannot find credentials files, defaulting to using ParallelTinyDbDriver\u001b[0m\n", + "\u001b[38;5;226mThe selected tracing database (ParallelTinyDbDriver) is not recommended for production\u001b[0m\n", + "\u001b[38;5;226mCannot find credentials files, defaulting to using LargeFileLocal\u001b[0m\n", + "\u001b[38;5;39mGreatAI (v0.1.4): configured ✅\u001b[0m\n", + "\u001b[38;5;39m 🔩 tracing_database: ParallelTinyDbDriver\u001b[0m\n", + "\u001b[38;5;39m 🔩 large_file_implementation: LargeFileLocal\u001b[0m\n", + "\u001b[38;5;39m 🔩 is_production: False\u001b[0m\n", + "\u001b[38;5;39m 🔩 should_log_exception_stack: True\u001b[0m\n", + "\u001b[38;5;39m 🔩 prediction_cache_size: 512\u001b[0m\n", + "\u001b[38;5;39m 🔩 dashboard_table_size: 50\u001b[0m\n", + "\u001b[38;5;226mYou still need to check whether you follow all best practices before trusting your deployment.\u001b[0m\n", + "\u001b[38;5;226m> Find out more at https://se-ml.github.io/practices\u001b[0m\n", + "\u001b[38;5;39mFetching cached versions of my-domain-predictor\u001b[0m\n", + "\u001b[38;5;39mCopying file for my-domain-predictor-9\u001b[0m\n", + "\u001b[38;5;39mCompressing my-domain-predictor-9\u001b[0m\n", + "\u001b[38;5;39mModel my-domain-predictor uploaded with version 9\u001b[0m\n" + ] + }, + { + "data": { + "text/plain": [ + "'my-domain-predictor:9'" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from great_ai import save_model\n", + "\n", + "save_model(model, key=\"my-domain-predictor\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### [Let's continue by finishing the deployment in the next notebook.](/tutorial/deploy)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.10.4 ('.env': venv)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.4" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "02dd6d3afbfa9fbbe1037d64ad9014965528a1ccad21929d6e72f466389a68ad" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/great_ai/__init__.py b/great_ai/__init__.py new file mode 100644 index 0000000..da7dba8 --- /dev/null +++ b/great_ai/__init__.py @@ -0,0 +1,32 @@ +"""Transform your prototype AI code into production-ready software.""" + +__version__ = "0.1.11" + + +from .context import configure +from .deploy import GreatAI +from .errors import ( + ArgumentValidationError, + MissingArgumentError, + RemoteCallError, + WrongDecoratorOrderError, +) +from .models.save_model import save_model +from .models.use_model import use_model +from .parameters.log_metric import log_metric +from .parameters.parameter import parameter +from .persistence.mongodb_driver import MongoDbDriver +from .persistence.parallel_tinydb_driver import ParallelTinyDbDriver +from .persistence.tracing_database_driver import TracingDatabaseDriver +from .remote.call_remote_great_ai import call_remote_great_ai +from .remote.call_remote_great_ai_async import call_remote_great_ai_async +from .tracing.add_ground_truth import add_ground_truth +from .tracing.delete_ground_truth import delete_ground_truth +from .tracing.query_ground_truth import query_ground_truth +from .views import RouteConfig, Trace +from .views.outputs.classification_output import ClassificationOutput +from .views.outputs.multi_label_classification_output import ( + MultiLabelClassificationOutput, +) +from .views.outputs.regression_output import RegressionOutput +from .views.outputs.sequence_labeling_output import SequenceLabelingOutput diff --git a/src/great_ai/__main__.py b/great_ai/__main__.py similarity index 74% rename from src/great_ai/__main__.py rename to great_ai/__main__.py index e24af7f..ec4915d 100644 --- a/src/great_ai/__main__.py +++ b/great_ai/__main__.py @@ -2,24 +2,25 @@ import logging import re -import time from importlib import import_module, reload from pathlib import Path +from threading import Event from typing import Optional import uvicorn from uvicorn._subprocess import get_subprocess from uvicorn.config import LOGGING_CONFIG, Config -from uvicorn.supervisors.basereload import BaseReload +from uvicorn.supervisors import BaseReload, Multiprocess from watchdog.events import FileSystemEvent, PatternMatchingEventHandler from watchdog.observers import Observer -from .great_ai.constants import SERVER_NAME -from .great_ai.context import _is_in_production_mode -from .great_ai.deploy import GreatAI -from .great_ai.exceptions import ArgumentValidationError, MissingArgumentError +from great_ai.constants import SERVER_NAME +from great_ai.context import _is_in_production_mode +from great_ai.deploy import GreatAI +from great_ai.errors import ArgumentValidationError, MissingArgumentError +from great_ai.utilities import get_logger + from .parse_arguments import parse_arguments -from .utilities import get_logger logger = get_logger(SERVER_NAME) @@ -28,24 +29,24 @@ GREAT_AI_LOGGING_CONFIG = { **LOGGING_CONFIG, "formatters": { "default": { - "()": "great_ai.logger.CustomFormatter", + "()": "great_ai.utilities.logger.get_logger.CustomFormatter", "fmt": "%(asctime)s | %(levelname)8s | %(message)s", }, "access": { - "()": "great_ai.logger.CustomFormatter", - "fmt": "%(asctime)s | %(levelname)8s | %(message)s", # noqa: E501 + "()": "great_ai.utilities.logger.get_logger.CustomFormatter", + "fmt": "%(asctime)s | %(levelname)8s | %(message)s", }, }, } -def main() -> None: +def serve() -> None: args = parse_arguments() should_auto_reload = not _is_in_production_mode(logger=None) - if args.workers > 1 and should_auto_reload: + if args.worker_count > 1 and should_auto_reload: raise ArgumentValidationError( - "Cannot use auto-reload with multiple workers: set the `--workers=1` CLI argument," + "Cannot use auto-reload with multiple worker_count: set the `--worker_count=1` CLI argument," + "or set the ENVIRONMENT environment variable to `production`." ) @@ -53,7 +54,7 @@ def main() -> None: host=args.host, port=args.port, timeout_keep_alive=args.timeout_keep_alive, - workers=args.workers, + workers=args.worker_count, server_header=False, reload=False, log_config=GREAT_AI_LOGGING_CONFIG, @@ -65,7 +66,21 @@ def main() -> None: logger.info(f"Starting uvicorn server with app={app}") - uvicorn.run(app, **common_config) + config = Config(app, **common_config) + socket = config.bind_socket() + + try: + Multiprocess( + config, target=uvicorn.Server(config=config).run, sockets=[socket] + ).run() + + finally: + if args.file_name.endswith(".ipynb"): + try: + Path(get_script_name_of_notebook(args.file_name)).unlink() + except FileNotFoundError: + # missing_ok only exists >= Python 3.8 + pass else: class EventHandler(PatternMatchingEventHandler): @@ -106,15 +121,16 @@ def main() -> None: observer.start() try: - while True: - time.sleep(50) + Event().wait() finally: observer.stop() restart_handler.stop_server() if args.file_name.endswith(".ipynb"): - Path(get_script_name_of_notebook(args.file_name)).unlink( - missing_ok=True - ) + try: + Path(get_script_name_of_notebook(args.file_name)).unlink() + except FileNotFoundError: + # missing_ok only exists >= Python 3.8 + pass observer.join() @@ -125,6 +141,8 @@ def get_script_name(file_name_argument: str) -> str: exporter = PythonExporter() content, _ = exporter.from_filename(file_name_argument) + content = re.sub(r".*get_ipython\(.*", "", content) + file_name_argument = get_script_name_of_notebook(file_name_argument) with open(file_name_argument, "w", encoding="utf-8") as f: @@ -157,6 +175,7 @@ def find_app(file_name: str) -> Optional[str]: finally: logging.disable(logging.NOTSET) + app_name = None for name, value in module.__dict__.items(): if isinstance(value, GreatAI): app_name = name @@ -165,7 +184,7 @@ def find_app(file_name: str) -> Optional[str]: logger.info(f"Found `{app_name}` to be the GreatAI app ") else: raise MissingArgumentError( - "GreatAI app could not be found, make sure to use `@GreatAI.deploy` on your prediction function" + "GreatAI app could not be found, make sure to use `@GreatAI.create` on your prediction function" ) return f"{file_name}:{app_name}.app" @@ -186,10 +205,19 @@ class GreatAIReload(BaseReload): sock.close() -if __name__ == "__main__": +def main() -> None: + import os + import sys + + sys.path.append(os.getcwd()) + try: - main() + serve() except KeyboardInterrupt: exit() except Exception as e: logger.error(e) + + +if __name__ == "__main__": + main() diff --git a/src/great_ai/great_ai/constants.py b/great_ai/constants.py similarity index 68% rename from src/great_ai/great_ai/constants.py rename to great_ai/constants.py index a912be8..dfa336e 100644 --- a/src/great_ai/great_ai/constants.py +++ b/great_ai/constants.py @@ -1,5 +1,5 @@ -from ..large_file import LargeFileMongo, LargeFileS3 -from .persistence.mongodb_driver import MongodbDriver +from .large_file import LargeFileMongo, LargeFileS3 +from .persistence.mongodb_driver import MongoDbDriver ENV_VAR_KEY = "ENVIRONMENT" PRODUCTION_KEY = "production" @@ -7,7 +7,7 @@ DASHBOARD_PATH = "/dashboard" MONGO_CONFIG_PATHS = ["mongodb.ini", "mongo.ini", "mongo_db.ini", "mongo-db.ini"] DEFAULT_TRACING_DATABASE_CONFIG_PATHS = { - MongodbDriver: MONGO_CONFIG_PATHS, + MongoDbDriver: MONGO_CONFIG_PATHS, } DEFAULT_LARGE_FILE_CONFIG_PATHS = { @@ -15,7 +15,7 @@ DEFAULT_LARGE_FILE_CONFIG_PATHS = { LargeFileMongo: MONGO_CONFIG_PATHS, } -GITHUB_LINK = "https://github.com/ScoutinScience/great_ai" +GITHUB_LINK = "https://github.com/schmelczer/great_ai" TRAIN_SPLIT_TAG_NAME = "train" TEST_SPLIT_TAG_NAME = "test" @@ -27,4 +27,5 @@ ONLINE_TAG_NAME = "online" SERVER_NAME = "GreatAI-Server" -SE4ML_WEBSITE = "https://se-ml.github.io/practices/" +SE4ML_WEBSITE = "https://se-ml.github.io/practices" +LIST_ITEM_PREFIX = " 🔩 " diff --git a/src/great_ai/great_ai/context.py b/great_ai/context.py similarity index 55% rename from src/great_ai/great_ai/context.py rename to great_ai/context.py index 7e8f2e2..24412a5 100644 --- a/src/great_ai/great_ai/context.py +++ b/great_ai/context.py @@ -2,33 +2,39 @@ import os import random from logging import DEBUG, Logger from pathlib import Path -from typing import Any, Dict, Optional, Type, cast +from typing import Any, Dict, Optional, Type, Union, cast -from pydantic import BaseModel +from pydantic import BaseModel, ConfigDict + +from great_ai import __version__ -from ..large_file import LargeFile, LargeFileLocal -from ..utilities import get_logger from .constants import ( DEFAULT_LARGE_FILE_CONFIG_PATHS, DEFAULT_TRACING_DATABASE_CONFIG_PATHS, ENV_VAR_KEY, + LIST_ITEM_PREFIX, PRODUCTION_KEY, SE4ML_WEBSITE, ) -from .persistence import ParallelTinyDbDriver, TracingDatabaseDriver +from .large_file import LargeFileBase, LargeFileLocal +from .persistence.parallel_tinydb_driver import ParallelTinyDbDriver +from .persistence.tracing_database_driver import TracingDatabaseDriver +from .utilities import get_logger +from .views import RouteConfig class Context(BaseModel): + version: Union[int, str] tracing_database: TracingDatabaseDriver - large_file_implementation: Type[LargeFile] + large_file_implementation: Type[LargeFileBase] is_production: bool logger: Logger should_log_exception_stack: bool prediction_cache_size: int dashboard_table_size: int + route_config: RouteConfig - class Config: - arbitrary_types_allowed = True + model_config = ConfigDict(arbitrary_types_allowed=True) def to_flat_dict(self) -> Dict[str, Any]: return { @@ -53,20 +59,52 @@ def get_context() -> Context: def configure( *, + version: Union[int, str] = "0.0.1", log_level: int = DEBUG, seed: int = 42, - tracing_database: Optional[Type[TracingDatabaseDriver]] = None, - large_file_implementation: Optional[Type[LargeFile]] = None, + tracing_database_factory: Optional[Type[TracingDatabaseDriver]] = None, + large_file_implementation: Optional[Type[LargeFileBase]] = None, should_log_exception_stack: Optional[bool] = None, prediction_cache_size: int = 512, disable_se4ml_banner: bool = False, dashboard_table_size: int = 50, + route_config: RouteConfig = RouteConfig(), ) -> None: + """Set the global configuration used by the great-ai library. + + You must call `configure` before calling (or decorating with) any other great-ai + function. + + If `tracing_database_factory` or `large_file_implementation` is not specified, their + default value is determined based on which TracingDatabase and LargeFile has been + configured (e.g.: LargeFileS3.configure_credentials_from_file('s3.ini')), or whether + there is any file named s3.ini or mongo.ini in the working directory. + + Examples: + >>> configure(prediction_cache_size=0) + + Arguments: + version: The version of your application (using SemVer is recommended). + log_level: Set the default logging level of `logging`. + seed: Set seed of `random` (and `numpy` if installed) for reproducibility. + tracing_database_factory: Specify a different TracingDatabaseDriver than the one + already configured. + large_file_implementation: Specify a different LargeFile than the one already + configured. + should_log_exception_stack: Log the traces of unhandled exceptions. + prediction_cache_size: Size of the LRU cache applied over the prediction + functions. + disable_se4ml_banner: Turn off the warning about the importance of SE4ML best- + practices. + dashboard_table_size: Number of rows to display in the dashboard's table. + route_config: Enable or disable specific HTTP API endpoints. + """ + global _context logger = get_logger("great_ai", level=log_level) if _context is not None: - logger.warn( + logger.error( "Configuration has been already initialised, overwriting.\n" + "Make sure to call `configure()` before importing your application code." ) @@ -75,39 +113,47 @@ def configure( _set_seed(seed) - tracing_database = _initialize_tracing_database(tracing_database, logger=logger)() + tracing_database_factory = _initialize_tracing_database( + tracing_database_factory, logger=logger + ) + tracing_database = tracing_database_factory() if not tracing_database.is_production_ready: + message = f"""The selected tracing database ({ + tracing_database_factory.__name__ + }) is not recommended for production""" + if is_production: - logger.error( - f"The selected tracing database ({type(tracing_database).__name__}) is not recommended for production" - ) + logger.error(message) else: - logger.warning( - f"The selected tracing database ({type(tracing_database).__name__}) is not recommended for production" - ) + logger.warning(message) _context = Context( + version=version, tracing_database=tracing_database, large_file_implementation=_initialize_large_file( large_file_implementation, logger=logger ), is_production=is_production, logger=logger, - should_log_exception_stack=not is_production - if should_log_exception_stack is None - else should_log_exception_stack, + should_log_exception_stack=( + not is_production + if should_log_exception_stack is None + else should_log_exception_stack + ), prediction_cache_size=prediction_cache_size, dashboard_table_size=dashboard_table_size, + route_config=route_config, ) - logger.info("Settings: configured ✅") + logger.info(f"GreatAI (v{__version__}): configured ✅") for k, v in get_context().to_flat_dict().items(): - logger.info(f"🔩 {k}: {v}") + logger.info(f"{LIST_ITEM_PREFIX}{k}: {v}") if not is_production and not disable_se4ml_banner: logger.warning( - "You still need to check whether you follow all best practices before trusting your deployment." + "You still need to check whether you follow all best practices before " + "trusting your deployment." ) logger.warning(f"> Find out more at {SE4ML_WEBSITE}") @@ -118,7 +164,8 @@ def _is_in_production_mode(logger: Optional[Logger]) -> bool: if environment is None: if logger: logger.warning( - f"Environment variable {ENV_VAR_KEY} is not set, defaulting to development mode ‼️" + f"Environment variable {ENV_VAR_KEY} is not set, " + "defaulting to development mode ‼️" ) is_production = False else: @@ -126,8 +173,8 @@ def _is_in_production_mode(logger: Optional[Logger]) -> bool: if logger: if not is_production: logger.info( - f"Value of {ENV_VAR_KEY} is `{environment}` which is not equal to `{PRODUCTION_KEY}`" - + "defaulting to development mode ‼️" + f"Value of {ENV_VAR_KEY} is `{environment}` which is not equal to" + + f"`{PRODUCTION_KEY}` defaulting to development mode ‼️" ) else: logger.info("Running in production mode ✅") @@ -141,14 +188,17 @@ def _initialize_tracing_database( for tracing_driver, paths in DEFAULT_TRACING_DATABASE_CONFIG_PATHS.items(): if selected is None or selected == tracing_driver: if tracing_driver.initialized: - logger.warning( - f"{tracing_driver.__name__} has been already configured: skipping initialisation" + logger.info( + f"{tracing_driver.__name__} has been already configured: " + "skipping initialisation" ) return tracing_driver for p in paths: if Path(p).exists(): logger.info( - f"Found credentials file ({Path(p).absolute()}), initialising {tracing_driver.__name__}" + f"""Found credentials file ({Path(p).absolute()}), initialising { + tracing_driver.__name__ + }""" ) tracing_driver.configure_credentials_from_file(p) return tracing_driver @@ -159,19 +209,21 @@ def _initialize_tracing_database( def _initialize_large_file( - selected: Optional[Type[LargeFile]], logger: Logger -) -> Type[LargeFile]: + selected: Optional[Type[LargeFileBase]], logger: Logger +) -> Type[LargeFileBase]: for large_file, paths in DEFAULT_LARGE_FILE_CONFIG_PATHS.items(): if selected is None or selected == large_file: if large_file.initialized: - logger.warning( + logger.info( f"{large_file.__name__} has been already configured: skipping initialisation" ) return large_file for p in paths: if Path(p).exists(): logger.info( - f"Found credentials file ({Path(p).absolute()}), initialising {large_file.__name__}" + f"""Found credentials file ({Path(p).absolute()}), initialising { + large_file.__name__ + }""" ) large_file.configure_credentials_from_file(p) return large_file diff --git a/src/great_ai/great_ai/deploy/__init__.py b/great_ai/deploy/__init__.py similarity index 100% rename from src/great_ai/great_ai/deploy/__init__.py rename to great_ai/deploy/__init__.py diff --git a/great_ai/deploy/great_ai.py b/great_ai/deploy/great_ai.py new file mode 100644 index 0000000..ac14590 --- /dev/null +++ b/great_ai/deploy/great_ai.py @@ -0,0 +1,319 @@ +from functools import lru_cache, wraps +from textwrap import dedent +from typing import ( + Any, + Awaitable, + Callable, + Generic, + List, + Literal, + Optional, + Sequence, + Tuple, + TypeVar, + Union, + cast, + overload, +) + +from fastapi import FastAPI +from tqdm import tqdm + +from ..constants import DASHBOARD_PATH +from ..context import get_context +from ..external.async_lru import alru_cache +from ..helper import freeze_arguments, get_function_metadata_store, snake_case_to_text +from ..models.use_model import model_versions +from ..parameters.automatically_decorate_parameters import ( + automatically_decorate_parameters, +) +from ..tracing.tracing_context import TracingContext +from ..utilities import parallel_map +from ..views import ApiMetadata, Trace +from .routes.bootstrap_dashboard import bootstrap_dashboard +from .routes.bootstrap_docs_endpoints import bootstrap_docs_endpoints +from .routes.bootstrap_feedback_endpoints import bootstrap_feedback_endpoints +from .routes.bootstrap_meta_endpoints import bootstrap_meta_endpoints +from .routes.bootstrap_prediction_endpoint import bootstrap_prediction_endpoint +from .routes.bootstrap_trace_endpoints import bootstrap_trace_endpoints + +T = TypeVar("T", bound=Union[Trace, Awaitable[Trace]]) +V = TypeVar("V") + + +class GreatAI(Generic[T, V]): + """Wrapper for a prediction function providing the implementation of SE4ML best practices. + + Provides caching (with argument freezing), a TracingContext during execution, the + scaffolding of HTTP endpoints using FastAPI and a dashboard using Dash. + + IMPORTANT: when a request is served from cache, no new trace is created. Thus, the + same trace can be returned multiple times. If this is undesirable turn off caching + using `configure(prediction_cache_size=0)`. + + Supports wrapping async and synchronous functions while also maintaining correct + typing. + + Attributes: + app: FastAPI instance wrapping the scaffolded endpoints and the Dash app. + version: SemVer derived from the app's version and the model names and versions + registered through use_model. + """ + + __name__: str # help for MyPy + __doc__: str # help for MyPy + + def __init__( + self, + func: Callable[..., Union[V, Awaitable[V]]], + ): + """Do not call this function directly, use GreatAI.create instead.""" + + func = automatically_decorate_parameters(func) + get_function_metadata_store(func).is_finalised = True + + self._cached_func = self._get_cached_traced_function(func) + self._wrapped_func = wraps(func)(freeze_arguments(self._cached_func)) + + wraps(func)(self) + self.__doc__ = ( + f"GreatAI wrapper for interacting with the `{self.__name__}` " + + f"function.\n\n{dedent(self.__doc__ or '')}" + ) + + self.version = str(get_context().version) + flat_model_versions = ".".join(f"{k}-v{v}" for k, v in model_versions) + if flat_model_versions: + self.version += f"+{flat_model_versions}" + + self.app = FastAPI( + title=snake_case_to_text(self.__name__), + version=self.version, + description=self.__doc__ + + f"\n\nFind out more in the [dashboard]({DASHBOARD_PATH}).", + docs_url=None, + redoc_url=None, + ) + + self._bootstrap_rest_api() + + @overload + @staticmethod + def create( # type: ignore + # Overloaded function signatures 1 and 2 overlap with incompatible return types + # https://github.com/python/mypy/issues/12759 + func: Callable[..., Awaitable[V]], + ) -> "GreatAI[Awaitable[Trace[V]], V]": ... + + @overload + @staticmethod + def create( + func: Callable[..., V], + ) -> "GreatAI[Trace[V], V]": ... + + @staticmethod + def create( + func: Union[Callable[..., Awaitable[V]], Callable[..., V]], + ) -> Union["GreatAI[Awaitable[Trace[V]], V]", "GreatAI[Trace[V], V]"]: + """Decorate a function by wrapping it in a GreatAI instance. + + The function can be typed, synchronous or async. If it has + unwrapped parameters (parameters not affected by a + [@parameter][great_ai.parameter] or [@use_model][great_ai.use_model] decorator), + those will be automatically wrapped. + + The return value is replaced by a Trace (or Awaitable[Trace]), + while the original return value is available under the `.output` + property. + + For configuration options, see [great_ai.configure][]. + + Examples: + >>> @GreatAI.create + ... def my_function(a): + ... return a + 2 + >>> my_function(3).output + 5 + + >>> @GreatAI.create + ... def my_function(a: int) -> int: + ... return a + 2 + >>> my_function(3) + Trace[int]... + + >>> my_function('3').output + Traceback (most recent call last): + ... + TypeError: argument a is not of the expected type: ... + + Args: + func: The prediction function that needs to be decorated. + + Returns: + A GreatAI instance wrapping `func`. + """ + + return GreatAI[Trace[V], V]( + func, + ) + + def __call__(self, *args: Any, **kwargs: Any) -> T: + return self._wrapped_func(*args, **kwargs) + + @overload + def process_batch( + self, + batch: Sequence[Tuple], + *, + concurrency: Optional[int] = None, + unpack_arguments: Literal[True], + do_not_persist_traces: bool = ..., + ) -> List[Trace[V]]: ... + + @overload + def process_batch( + self, + batch: Sequence, + *, + concurrency: Optional[int] = None, + unpack_arguments: Literal[False] = ..., + do_not_persist_traces: bool = ..., + ) -> List[Trace[V]]: ... + + def process_batch( + self, + batch: Sequence, + *, + concurrency: Optional[int] = None, + unpack_arguments: bool = False, + do_not_persist_traces: bool = False, + ) -> List[Trace[V]]: + """Map the wrapped function over a list of input_values (`batch`). + + A wrapper over [parallel_map][great_ai.utilities.parallel_map.parallel_map.parallel_map] + providing type-safety and a progressbar through tqdm. + + Args: + batch: A list of arguments for the original (wrapped) function. If the + function expects multiple arguments, provide a list of tuples and set + `unpack_arguments=True`. + concurrency: Number of processes to start. Don't set it too much higher than + the number of available CPU cores. + unpack_arguments: Expect a list of tuples and unpack the tuples before + giving them to the wrapped function. + do_not_persist_traces: Don't save the traces in the database. Useful for + evaluations run part of the CI. + """ + + wrapped_function = self._wrapped_func + + def inner(value: Any) -> T: + return ( + wrapped_function(*value, do_not_persist_traces=do_not_persist_traces) + if unpack_arguments + else wrapped_function( + value, do_not_persist_traces=do_not_persist_traces + ) + ) + + async def inner_async(value: Any) -> T: + return await cast( + Awaitable, + ( + wrapped_function( + *value, do_not_persist_traces=do_not_persist_traces + ) + if unpack_arguments + else wrapped_function( + value, do_not_persist_traces=do_not_persist_traces + ) + ), + ) + + # inner/inner_async return the class' T (bound to Trace | Awaitable[Trace]); + # in this method T resolves to Trace[V], but that is not provable to mypy, so + # cast to the concrete shape parallel_map expects. + map_function = cast( + Callable[[Any], Union[Trace[V], Awaitable[Trace[V]]]], + inner_async if get_function_metadata_store(self).is_asynchronous else inner, + ) + + return list( + tqdm( + parallel_map(map_function, batch, concurrency=concurrency), + total=len(batch), + ) + ) + + @staticmethod + def _get_cached_traced_function( + func: Callable[..., Union[V, Awaitable[V]]], + ) -> Callable[..., T]: + @lru_cache(maxsize=get_context().prediction_cache_size) + def func_in_tracing_context_sync( + *args: Any, + do_not_persist_traces: bool = False, + **kwargs: Any, + ) -> T: + with TracingContext[V]( + func.__name__, do_not_persist_traces=do_not_persist_traces + ) as t: + result = func(*args, **kwargs) + return cast(T, t.finalise(output=result)) + + @alru_cache(maxsize=get_context().prediction_cache_size) + async def func_in_tracing_context_async( + *args: Any, + do_not_persist_traces: bool = False, + **kwargs: Any, + ) -> T: + with TracingContext[V]( + func.__name__, do_not_persist_traces=do_not_persist_traces + ) as t: + result = await cast(Callable[..., Awaitable], func)(*args, **kwargs) + return cast(T, t.finalise(output=result)) + + return cast( + Callable[..., T], + ( + func_in_tracing_context_async + if get_function_metadata_store(func).is_asynchronous + else func_in_tracing_context_sync + ), + ) + + def _bootstrap_rest_api( + self, + ) -> None: + route_config = get_context().route_config + + if route_config.prediction_endpoint_enabled: + bootstrap_prediction_endpoint(self.app, self._wrapped_func) + + if route_config.docs_endpoints_enabled: + bootstrap_docs_endpoints(self.app) + + if route_config.dashboard_enabled: + bootstrap_dashboard( + self.app, + function_name=self.__name__, + documentation=self.__doc__, + ) + + if route_config.trace_endpoints_enabled: + bootstrap_trace_endpoints(self.app) + + if route_config.feedback_endpoints_enabled: + bootstrap_feedback_endpoints(self.app) + + if route_config.meta_endpoints_enabled: + bootstrap_meta_endpoints( + self.app, + self._cached_func, + ApiMetadata( + name=self.__name__, + version=self.version, + documentation=self.__doc__, + configuration=get_context().to_flat_dict(), + ), + ) diff --git a/src/great_ai/great_ai/deploy/routes/__init__.py b/great_ai/deploy/routes/__init__.py similarity index 64% rename from src/great_ai/great_ai/deploy/routes/__init__.py rename to great_ai/deploy/routes/__init__.py index b5c2966..693155e 100644 --- a/src/great_ai/great_ai/deploy/routes/__init__.py +++ b/great_ai/deploy/routes/__init__.py @@ -1,4 +1,6 @@ from .bootstrap_dashboard import bootstrap_dashboard from .bootstrap_docs_endpoints import bootstrap_docs_endpoints from .bootstrap_feedback_endpoints import bootstrap_feedback_endpoints +from .bootstrap_meta_endpoints import bootstrap_meta_endpoints +from .bootstrap_prediction_endpoint import bootstrap_prediction_endpoint from .bootstrap_trace_endpoints import bootstrap_trace_endpoints diff --git a/great_ai/deploy/routes/bootstrap_dashboard.py b/great_ai/deploy/routes/bootstrap_dashboard.py new file mode 100644 index 0000000..6bafc5f --- /dev/null +++ b/great_ai/deploy/routes/bootstrap_dashboard.py @@ -0,0 +1,35 @@ +from pathlib import Path + +from a2wsgi import WSGIMiddleware +from fastapi import FastAPI +from fastapi.responses import FileResponse, RedirectResponse +from fastapi.staticfiles import StaticFiles + +from ...constants import DASHBOARD_PATH +from .dashboard.create_dash_app import create_dash_app + +PATH = Path(__file__).parent.resolve() + + +def bootstrap_dashboard(app: FastAPI, function_name: str, documentation: str) -> None: + dash_app = create_dash_app(function_name, app.version, documentation) + + @app.get("/favicon.ico", include_in_schema=False) + @app.get(f"{DASHBOARD_PATH}/_favicon.ico", include_in_schema=False) + def get_favicon() -> FileResponse: + return FileResponse(PATH / "dashboard/assets/favicon.ico") + + # a2wsgi types its WSGI input (Flask) and ASGI output more strictly than + # Starlette's loose WSGIApp/ASGIApp aliases, so mypy flags the mount despite + # this being the canonical, runtime-correct way to bridge the Dash app. + app.mount(DASHBOARD_PATH, WSGIMiddleware(dash_app)) # type: ignore[arg-type] + + @app.get("/", include_in_schema=False) + def redirect_to_entrypoint() -> RedirectResponse: + return RedirectResponse(DASHBOARD_PATH) + + app.mount( + "/assets", + StaticFiles(directory=PATH / "dashboard/assets"), + name="static", + ) diff --git a/src/great_ai/great_ai/deploy/routes/bootstrap_docs_endpoints.py b/great_ai/deploy/routes/bootstrap_docs_endpoints.py similarity index 74% rename from src/great_ai/great_ai/deploy/routes/bootstrap_docs_endpoints.py rename to great_ai/deploy/routes/bootstrap_docs_endpoints.py index 22fee23..efaaa37 100644 --- a/src/great_ai/great_ai/deploy/routes/bootstrap_docs_endpoints.py +++ b/great_ai/deploy/routes/bootstrap_docs_endpoints.py @@ -7,7 +7,11 @@ from starlette.responses import HTMLResponse def bootstrap_docs_endpoints(app: FastAPI) -> None: @app.get("/docs", include_in_schema=False) def custom_swagger_ui_html() -> HTMLResponse: - return get_swagger_ui_html(openapi_url="openapi.json", title=app.title) + return get_swagger_ui_html( + openapi_url="openapi.json", + title=app.title, + swagger_favicon_url="/favicon.ico", + ) @app.get("/docs/index.html", include_in_schema=False) def redirect_to_docs() -> RedirectResponse: diff --git a/src/great_ai/great_ai/deploy/routes/bootstrap_feedback_endpoints.py b/great_ai/deploy/routes/bootstrap_feedback_endpoints.py similarity index 96% rename from src/great_ai/great_ai/deploy/routes/bootstrap_feedback_endpoints.py rename to great_ai/deploy/routes/bootstrap_feedback_endpoints.py index 8b219ee..b14df7e 100644 --- a/src/great_ai/great_ai/deploy/routes/bootstrap_feedback_endpoints.py +++ b/great_ai/deploy/routes/bootstrap_feedback_endpoints.py @@ -31,7 +31,7 @@ def bootstrap_feedback_endpoints(app: FastAPI) -> None: return trace.feedback @router.delete("/", status_code=status.HTTP_204_NO_CONTENT) - def delete_feedback(trace_id: str) -> Any: + def delete_feedback(trace_id: str) -> Response: trace = get_context().tracing_database.get(trace_id) if trace is None: raise HTTPException(status_code=status.HTTP_404_NOT_FOUND) diff --git a/great_ai/deploy/routes/bootstrap_meta_endpoints.py b/great_ai/deploy/routes/bootstrap_meta_endpoints.py new file mode 100644 index 0000000..d419c0b --- /dev/null +++ b/great_ai/deploy/routes/bootstrap_meta_endpoints.py @@ -0,0 +1,26 @@ +from typing import Any + +from fastapi import APIRouter, FastAPI, status + +from ...views import ApiMetadata, CacheStatistics, HealthCheckResponse + + +def bootstrap_meta_endpoints(app: FastAPI, func: Any, metadata: ApiMetadata) -> None: + router = APIRouter( + tags=["meta"], + ) + + @router.get("/health", status_code=status.HTTP_200_OK) + def check_health() -> HealthCheckResponse: + hits, misses, maxsize, cache_size = func.cache_info() + cache_statistics = CacheStatistics( + hits=hits, misses=misses, size=cache_size, max_size=maxsize + ) + + return HealthCheckResponse(is_healthy=True, cache_statistics=cache_statistics) + + @router.get("/version", response_model=ApiMetadata, status_code=status.HTTP_200_OK) + def get_version() -> ApiMetadata: + return metadata + + app.include_router(router) diff --git a/great_ai/deploy/routes/bootstrap_prediction_endpoint.py b/great_ai/deploy/routes/bootstrap_prediction_endpoint.py new file mode 100644 index 0000000..b3787ec --- /dev/null +++ b/great_ai/deploy/routes/bootstrap_prediction_endpoint.py @@ -0,0 +1,51 @@ +import inspect +from typing import Any, Awaitable, Callable, Type, Union, cast + +from fastapi import APIRouter, FastAPI, HTTPException, status +from pydantic import BaseModel, create_model + +from ...helper import get_function_metadata_store +from ...views import Trace + + +def bootstrap_prediction_endpoint( + app: FastAPI, func: Callable[..., Union[Trace, Awaitable[Trace]]] +) -> None: + router = APIRouter( + tags=["predictions"], + ) + + schema = _get_schema(func) + + @router.post("/predict", status_code=status.HTTP_200_OK, response_model=Trace) + async def predict(input_value: schema) -> Trace: # type: ignore + try: + if inspect.iscoroutinefunction(func): + return await cast(Callable[..., Awaitable[Trace]], func)( + **cast(BaseModel, input_value).model_dump() + ) + return cast(Callable[..., Trace], func)( + **cast(BaseModel, input_value).model_dump() + ) + except Exception as e: + raise HTTPException( + status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, + detail=f"The following exception has occurred: {type(e).__name__}: {e}", + ) + + app.include_router(router) + + +def _get_schema(func: Callable) -> Type[BaseModel]: + signature = inspect.signature(func) + parameters = { + p.name: ( + p.annotation if p.annotation != inspect._empty else Any, + p.default if p.default != inspect._empty else ..., + ) + for p in signature.parameters.values() + if p.name in get_function_metadata_store(func).input_parameter_names + } + + schema: Type[BaseModel] = create_model("InputModel", **parameters) # type: ignore + return schema diff --git a/src/great_ai/great_ai/deploy/routes/bootstrap_trace_endpoints.py b/great_ai/deploy/routes/bootstrap_trace_endpoints.py similarity index 94% rename from src/great_ai/great_ai/deploy/routes/bootstrap_trace_endpoints.py rename to great_ai/deploy/routes/bootstrap_trace_endpoints.py index 7c951a7..e690c75 100644 --- a/src/great_ai/great_ai/deploy/routes/bootstrap_trace_endpoints.py +++ b/great_ai/deploy/routes/bootstrap_trace_endpoints.py @@ -12,7 +12,7 @@ def bootstrap_trace_endpoints(app: FastAPI) -> None: tags=["traces"], ) - @router.post("/", status_code=status.HTTP_200_OK, response_model=List[Trace]) + @router.post("", status_code=status.HTTP_200_OK, response_model=List[Trace]) def query_traces( query: Query, skip: int = 0, diff --git a/src/great_ai/great_ai/deploy/routes/dashboard/__init__.py b/great_ai/deploy/routes/dashboard/__init__.py similarity index 100% rename from src/great_ai/great_ai/deploy/routes/dashboard/__init__.py rename to great_ai/deploy/routes/dashboard/__init__.py diff --git a/great_ai/deploy/routes/dashboard/assets/favicon.ico b/great_ai/deploy/routes/dashboard/assets/favicon.ico new file mode 100644 index 0000000..d0a6efa Binary files /dev/null and b/great_ai/deploy/routes/dashboard/assets/favicon.ico differ diff --git a/src/great_ai/great_ai/deploy/routes/dashboard/assets/index.css b/great_ai/deploy/routes/dashboard/assets/index.css similarity index 88% rename from src/great_ai/great_ai/deploy/routes/dashboard/assets/index.css rename to great_ai/deploy/routes/dashboard/assets/index.css index 5f500f9..e730d06 100644 --- a/src/great_ai/great_ai/deploy/routes/dashboard/assets/index.css +++ b/great_ai/deploy/routes/dashboard/assets/index.css @@ -1,6 +1,7 @@ :root { - --important-color: #a30808; --background-color: #edf5f6; + --dark-background-color: #e7eced; + --light-text-color: #747879; --small-padding: 10px; --medium-padding: 20px; --large-padding: 40px; @@ -84,7 +85,6 @@ main { } .environment { - background-color: var(--important-color); color: white; text-align: center; display: flex; @@ -129,6 +129,19 @@ main > header > div > h1 { margin-top: 0; } +.version-tag { + border-radius: var(--border-radius); + display: inline-block; + font-size: 1rem; + padding: 3px 8px; + margin-left: var(--small-padding) +} + +main > header .version-tag { + background: var(--background-color); + vertical-align: 4px; +} + main > header > *:nth-child(2) { min-width: 250px; max-width: 550px; @@ -136,7 +149,7 @@ main > header > *:nth-child(2) { } main > header .placeholder { - opacity: 0.35; + color: var(--light-text-color); font-size: 1.5rem; text-align: center; display: block; @@ -152,7 +165,6 @@ main > header .placeholder { } .configuration-item { - border-left: 2px solid var(--important-color); padding-left: var(--small-padding); margin: var(--medium-padding); } @@ -194,17 +206,13 @@ main > header .placeholder { flex-grow: 1; } -main > footer { - opacity: 0.35; - margin: 0; -} - main > footer { display: flex; justify-content: space-between; align-items: center; padding: var(--large-padding); - background-color: #ddd; + background-color: var(--dark-background-color); + color: var(--light-text-color); position: relative; } @@ -215,10 +223,11 @@ main > footer { a img { display: block; margin-left: var(--large-padding); - width: 64px; - height: 64px; + width: 80px; + height: 80px; cursor: pointer; transition: transform 300ms; + opacity: 0.6; } a img:hover { diff --git a/great_ai/deploy/routes/dashboard/assets/logo.png b/great_ai/deploy/routes/dashboard/assets/logo.png new file mode 100644 index 0000000..b5dbe98 Binary files /dev/null and b/great_ai/deploy/routes/dashboard/assets/logo.png differ diff --git a/great_ai/deploy/routes/dashboard/assets/logo.svg b/great_ai/deploy/routes/dashboard/assets/logo.svg new file mode 100644 index 0000000..326be6e --- /dev/null +++ b/great_ai/deploy/routes/dashboard/assets/logo.svg @@ -0,0 +1,34 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + AI + \ No newline at end of file diff --git a/src/great_ai/great_ai/deploy/routes/dashboard/create_dash_app.py b/great_ai/deploy/routes/dashboard/create_dash_app.py similarity index 64% rename from src/great_ai/great_ai/deploy/routes/dashboard/create_dash_app.py rename to great_ai/deploy/routes/dashboard/create_dash_app.py index d7d65d6..e76ab98 100644 --- a/src/great_ai/great_ai/deploy/routes/dashboard/create_dash_app.py +++ b/great_ai/deploy/routes/dashboard/create_dash_app.py @@ -8,10 +8,10 @@ from dash import Dash, dcc, html from dash.dependencies import Input, Output from flask import Flask -from .....utilities import unique from ....constants import DASHBOARD_PATH, ONLINE_TAG_NAME from ....context import get_context -from ....helper import snake_case_to_text, text_to_hex_color +from ....helper import freeze, snake_case_to_text, text_to_hex_color +from ....utilities import unique from ....views import SortBy, Trace from .get_description import get_description from .get_filter_from_datatable import get_filter_from_datatable @@ -19,66 +19,80 @@ from .get_footer import get_footer from .get_traces_table import get_traces_table -def create_dash_app(function_name: str, function_docs: str) -> Flask: +def create_dash_app(function_name: str, version: str, function_docs: str) -> Flask: accent_color = text_to_hex_color(function_name) + function_name = snake_case_to_text(function_name) app = Dash( function_name, requests_pathname_prefix=DASHBOARD_PATH + "/", - server=Flask(__name__), - title=snake_case_to_text(function_name), - update_title=None, + server=Flask(__name__), # type: ignore[arg-type] + title=function_name, + update_title=None, # type: ignore[arg-type] external_stylesheets=[ "/assets/index.css", ], ) + execution_time_histogram_container = html.Div() + configuration_container = html.Div( + className="configuration-container", + ) + table = get_traces_table() + traces_table_container = html.Div( + [ + html.Header( + [ + html.H2("Latest traces"), + html.P( + "Recent traces and aggregated metrics are presented below. Try filtering the table." + ), + html.A( + "Filtering syntax.", + href="https://dash.plotly.com/datatable/filtering", + target="_blank", + ), + ] + ), + table, + ], + className="traces-table-container", + ) + parallel_coordinates = dcc.Graph( + className="parallel-coordinates", config={"displaylogo": False} + ) + interval = dcc.Interval( + interval=2 * 1000, # in milliseconds + n_intervals=0, + max_intervals=( + 1 if get_context().is_production else -1 + ), # will be incremented in production upon each successful request + ) + app.layout = html.Main( [ html.Div( html.P("PRODUCTION" if get_context().is_production else "DEVELOPMENT"), className="environment", + style={"background": accent_color}, ), html.Header( [ get_description( function_name=function_name, + version=version, function_docs=function_docs, accent_color=accent_color, ), - execution_time_histogram_container := html.Div(), + execution_time_histogram_container, ], ), - configuration_container := html.Div( - className="configuration-container", - ), - traces_table_container := html.Div( - [ - html.Header( - [ - html.H2("Latest traces"), - html.P( - "Recent traces and aggregated metrics are presented below. Try filtering the table." - ), - html.A( - "Filtering syntax.", - href="https://dash.plotly.com/datatable/filtering", - target="_blank", - ), - ] - ), - table := get_traces_table(), - ], - className="traces-table-container", - ), - parallel_coordinates := dcc.Graph( - className="parallel-coordinates", config={"displaylogo": False} - ), + configuration_container, + traces_table_container, + parallel_coordinates, html.Div(className="space-filler"), get_footer(), - interval := dcc.Interval( - interval=4 * 1000, # in milliseconds - ), + interval, ] ) @@ -97,6 +111,7 @@ def create_dash_app(function_name: str, function_docs: str) -> Flask: html.P(str(value)), ], className="configuration-item", + style={"border-left": f"2px solid {accent_color}"}, ) for key, value in config.items() ] @@ -109,6 +124,7 @@ def create_dash_app(function_name: str, function_docs: str) -> Flask: Output(execution_time_histogram_container, "children"), Output(parallel_coordinates, "figure"), Output(parallel_coordinates, "style"), + Output(interval, "max_intervals"), Input(table, "page_current"), Input(table, "page_size"), Input(table, "sort_by"), @@ -120,7 +136,7 @@ def create_dash_app(function_name: str, function_docs: str) -> Flask: page_size: int, sort_by: List[Dict[str, Union[str, int]]], filter_query: str, - n_intervals: int, + n_intervals: Optional[int], ) -> Tuple[ List[Dict[str, Any]], int, @@ -129,6 +145,7 @@ def create_dash_app(function_name: str, function_docs: str) -> Flask: Any, go.Figure, Dict[str, Any], + int, ]: conjunctive_filters = ( [get_filter_from_datatable(f) for f in filter_query.split(" && ")] @@ -142,22 +159,33 @@ def create_dash_app(function_name: str, function_docs: str) -> Flask: take=page_size, conjunctive_filters=non_null_conjunctive_filters, conjunctive_tags=[ONLINE_TAG_NAME], - sort_by=[SortBy.parse_obj(s) for s in sort_by], + sort_by=[SortBy.model_validate(s) for s in sort_by], ) - columns, style = update_layout(elements[0] if elements else None) - execution_time_histogram, parallel_coords_fig, style = update_charts( - elements=elements, function_name=function_name, accent_color=accent_color + if non_null_conjunctive_filters: + all_elements, _ = get_context().tracing_database.query( + take=1, conjunctive_tags=[ONLINE_TAG_NAME] + ) + else: + all_elements = elements + + columns, style = update_layout(all_elements[0] if all_elements else None) + execution_time_histogram, parallel_coords_fig, parallel_style = update_charts( + elements=elements, accent_color=accent_color ) return ( - [e.to_flat_dict(include_original=False) for e in elements], + [ + {k: str(v) for k, v in e.to_flat_dict(include_original=False).items()} + for e in elements + ], max(1, ceil(count / page_size)), columns, style, execution_time_histogram, parallel_coords_fig, - style, + parallel_style, + ((n_intervals or 0) + 1) if get_context().is_production else -1, ) return app.server @@ -188,12 +216,12 @@ def update_layout( def update_charts( - elements: List[Trace], function_name: str, accent_color: str + elements: List[Trace], accent_color: str ) -> Tuple[Any, go.Figure, Dict[str, Any]]: if not elements: return ( html.Span( - f"No traces yet: call your function ({function_name}) to create one.", + "No matching traces.", className="placeholder", ), go.Figure(), @@ -216,7 +244,7 @@ def update_charts( fig.update_layout( margin=dict(l=0, r=0, b=0, t=0, pad=0), ) - execution_time_histogram.figure = fig + execution_time_histogram.figure = fig # type: ignore[attr-defined] parallel_coords_fig = go.Figure( go.Parcoords( @@ -243,11 +271,11 @@ def get_dimension_descriptor(df: pd.DataFrame, column: str) -> Dict[str, Any]: dimension["values"] = [float(v) for v in values] except (TypeError, ValueError): MAX_LENGTH = 40 - unique_values = unique(values) - value_mapping = {str(v)[-MAX_LENGTH:]: i for i, v in enumerate(unique_values)} + unique_values = unique(values, key=freeze) + value_mapping = {str(v)[:MAX_LENGTH]: i for i, v in enumerate(unique_values)} - dimension["values"] = [value_mapping[str(v)[-MAX_LENGTH:]] for v in values] + dimension["values"] = [value_mapping[str(v)[:MAX_LENGTH]] for v in values] dimension["tickvals"] = list(value_mapping.values()) - dimension["ticktext"] = [k[-MAX_LENGTH:] for k in value_mapping.keys()] + dimension["ticktext"] = [k[:MAX_LENGTH] for k in value_mapping.keys()] return dimension diff --git a/great_ai/deploy/routes/dashboard/get_description.py b/great_ai/deploy/routes/dashboard/get_description.py new file mode 100644 index 0000000..8982f24 --- /dev/null +++ b/great_ai/deploy/routes/dashboard/get_description.py @@ -0,0 +1,35 @@ +from dash import dcc, html + +from ....helper import snake_case_to_text, strip_lines + + +def get_description( + function_name: str, version: str, function_docs: str, accent_color: str +) -> html.Div: + return html.Div( + [ + html.H1( + [ + f"{snake_case_to_text(function_name)} - dashboard", + html.Span(version, className="version-tag"), + ], + style={"color": accent_color}, + ), + dcc.Markdown( + strip_lines( + f""" + > View the live data of your deployment here. + + ## Using the API + + You can find the available endpoints at [/docs](/docs). + + ## Details + + {function_docs} + """ + ), + className="description", + ), + ] + ) diff --git a/src/great_ai/great_ai/deploy/routes/dashboard/get_filter_from_datatable.py b/great_ai/deploy/routes/dashboard/get_filter_from_datatable.py similarity index 100% rename from src/great_ai/great_ai/deploy/routes/dashboard/get_filter_from_datatable.py rename to great_ai/deploy/routes/dashboard/get_filter_from_datatable.py diff --git a/src/great_ai/great_ai/deploy/routes/dashboard/get_footer.py b/great_ai/deploy/routes/dashboard/get_footer.py similarity index 67% rename from src/great_ai/great_ai/deploy/routes/dashboard/get_footer.py rename to great_ai/deploy/routes/dashboard/get_footer.py index e6c2fe4..bdd6d48 100644 --- a/src/great_ai/great_ai/deploy/routes/dashboard/get_footer.py +++ b/great_ai/deploy/routes/dashboard/get_footer.py @@ -1,5 +1,7 @@ from dash import html +from great_ai import __version__ + from ....constants import GITHUB_LINK @@ -8,14 +10,16 @@ def get_footer() -> html.Footer: [ html.Div( [ - html.H6("GreatAI"), + html.H6( + ["GreatAI", html.Span(__version__, className="version-tag")] + ), html.P( "A human-friendly framework for robust end-to-end AI deployments." ), ] ), html.A( - html.Img(src="/assets/github.png"), + html.Img(src="/assets/logo.png"), href=GITHUB_LINK, target="_blank", ), diff --git a/src/great_ai/great_ai/deploy/routes/dashboard/get_traces_table.py b/great_ai/deploy/routes/dashboard/get_traces_table.py similarity index 75% rename from src/great_ai/great_ai/deploy/routes/dashboard/get_traces_table.py rename to great_ai/deploy/routes/dashboard/get_traces_table.py index 9b51761..1550f48 100644 --- a/src/great_ai/great_ai/deploy/routes/dashboard/get_traces_table.py +++ b/great_ai/deploy/routes/dashboard/get_traces_table.py @@ -1,10 +1,12 @@ +from typing import Any + from dash import dash_table from ....context import get_context -def get_traces_table() -> dash_table.DataTable: - return dash_table.DataTable( +def get_traces_table() -> Any: + return dash_table.DataTable( # type: ignore[attr-defined] page_current=0, page_size=get_context().dashboard_table_size, page_action="custom", @@ -18,8 +20,8 @@ def get_traces_table() -> dash_table.DataTable: "white-space": "normal", "height": "auto", "max-height": "300px", + "max-width": "500px", "overflow": "hidden", - "text-overflow": "ellipsis", }, style_cell={"padding": "5px"}, style_header={ @@ -27,7 +29,5 @@ def get_traces_table() -> dash_table.DataTable: "font-weight": "bold", }, merge_duplicate_headers=True, - style_cell_conditional=[ - {"if": {"column_id": "output"}, "width": 1500}, - ], + style_table={"overflow": "auto", "max-height": "80vh"}, ) diff --git a/src/great_ai/great_ai/exceptions/__init__.py b/great_ai/errors/__init__.py similarity index 51% rename from src/great_ai/great_ai/exceptions/__init__.py rename to great_ai/errors/__init__.py index 037b1aa..b4d64ed 100644 --- a/src/great_ai/great_ai/exceptions/__init__.py +++ b/great_ai/errors/__init__.py @@ -1,2 +1,4 @@ from .argument_validation_error import ArgumentValidationError from .missing_argument_error import MissingArgumentError +from .remote_call_error import RemoteCallError +from .wrong_decorator_order_error import WrongDecoratorOrderError diff --git a/src/great_ai/great_ai/exceptions/argument_validation_error.py b/great_ai/errors/argument_validation_error.py similarity index 100% rename from src/great_ai/great_ai/exceptions/argument_validation_error.py rename to great_ai/errors/argument_validation_error.py diff --git a/src/great_ai/great_ai/exceptions/missing_argument_error.py b/great_ai/errors/missing_argument_error.py similarity index 100% rename from src/great_ai/great_ai/exceptions/missing_argument_error.py rename to great_ai/errors/missing_argument_error.py diff --git a/src/great_ai/great_ai/remote/remote_call_error.py b/great_ai/errors/remote_call_error.py similarity index 100% rename from src/great_ai/great_ai/remote/remote_call_error.py rename to great_ai/errors/remote_call_error.py diff --git a/great_ai/errors/wrong_decorator_order_error.py b/great_ai/errors/wrong_decorator_order_error.py new file mode 100644 index 0000000..ca9864c --- /dev/null +++ b/great_ai/errors/wrong_decorator_order_error.py @@ -0,0 +1,2 @@ +class WrongDecoratorOrderError(Exception): + pass diff --git a/src/__init__.py b/great_ai/external/__init__.py similarity index 100% rename from src/__init__.py rename to great_ai/external/__init__.py diff --git a/great_ai/external/async_lru.py b/great_ai/external/async_lru.py new file mode 100644 index 0000000..c209d5a --- /dev/null +++ b/great_ai/external/async_lru.py @@ -0,0 +1,192 @@ +import asyncio +from collections import OrderedDict +from functools import _CacheInfo, _make_key, partial, wraps + +__version__ = "1.0.3" + +__all__ = ("alru_cache",) + + +def unpartial(fn): + while hasattr(fn, "func"): + fn = fn.func + + return fn + + +def _done_callback(fut, task): + if task.cancelled(): + fut.cancel() + return + + exc = task.exception() + if exc is not None: + fut.set_exception(exc) + return + + fut.set_result(task.result()) + + +def _cache_invalidate(wrapped, typed, *args, **kwargs): + key = _make_key(args, kwargs, typed) + + exists = key in wrapped._cache + + if exists: + wrapped._cache.pop(key) + + return exists + + +def _cache_clear(wrapped): + wrapped.hits = wrapped.misses = 0 + wrapped._cache = OrderedDict() + wrapped.tasks = set() + + +def _open(wrapped): + if not wrapped.closed: + raise RuntimeError("alru_cache is not closed") + + was_closed = ( + wrapped.hits == wrapped.misses == len(wrapped.tasks) == len(wrapped._cache) == 0 + ) + + if not was_closed: + raise RuntimeError("alru_cache was not closed correctly") + + wrapped.closed = False + + +def _close(wrapped, *, cancel=False, return_exceptions=True): + if wrapped.closed: + raise RuntimeError("alru_cache is closed") + + wrapped.closed = True + + if cancel: + for task in wrapped.tasks: + if not task.done(): # not sure is it possible + task.cancel() + + return _wait_closed(wrapped, return_exceptions=return_exceptions) + + +async def _wait_closed(wrapped, *, return_exceptions): + wait_closed = asyncio.gather(*wrapped.tasks, return_exceptions=return_exceptions) + + wait_closed.add_done_callback(partial(_close_waited, wrapped)) + + ret = await wait_closed + + # hack to get _close_waited callback to be executed + await asyncio.sleep(0) + + return ret + + +def _close_waited(wrapped, _): + wrapped.cache_clear() + + +def _cache_info(wrapped, maxsize): + return _CacheInfo( + wrapped.hits, + wrapped.misses, + maxsize, + len(wrapped._cache), + ) + + +def __cache_touch(wrapped, key): + try: + wrapped._cache.move_to_end(key) + except KeyError: # not sure is it possible + pass + + +def _cache_hit(wrapped, key): + wrapped.hits += 1 + __cache_touch(wrapped, key) + + +def _cache_miss(wrapped, key): + wrapped.misses += 1 + __cache_touch(wrapped, key) + + +def alru_cache( + fn=None, + maxsize=128, + typed=False, + *, + cache_exceptions=True, +): + def wrapper(fn): + _origin = unpartial(fn) + + if not asyncio.iscoroutinefunction(_origin): + raise RuntimeError("Coroutine function is required, got {}".format(fn)) + + # functools.partialmethod support + if hasattr(fn, "_make_unbound_method"): + fn = fn._make_unbound_method() + + @wraps(fn) + async def wrapped(*fn_args, **fn_kwargs): + if wrapped.closed: + raise RuntimeError("alru_cache is closed for {}".format(wrapped)) + + loop = asyncio.get_event_loop() + + key = _make_key(fn_args, fn_kwargs, typed) + + fut = wrapped._cache.get(key) + + if fut is not None: + if not fut.done(): + _cache_hit(wrapped, key) + return await asyncio.shield(fut) + + exc = fut._exception + + if exc is None or cache_exceptions: + _cache_hit(wrapped, key) + return fut.result() + + # exception here and cache_exceptions == False + wrapped._cache.pop(key) + + fut = loop.create_future() + task = loop.create_task(fn(*fn_args, **fn_kwargs)) + task.add_done_callback(partial(_done_callback, fut)) + + wrapped.tasks.add(task) + task.add_done_callback(wrapped.tasks.remove) + + wrapped._cache[key] = fut + + if maxsize is not None and len(wrapped._cache) > maxsize: + wrapped._cache.popitem(last=False) + + _cache_miss(wrapped, key) + return await asyncio.shield(fut) + + _cache_clear(wrapped) + wrapped._origin = _origin + wrapped.closed = False + wrapped.cache_info = partial(_cache_info, wrapped, maxsize) + wrapped.cache_clear = partial(_cache_clear, wrapped) + wrapped.invalidate = partial(_cache_invalidate, wrapped, typed) + wrapped.close = partial(_close, wrapped) + wrapped.open = partial(_open, wrapped) + + return wrapped + + if fn is None: + return wrapper + + if callable(fn) or hasattr(fn, "_make_unbound_method"): + return wrapper(fn) + + raise NotImplementedError("{} decorating is not supported".format(fn)) diff --git a/src/great_ai/great_ai/helper/__init__.py b/great_ai/helper/__init__.py similarity index 62% rename from src/great_ai/great_ai/helper/__init__.py rename to great_ai/helper/__init__.py index a76ce3d..8f29d76 100644 --- a/src/great_ai/great_ai/helper/__init__.py +++ b/great_ai/helper/__init__.py @@ -1,8 +1,6 @@ -from .freeze_arguments import freeze_arguments +from .freeze_arguments import freeze, freeze_arguments from .get_arguments import get_arguments from .get_function_metadata_store import get_function_metadata_store -from .hashable_base_model import HashableBaseModel from .snake_case_to_text import snake_case_to_text from .strip_lines import strip_lines from .text_to_hex_color import text_to_hex_color -from .use_http_exceptions import use_http_exceptions diff --git a/great_ai/helper/assert_function_is_not_finalised.py b/great_ai/helper/assert_function_is_not_finalised.py new file mode 100644 index 0000000..0d6f950 --- /dev/null +++ b/great_ai/helper/assert_function_is_not_finalised.py @@ -0,0 +1,14 @@ +from typing import Callable + +from ..errors import WrongDecoratorOrderError +from .get_function_metadata_store import get_function_metadata_store + + +def assert_function_is_not_finalised(func: Callable) -> None: + error_message = ( + "The outer-most (first) decorator has to be `@GreatAI.create`. " + + f"In the case of `{func.__name__}`, it is not: fix this by moving `@GreatAI.create` to the top." + ) + + if get_function_metadata_store(func).is_finalised: + raise WrongDecoratorOrderError(error_message) diff --git a/great_ai/helper/freeze_arguments.py b/great_ai/helper/freeze_arguments.py new file mode 100644 index 0000000..e6ff56f --- /dev/null +++ b/great_ai/helper/freeze_arguments.py @@ -0,0 +1,72 @@ +import inspect +from functools import lru_cache, wraps +from typing import Any, Callable, Mapping, Sequence, Set, Type, TypeVar, Union, cast + +from pydantic import BaseModel + +F = TypeVar("F", bound=Callable) + + +@lru_cache(maxsize=None) +def _hashable_model_type(model_type: Type[BaseModel]) -> Type[BaseModel]: + # The subclass is cached per model type: Pydantic v2's __eq__ requires both + # operands to share a type, so creating a fresh subclass on every freeze() + # call would make even identical models compare unequal. + class HashableValue(model_type): # type: ignore + def __hash__(self) -> int: + return hash(frozenset((k, freeze(v)) for k, v in self.model_dump().items())) + + return HashableValue + + +class FrozenDict(dict): + def __hash__(self) -> int: # type: ignore + return hash(frozenset((k, freeze(v)) for k, v in self.items())) + + +class FrozenList(list): + def __hash__(self) -> int: # type: ignore + return hash(tuple(freeze(i) for i in self)) + + +class FrozenSet(set): + def __hash__(self) -> int: # type: ignore + return hash(frozenset(freeze(i) for i in self)) + + +def freeze_arguments(func: F) -> F: + @wraps(func) + def wrapper(*args: Any, **kwargs: Any) -> Any: + args = tuple(freeze(arg) for arg in args) + kwargs = {k: freeze(v) for k, v in kwargs.items()} + return func(*args, **kwargs) + + @wraps(func) + async def async_wrapper(*args: Any, **kwargs: Any) -> Any: + return await wrapper(*args, **kwargs) + + return cast(F, async_wrapper if inspect.iscoroutinefunction(func) else wrapper) + + +def freeze(value: Union[Sequence[Any], Mapping[str, Any], Set[Any], BaseModel]) -> Any: + """ + >>> class MyClass(BaseModel): + ... a: int + >>> my_object = MyClass(a=3) + >>> my_other_object = MyClass(a=4) + >>> freeze(my_object) == freeze(my_other_object), freeze(my_object) == freeze(my_object) + (False, True) + """ + if isinstance(value, dict): + return FrozenDict(value) + + if isinstance(value, list): + return FrozenList(value) + + if isinstance(value, set): + return FrozenSet(value) + + if isinstance(value, BaseModel): + return _hashable_model_type(type(value))(**value.model_dump()) + + return value diff --git a/src/great_ai/great_ai/helper/get_arguments.py b/great_ai/helper/get_arguments.py similarity index 87% rename from src/great_ai/great_ai/helper/get_arguments.py rename to great_ai/helper/get_arguments.py index 91fb44c..af575d1 100644 --- a/src/great_ai/great_ai/helper/get_arguments.py +++ b/great_ai/helper/get_arguments.py @@ -3,9 +3,9 @@ from typing import Any, Callable, Dict, Mapping, Sequence def get_arguments( - func: Callable[..., Any], args: Sequence[Any], kwargs: Mapping[str, Any] + func: Callable, args: Sequence[Any], kwargs: Mapping[str, Any] ) -> Dict[str, Any]: - """Return mapping from parameter names to actual argument values""" + """Return mapping from parameter names to actual argument values.""" signature = inspect.signature(func) diff --git a/great_ai/helper/get_function_metadata_store.py b/great_ai/helper/get_function_metadata_store.py new file mode 100644 index 0000000..5f35be3 --- /dev/null +++ b/great_ai/helper/get_function_metadata_store.py @@ -0,0 +1,14 @@ +import inspect +from typing import Any, Callable, cast + +from ..views.function_metadata import FunctionMetadata + + +def get_function_metadata_store(func: Callable) -> FunctionMetadata: + any_func = cast(Any, func) + + if not hasattr(any_func, "_great_ai_metadata"): + is_asynchronous = inspect.iscoroutinefunction(func) + any_func._great_ai_metadata = FunctionMetadata(is_asynchronous=is_asynchronous) + + return any_func._great_ai_metadata diff --git a/src/great_ai/great_ai/helper/snake_case_to_text.py b/great_ai/helper/snake_case_to_text.py similarity index 100% rename from src/great_ai/great_ai/helper/snake_case_to_text.py rename to great_ai/helper/snake_case_to_text.py diff --git a/src/great_ai/great_ai/helper/strip_lines.py b/great_ai/helper/strip_lines.py similarity index 100% rename from src/great_ai/great_ai/helper/strip_lines.py rename to great_ai/helper/strip_lines.py diff --git a/src/great_ai/great_ai/helper/text_to_hex_color.py b/great_ai/helper/text_to_hex_color.py similarity index 88% rename from src/great_ai/great_ai/helper/text_to_hex_color.py rename to great_ai/helper/text_to_hex_color.py index e906a0c..62acb98 100644 --- a/src/great_ai/great_ai/helper/text_to_hex_color.py +++ b/great_ai/helper/text_to_hex_color.py @@ -4,10 +4,14 @@ from hashlib import md5 def text_to_hex_color(text: str) -> str: ascii_bytes = text.encode("ascii") + digest = md5( ascii_bytes ).hexdigest() # the built-in hash function is salted differently in each process + integer = int(digest, 16) hue = integer % 6311 / 6311.0 - rgb = colorsys.hsv_to_rgb(hue, 0.75, 0.6) + + rgb = colorsys.hsv_to_rgb(hue, 0.8, 0.6) + return "#" + "".join("%02X" % round(i * 255) for i in rgb) diff --git a/great_ai/large_file/__init__.py b/great_ai/large_file/__init__.py new file mode 100644 index 0000000..96df5cb --- /dev/null +++ b/great_ai/large_file/__init__.py @@ -0,0 +1,4 @@ +from .large_file.large_file_base import LargeFileBase +from .large_file.large_file_local import LargeFileLocal +from .large_file.large_file_mongo import LargeFileMongo +from .large_file.large_file_s3 import LargeFileS3 diff --git a/src/great_ai/large_file/__main__.py b/great_ai/large_file/__main__.py similarity index 87% rename from src/great_ai/large_file/__main__.py rename to great_ai/large_file/__main__.py index ed3bc14..2e804a6 100644 --- a/src/great_ai/large_file/__main__.py +++ b/great_ai/large_file/__main__.py @@ -5,13 +5,13 @@ from pathlib import Path from typing import Mapping, Type from ..utilities import get_logger -from .large_file import LargeFile, LargeFileLocal, LargeFileMongo, LargeFileS3 +from . import LargeFileBase, LargeFileLocal, LargeFileMongo, LargeFileS3 from .parse_arguments import parse_arguments logger = get_logger("large_file") -def main() -> None: +def handle_command() -> None: parser, args = parse_arguments() large_file = get_class(args) @@ -37,8 +37,8 @@ def main() -> None: large_file(f).delete() -def get_class(args: Namespace) -> Type[LargeFile]: - factory: Mapping[str, Type[LargeFile]] = { +def get_class(args: Namespace) -> Type[LargeFileBase]: + factory: Mapping[str, Type[LargeFileBase]] = { "s3": LargeFileS3, "local": LargeFileLocal, "mongodb": LargeFileMongo, @@ -61,11 +61,15 @@ def get_class(args: Namespace) -> Type[LargeFile]: return large_file -if __name__ == "__main__": +def main() -> None: try: - main() + handle_command() except KeyboardInterrupt: logger.warning("Exiting") exit() except Exception as e: logger.exception(e) + + +if __name__ == "__main__": + main() diff --git a/src/great_ai/large_file/helper/__init__.py b/great_ai/large_file/helper/__init__.py similarity index 73% rename from src/great_ai/large_file/helper/__init__.py rename to great_ai/large_file/helper/__init__.py index 9639296..5eb33e8 100644 --- a/src/great_ai/large_file/helper/__init__.py +++ b/great_ai/large_file/helper/__init__.py @@ -1,2 +1,3 @@ +from .cached_property import cached_property from .human_readable_to_byte import human_readable_to_byte from .progress_bar import DownloadProgressBar, UploadProgressBar diff --git a/src/great_ai/large_file/helper/bytes_to_megabytes.py b/great_ai/large_file/helper/bytes_to_megabytes.py similarity index 100% rename from src/great_ai/large_file/helper/bytes_to_megabytes.py rename to great_ai/large_file/helper/bytes_to_megabytes.py diff --git a/great_ai/large_file/helper/cached_property.py b/great_ai/large_file/helper/cached_property.py new file mode 100644 index 0000000..d141d3c --- /dev/null +++ b/great_ai/large_file/helper/cached_property.py @@ -0,0 +1,54 @@ +from threading import RLock + +_NOT_FOUND = object() + + +class cached_property: + def __init__(self, func): # type: ignore + self.func = func + self.attrname = None + self.__doc__ = func.__doc__ + self.lock = RLock() + + def __set_name__(self, owner, name): # type: ignore + if self.attrname is None: + self.attrname = name + elif name != self.attrname: + raise TypeError( + "Cannot assign the same cached_property to two different names " + f"({self.attrname!r} and {name!r})." + ) + + def __get__(self, instance, owner=None): # type: ignore + if instance is None: + return self + if self.attrname is None: + raise TypeError( + "Cannot use cached_property instance without calling __set_name__ on it." + ) + try: + cache = instance.__dict__ + except ( + AttributeError + ): # not all objects have __dict__ (e.g. class defines slots) + msg = ( + f"No '__dict__' attribute on {type(instance).__name__!r} " + f"instance to cache {self.attrname!r} property." + ) + raise TypeError(msg) from None + val = cache.get(self.attrname, _NOT_FOUND) + if val is _NOT_FOUND: + with self.lock: + # check if another thread filled cache while we awaited lock + val = cache.get(self.attrname, _NOT_FOUND) + if val is _NOT_FOUND: + val = self.func(instance) + try: + cache[self.attrname] = val + except TypeError: + msg = ( + f"The '__dict__' attribute on {type(instance).__name__!r} instance " + f"does not support item assignment for caching {self.attrname!r} property." + ) + raise TypeError(msg) from None + return val diff --git a/src/great_ai/large_file/helper/human_readable_to_byte.py b/great_ai/large_file/helper/human_readable_to_byte.py similarity index 100% rename from src/great_ai/large_file/helper/human_readable_to_byte.py rename to great_ai/large_file/helper/human_readable_to_byte.py diff --git a/src/great_ai/large_file/helper/progress_bar.py b/great_ai/large_file/helper/progress_bar.py similarity index 100% rename from src/great_ai/large_file/helper/progress_bar.py rename to great_ai/large_file/helper/progress_bar.py diff --git a/src/great_ai/utilities/external/__init__.py b/great_ai/large_file/large_file/__init__.py similarity index 100% rename from src/great_ai/utilities/external/__init__.py rename to great_ai/large_file/large_file/__init__.py diff --git a/src/great_ai/large_file/large_file/large_file.py b/great_ai/large_file/large_file/large_file_base.py similarity index 72% rename from src/great_ai/large_file/large_file/large_file.py rename to great_ai/large_file/large_file/large_file_base.py index 0172ef9..92fa5d9 100644 --- a/src/great_ai/large_file/large_file/large_file.py +++ b/great_ai/large_file/large_file/large_file_base.py @@ -1,12 +1,16 @@ import os +import re import shutil +import sys import tempfile from abc import ABC, abstractmethod +from functools import lru_cache from pathlib import Path from types import TracebackType -from typing import IO, Any, List, Optional, Type, Union, cast +from typing import IO, Any, List, Literal, Optional, Type, Union, cast + +from great_ai.utilities import ConfigFile, get_logger -from ...utilities import ConfigFile, get_logger from ..helper import human_readable_to_byte from ..models import DataInstance @@ -18,32 +22,27 @@ COMPRESSION_ALGORITHM = "gztar" ARCHIVE_EXTENSION = ".tar.gz" -class LargeFile(ABC): - """ - Store large files remotely. Use local cache for speed up. +class LargeFileBase(ABC): + """Base for LargeFile implementations with different backends. + + Store large files remotely using the familiar API of `open()`. With built-in + versioning, pruning and local cache. + + By default, files are stored in the ".cache" folder and the least recently used is + deleted after the overall size reaches 30 GBs. Examples: + >>> LargeFileBase.cache_path = Path(".cache") - ``` - with LargeFile("test.txt", "w", keep_last_n=3) as f: - for i in range(1000000): - f.write('test\n') + >>> LargeFileBase.max_cache_size = "30GB" - with LargeFile("test.txt", "r") as f: - print(f.readlines()[0]) - - path_to_cached_text_file = LargeFile("test.txt", version=0).get() - ``` - - By default, files are stored in the ".cache" folder and the - least recently use is deleted after the overall size reaches 30 GBs. - - Change it with the following properties. - - ``` - LargeFile.cache_path = Path(".cache") - LargeFile.max_cache_size = "30GB" - ``` + Attributes: + initialized: Tell whether `configure_credentials` or + `configure_credentials_from_file` has been already called. + cache_path: Storage location for cached files. + max_cache_size: Delete files until the folder at `cache_path` is smaller than + this value. Examples: "5 GB", "10MB", "0.3 TB". Set to `None` for no + automatic cache-pruning. """ initialized = False @@ -63,6 +62,12 @@ class LargeFile(ABC): keep_last_n: Optional[int] = None, cache_only_mode: bool = False, ): + clean_name = re.sub(r"[^!a-zA-Z0-9._-]+", "", name) + if clean_name != name: + raise ValueError( + f"Given name contains illegal characters, consider changing it to: `{clean_name}`" + ) + self._name = name self._version = version self._mode = mode @@ -71,10 +76,16 @@ class LargeFile(ABC): self._buffering = buffering self._encoding = encoding + + if errors is not None and sys.version_info[1] < 8: + raise RuntimeError( + "The `errors` kwarg is only supported in 3.8 <= Python versions." + ) self._errors = errors + self._newline = newline - LargeFile.cache_path.mkdir(parents=True, exist_ok=True) + LargeFileBase.cache_path.mkdir(parents=True, exist_ok=True) self._find_instances() self._check_mode_and_set_version() @@ -82,27 +93,38 @@ class LargeFile(ABC): @classmethod def configure_credentials_from_file( cls, - secrets_path: Union[Path, str], + secrets: Union[Path, str, ConfigFile], ) -> None: - cls.configure_credentials(**ConfigFile(secrets_path)) + """Load file and feed its content to `configure_credentials`. + + Extra keys are ignored. + """ + + if not isinstance(secrets, ConfigFile): + secrets = ConfigFile(secrets) + cls.configure_credentials(**{k.lower(): v for k, v in secrets.items()}) @classmethod - def configure_credentials( - cls, - ) -> None: + def configure_credentials(cls, **kwargs: str) -> None: + """Configure required credentials for the LargeFile backend.""" + cls.initialized = True def __enter__(self) -> IO: + params = dict( + mode=self._mode, + buffering=self._buffering, + encoding=self._encoding, + newline=self._newline, + delete=False, + prefix="large_file-", + ) + + if sys.version_info[1] >= 8: + params["errors"] = self._errors + self._file: IO[Any] = ( - tempfile.NamedTemporaryFile( - mode=self._mode, - buffering=self._buffering, - encoding=self._encoding, - newline=self._newline, - errors=self._errors, - delete=False, - prefix="large_file-", - ) + tempfile.NamedTemporaryFile(**params) # type: ignore if "w" in self._mode else open( self.get(), @@ -121,7 +143,7 @@ class LargeFile(ABC): type: Optional[Type[BaseException]], exc: Optional[BaseException], traceback: Optional[TracebackType], - ) -> bool: + ) -> Literal[False]: self._file.close() if type is None: @@ -131,17 +153,24 @@ class LargeFile(ABC): else: logger.exception("Could not finish operation.") - return True - - @property - def _local_name(self) -> str: - return f"{self._name}{CACHE_NAME_VERSION_SEPARATOR}{self.version}" + return False @property def version(self) -> int: + """Numeric version of the file proxied by this LargeFile instance.""" + return cast(int, self._version) + @lru_cache(1) def get(self, hide_progress: bool = False) -> Path: + """Return path to the proxy of a file (or directory). + + If not available in the local cache, an attempt is made to download it. + + Args: + hide_progress: Do not show a progress update after each 10% of progress. + """ + remote_path = next( i.remote_path for i in self._instances if i.version == self._version ) @@ -168,6 +197,14 @@ class LargeFile(ABC): return destination def push(self, path: Union[Path, str], hide_progress: bool = False) -> None: + """Upload a file (or directory) as a new version of `key`. + + The file/directory is compressed before upload. + + Args: + hide_progress: Do not show a progress update after each 10% of progress. + """ + if isinstance(path, str): path = Path(path) @@ -205,9 +242,26 @@ class LargeFile(ABC): self.clean_up() def delete(self) -> None: + """Delete all versions of the files under this `key`.""" + self._keep_last_n = 0 self._delete_old_remote_versions() + @property + def versions_pretty(self) -> str: + """Formatted string of all available versions.""" + return ", ".join((str(i.version) for i in self._instances)) + + def clean_up(self) -> None: + """Delete local and remote versions according to currently set cache and retention policy.""" + + self._delete_old_remote_versions() + self._prune_cache() + + @property + def _local_name(self) -> str: + return f"{self._name}{CACHE_NAME_VERSION_SEPARATOR}{self.version}" + def _find_instances(self) -> None: if self._cache_only_mode: self._instances = self._find_instances_from_cache() @@ -266,14 +320,6 @@ class LargeFile(ABC): else: raise ValueError("Unsupported file mode.") - @property - def versions_pretty(self) -> str: - return ", ".join((str(i.version) for i in self._instances)) - - def clean_up(self) -> None: - self._delete_old_remote_versions() - self._prune_cache() - def _prune_cache(self) -> None: self.cache_path.mkdir(parents=True, exist_ok=True) diff --git a/src/great_ai/large_file/large_file/large_file_local.py b/great_ai/large_file/large_file/large_file_local.py similarity index 65% rename from src/great_ai/large_file/large_file/large_file_local.py rename to great_ai/large_file/large_file/large_file_local.py index 689ea52..c1c5a12 100644 --- a/src/great_ai/large_file/large_file/large_file_local.py +++ b/great_ai/large_file/large_file/large_file_local.py @@ -3,12 +3,36 @@ from typing import Any, List, Optional from ...utilities import get_logger from ..models import DataInstance -from .large_file import LargeFile +from .large_file_base import LargeFileBase logger = get_logger("large_file") -class LargeFileLocal(LargeFile): +class LargeFileLocal(LargeFileBase): + """LargeFile implementation using local filesystem as a backend. + + Store large files remotely using the familiar API of `open()`. With built-in + versioning, pruning and local cache. + + IMPORTANT: If LargeFileLocal.max_cache_size is too small, it won't be enough to + store all your files and they can end up deleted. + + See parent for more details. + + Examples: + >>> LargeFileLocal.cache_path = Path(".cache") + + >>> LargeFileLocal.max_cache_size = "30GB" + + >>> with LargeFileLocal("my_test.txt", "w", keep_last_n=2) as f: + ... f.write('test') + 4 + + >>> with LargeFileLocal("my_test.txt") as f: + ... print(f.read()) + test + """ + def __init__( self, name: str, @@ -40,6 +64,7 @@ class LargeFileLocal(LargeFile): def _download( self, remote_path: Any, local_path: Path, hide_progress: bool ) -> None: + # This will never be called because the file must be in the cache raise NotImplementedError() def _upload(self, local_path: Path, hide_progress: bool) -> None: diff --git a/src/great_ai/large_file/large_file/large_file_mongo.py b/great_ai/large_file/large_file/large_file_mongo.py similarity index 85% rename from src/great_ai/large_file/large_file/large_file_mongo.py rename to great_ai/large_file/large_file/large_file_mongo.py index 5dda944..0376ce9 100644 --- a/src/great_ai/large_file/large_file/large_file_mongo.py +++ b/great_ai/large_file/large_file/large_file_mongo.py @@ -1,15 +1,15 @@ import re -from functools import cached_property from pathlib import Path -from typing import Any, List, Mapping +from typing import Any, List -from gridfs import DEFAULT_CHUNK_SIZE, Database, GridFSBucket +from gridfs import DEFAULT_CHUNK_SIZE, GridFSBucket from pymongo import MongoClient +from pymongo.database import Database from ...utilities import get_logger -from ..helper import DownloadProgressBar, UploadProgressBar +from ..helper import DownloadProgressBar, UploadProgressBar, cached_property from ..models import DataInstance -from .large_file import LargeFile +from .large_file_base import LargeFileBase logger = get_logger("large_file") @@ -17,7 +17,15 @@ logger = get_logger("large_file") MONGO_NAME_VERSION_SEPARATOR = "_" -class LargeFileMongo(LargeFile): +class LargeFileMongo(LargeFileBase): + """LargeFile implementation using GridFS (MongoDB) as a backend. + + Store large files remotely using the familiar API of `open()`. With built-in + versioning, pruning and local cache. + + See parent for more details. + """ + mongo_connection_string = None mongo_database = None @@ -27,7 +35,7 @@ class LargeFileMongo(LargeFile): *, mongo_connection_string: str, mongo_database: str, - **_: Mapping[str, Any], + **_: Any, ) -> None: cls.mongo_connection_string = mongo_connection_string cls.mongo_database = mongo_database @@ -37,7 +45,7 @@ class LargeFileMongo(LargeFile): def _client(self) -> GridFSBucket: if self.mongo_connection_string is None or self.mongo_database is None: raise ValueError( - "Please configure the MongoDB access options by calling LargeFileMongo.configure_credentials or set offline_mode=True in the constructor." + "Please configure the MongoDB access options by calling LargeFileMongo.configure_credentials or set cache_only_mode=True in the constructor." ) db: Database = MongoClient(self.mongo_connection_string)[self.mongo_database] @@ -53,7 +61,6 @@ class LargeFileMongo(LargeFile): ), version=int(f.name.split(MONGO_NAME_VERSION_SEPARATOR)[-1]), remote_path=(f._id, f.length), - origin="mongodb", ) for f in self._client.find( { diff --git a/src/great_ai/large_file/large_file/large_file_s3.py b/great_ai/large_file/large_file/large_file_s3.py similarity index 73% rename from src/great_ai/large_file/large_file/large_file_s3.py rename to great_ai/large_file/large_file/large_file_s3.py index d73493e..3e32a59 100644 --- a/src/great_ai/large_file/large_file/large_file_s3.py +++ b/great_ai/large_file/large_file/large_file_s3.py @@ -1,13 +1,12 @@ -from functools import cached_property from pathlib import Path -from typing import Any, List, Mapping, Optional +from typing import Any, List, Optional import boto3 from ...utilities import get_logger -from ..helper import DownloadProgressBar, UploadProgressBar +from ..helper import DownloadProgressBar, UploadProgressBar, cached_property from ..models import DataInstance -from .large_file import LargeFile +from .large_file_base import LargeFileBase logger = get_logger("large_file") @@ -15,32 +14,13 @@ logger = get_logger("large_file") S3_NAME_VERSION_SEPARATOR = "/" -class LargeFileS3(LargeFile): - """ - Store large files in S3. Use local cache for speed up. +class LargeFileS3(LargeFileBase): + """LargeFile implementation using S3-compatible storage as a backend. - Examples: + Store large files remotely using the familiar API of `open()`. With built-in + versioning, pruning and local cache. - ``` - with LargeFile("test.txt", "w", keep_last_n=3) as f: - for i in range(1000000): - f.write('test\n') - - with LargeFile("test.txt", "r") as f: - print(f.readlines()[0]) - - path_to_cached_text_file = LargeFile("test.txt", version=0).get() - ``` - - By default, files are stored in the ".cache" folder and the - least recently use is deleted after the overall size reaches 30 GBs. - - Change it with the following properties. - - ``` - LargeFile.cache_path = Path(".cache") - LargeFile.max_cache_size = "30GB" - ``` + See parent for more details. """ region_name = None @@ -58,7 +38,7 @@ class LargeFileS3(LargeFile): aws_secret_access_key: str, large_files_bucket_name: str, aws_endpoint_url: Optional[str] = None, - **_: Mapping[str, Any], + **_: Any, ) -> None: cls.region_name = aws_region_name cls.access_key_id = aws_access_key_id @@ -76,7 +56,7 @@ class LargeFileS3(LargeFile): or self.bucket_name is None ): raise ValueError( - "Please configure the S3 access options by calling LargeFileS3.configure_credentials or set offline_mode=True in the constructor." + "Please configure the S3 access options by calling LargeFileS3.configure_credentials or set cache_only_mode=True in the constructor." ) return boto3.client( @@ -120,9 +100,13 @@ class LargeFileS3(LargeFile): Bucket=self.bucket_name, Key=remote_path, Filename=str(local_path), - Callback=None - if hide_progress - else DownloadProgressBar(name=str(remote_path), size=size, logger=logger), + Callback=( + None + if hide_progress + else DownloadProgressBar( + name=str(remote_path), size=size, logger=logger + ) + ), ) def _upload(self, local_path: Path, hide_progress: bool) -> None: @@ -133,9 +117,11 @@ class LargeFileS3(LargeFile): Filename=str(local_path), Bucket=self.bucket_name, Key=key, - Callback=None - if hide_progress - else UploadProgressBar(path=local_path, logger=logger), + Callback=( + None + if hide_progress + else UploadProgressBar(path=local_path, logger=logger) + ), ) def _delete_old_remote_versions(self) -> None: diff --git a/src/great_ai/large_file/models/__init__.py b/great_ai/large_file/models/__init__.py similarity index 100% rename from src/great_ai/large_file/models/__init__.py rename to great_ai/large_file/models/__init__.py diff --git a/src/great_ai/large_file/models/data_instance.py b/great_ai/large_file/models/data_instance.py similarity index 100% rename from src/great_ai/large_file/models/data_instance.py rename to great_ai/large_file/models/data_instance.py diff --git a/src/great_ai/large_file/parse_arguments.py b/great_ai/large_file/parse_arguments.py similarity index 100% rename from src/great_ai/large_file/parse_arguments.py rename to great_ai/large_file/parse_arguments.py diff --git a/tests/__init__.py b/great_ai/models/__init__.py similarity index 100% rename from tests/__init__.py rename to great_ai/models/__init__.py diff --git a/great_ai/models/save_model.py b/great_ai/models/save_model.py new file mode 100644 index 0000000..84bef03 --- /dev/null +++ b/great_ai/models/save_model.py @@ -0,0 +1,48 @@ +from pathlib import Path +from typing import Optional, Union + +from dill import dump + +from ..context import get_context + + +def save_model( + model: Union[Path, str, object], key: str, *, keep_last_n: Optional[int] = None +) -> str: + """Save (and optionally serialise) a model in order to use by `use_model`. + + The `model` can be a Path or string representing a path in which case the + local file/folder is read and saved using the current LargeFile implementation. + In case `model` is an object, it is serialised using `dill` before uploading it. + + Examples: + >>> from great_ai import use_model + >>> save_model(3, 'my_number') + 'my_number:...' + + >>> @use_model('my_number') + ... def my_function(a, model): + ... return a + model + >>> my_function(4) + 7 + + Args: + model: The object or path to be uploaded. + key: The model's name. + keep_last_n: If specified, remove old models and only keep the latest n. Directly passed to LargeFile. + Returns: + The key and version of the saved model separated by a colon. Example: "key:version" + """ + file = get_context().large_file_implementation( + name=key, mode="wb", keep_last_n=keep_last_n + ) + + if isinstance(model, Path) or isinstance(model, str): + file.push(model) + else: + with file as f: + dump(model, f) + + get_context().logger.info(f"Model {key} uploaded with version {file.version}") + + return f"{key}:{file.version}" diff --git a/great_ai/models/use_model.py b/great_ai/models/use_model.py new file mode 100644 index 0000000..e18eff8 --- /dev/null +++ b/great_ai/models/use_model.py @@ -0,0 +1,103 @@ +from functools import wraps +from typing import ( + Any, + Callable, + Dict, + List, + Literal, + Optional, + Set, + Tuple, + TypeVar, + Union, + cast, +) + +from dill import load + +from ..context import get_context +from ..helper import get_function_metadata_store +from ..helper.assert_function_is_not_finalised import assert_function_is_not_finalised +from ..tracing.tracing_context import TracingContext +from ..views import Model + +F = TypeVar("F", bound=Callable) + + +def use_model( + key: str, + *, + version: Union[int, Literal["latest"]] = "latest", + model_kwarg_name: str = "model", +) -> Callable[[F], F]: + """Inject a model into a function. + + Load a model specified by `key` and `version` using the currently active `LargeFile` + implementation. If it's a single object, it is deserialised using `dill`. If it's a + directory of files, a `pathlib.Path` instance is given. + + By default, the function's `model` parameter is replaced by the loaded model. This + can be customised by changing `model_kwarg_name`. Multiple models can be loaded by + decorating the same function with `use_model` multiple times. + + Examples: + >>> from great_ai import save_model + >>> save_model(3, 'my_number') + 'my_number:...' + >>> @use_model('my_number') + ... def my_function(a, model): + ... return a + model + >>> my_function(4) + 7 + + Args: + key: The model's name as stored by the LargeFile implementation. + version: The model's version as stored by the LargeFile implementation. + model_kwarg_name: the parameter to use for injecting the loaded model + Returns: + A decorator for model injection. + """ + + assert ( + isinstance(version, int) or version == "latest" + ), "Only integers or the string literal `latest` is allowed as a version" + + model, actual_version = _load_model( + key=key, + version=None if version == "latest" else version, + ) + + def decorator(func: F) -> F: + assert_function_is_not_finalised(func) + + store = get_function_metadata_store(func) + store.model_parameter_names.append(model_kwarg_name) + + @wraps(func) + def wrapper(*args: List[Any], **kwargs: Dict[str, Any]) -> Any: + tracing_context = TracingContext.get_current_tracing_context() + if tracing_context: + tracing_context.log_model(Model(key=key, version=actual_version)) + return func(*args, **kwargs, **{model_kwarg_name: model}) + + return cast(F, wrapper) + + return decorator + + +model_versions: Set[Tuple[str, int]] = set() + + +def _load_model(key: str, version: Optional[int] = None) -> Tuple[Any, int]: + file = get_context().large_file_implementation(name=key, mode="rb", version=version) + path = file.get() + + model_versions.add((key, file.version)) + + if path.is_dir(): + return path, file.version + + with file as f: + loaded = load(f) + + return loaded, file.version diff --git a/tests/large_file/__init__.py b/great_ai/parameters/__init__.py similarity index 100% rename from tests/large_file/__init__.py rename to great_ai/parameters/__init__.py diff --git a/src/great_ai/great_ai/parameters/automatically_decorate_parameters.py b/great_ai/parameters/automatically_decorate_parameters.py similarity index 88% rename from src/great_ai/great_ai/parameters/automatically_decorate_parameters.py rename to great_ai/parameters/automatically_decorate_parameters.py index 8a3b017..9d4e9f2 100644 --- a/src/great_ai/great_ai/parameters/automatically_decorate_parameters.py +++ b/great_ai/parameters/automatically_decorate_parameters.py @@ -1,10 +1,10 @@ import inspect -from typing import Any, Callable, TypeVar +from typing import Callable, TypeVar from ..helper.get_function_metadata_store import get_function_metadata_store from .parameter import parameter -F = TypeVar("F", bound=Callable[..., Any]) +F = TypeVar("F", bound=Callable) def automatically_decorate_parameters(func: F) -> F: diff --git a/great_ai/parameters/log_metric.py b/great_ai/parameters/log_metric.py new file mode 100644 index 0000000..f307573 --- /dev/null +++ b/great_ai/parameters/log_metric.py @@ -0,0 +1,31 @@ +import inspect +from typing import Any + +from ..context import get_context +from ..tracing import TracingContext + + +def log_metric(argument_name: str, value: Any, disable_logging: bool = False) -> None: + """Log a key (argument_name)-value pair that is persisted inside the trace. + + The name of the function from where this is called is also stored. + + Args: + argument_name: The key for storing the value. + value: Value to log. Must be JSON-serialisable. + disable_logging: If True, only persist in trace but don't show in console + """ + + tracing_context = TracingContext.get_current_tracing_context() + try: + caller = inspect.stack()[1].function + actual_name = f"metric:{caller}:{argument_name}" + except: + # inspect might not work in notebooks + actual_name = f"metric:{argument_name}" + + if tracing_context: + tracing_context.log_value(name=actual_name, value=value) + + if not disable_logging: + get_context().logger.info(f"{actual_name}={value}") diff --git a/great_ai/parameters/parameter.py b/great_ai/parameters/parameter.py new file mode 100644 index 0000000..df3a7d4 --- /dev/null +++ b/great_ai/parameters/parameter.py @@ -0,0 +1,90 @@ +from functools import wraps +from typing import Any, Callable, Dict, TypeVar, cast + +from typeguard import TypeCheckError, check_type + +from ..errors import ArgumentValidationError +from ..helper import get_arguments, get_function_metadata_store +from ..helper.assert_function_is_not_finalised import assert_function_is_not_finalised +from ..tracing.tracing_context import TracingContext + +F = TypeVar("F", bound=Callable) + + +def parameter( + parameter_name: str, + *, + validate: Callable[[Any], bool] = lambda _: True, + disable_logging: bool = False, +) -> Callable[[F], F]: + """Control the validation and logging of function parameters. + + Basically, a parameter decorator. Unfortunately, Python does not have that concept, + thus, it's a method decorator that expects the name of the to-be-decorated + parameter. + + Examples: + >>> @parameter('a') + ... def my_function(a: int): + ... return a + 2 + >>> my_function(4) + 6 + >>> my_function('3') + Traceback (most recent call last): + ... + TypeError: argument a is not of the expected type: ... + + >>> @parameter('positive_a', validate=lambda v: v > 0) + ... def my_function(positive_a: int): + ... return a + 2 + >>> my_function(-1) + Traceback (most recent call last): + ... + great_ai.errors.argument_validation_error.ArgumentValidationError: ... + + Args: + parameter_name: Name of parameter to consider. + validate: Optional validate to run against the concrete argument. + ArgumentValidationError is thrown when the return value is False. + disable_logging: Do not save the value in any active TracingContext. + Returns: + A decorator for argument validation. + """ + + def decorator(func: F) -> F: + get_function_metadata_store(func).input_parameter_names.append(parameter_name) + assert_function_is_not_finalised(func) + + actual_name = f"arg:{parameter_name}" + + @wraps(func) + def wrapper(*args: Any, **kwargs: Dict[str, Any]) -> Any: + arguments = get_arguments(func, args, kwargs) + argument = arguments.get(parameter_name) + + expected_type = func.__annotations__.get(parameter_name) + + if expected_type is not None: + try: + check_type(argument, expected_type) + except TypeCheckError as error: + raise TypeError( + f"argument {parameter_name} is not of the expected type: {error}" + ) from error + + if not validate(argument): + raise ArgumentValidationError( + f"Argument {parameter_name} in {func.__name__} did not pass validation" + ) + + context = TracingContext.get_current_tracing_context() + if context and not disable_logging: + context.log_value(name=f"{actual_name}:value", value=argument) + if isinstance(argument, str): + context.log_value(name=f"{actual_name}:length", value=len(argument)) + + return func(*args, **kwargs) + + return cast(F, wrapper) + + return decorator diff --git a/src/great_ai/parse_arguments.py b/great_ai/parse_arguments.py similarity index 51% rename from src/great_ai/parse_arguments.py rename to great_ai/parse_arguments.py index 1ca111c..e816b6b 100644 --- a/src/great_ai/parse_arguments.py +++ b/great_ai/parse_arguments.py @@ -12,35 +12,39 @@ def parse_arguments() -> Namespace: help="the name of the file containing your to-be-served function such as `main.py`\n", ) + default_host = "0.0.0.0" parser.add_argument( "--host", type=str, - help="it is passed to uvicorn which starts a server listening on this address", - default="0.0.0.0", + help=f"it is passed to uvicorn which starts a server listening on this address (default: {default_host})", + default=default_host, required=False, ) + default_port = 6060 parser.add_argument( "--port", type=int, - help="it is passed to uvicorn which starts a server listening on this port", - default=6060, + help=f"it is passed to uvicorn which starts a server listening on this port (default: {default_port})", + default=default_port, required=False, ) + default_timeout_keep_alive = 600 parser.add_argument( "--timeout_keep_alive", type=int, - help="it is passed to uvicorn which uses it for timing out requests taking longer than this many seconds", + help=f"it is passed to uvicorn which uses it for timing out requests taking longer than this many seconds (default: {default_timeout_keep_alive})", default=600, required=False, ) + default_worker_count = 1 parser.add_argument( - "--workers", + "--worker_count", type=int, - help="it is passed to uvicorn which starts this many server processes", - default=1, + help=f"it is passed to uvicorn which starts this many server processes (default: {default_worker_count})", + default=default_worker_count, required=False, ) diff --git a/tests/utilities/__init__.py b/great_ai/persistence/__init__.py similarity index 100% rename from tests/utilities/__init__.py rename to great_ai/persistence/__init__.py diff --git a/great_ai/persistence/mongodb_driver.py b/great_ai/persistence/mongodb_driver.py new file mode 100644 index 0000000..506d74d --- /dev/null +++ b/great_ai/persistence/mongodb_driver.py @@ -0,0 +1,173 @@ +from datetime import datetime +from typing import Any, Dict, List, Optional, Sequence, Tuple + +from pymongo import ASCENDING, DESCENDING, MongoClient + +from ..utilities import chunk +from ..views import Filter, SortBy, Trace +from .tracing_database_driver import TracingDatabaseDriver + +operator_mapping = { + "=": "$eq", + "!=": "$ne", + "<": "$lt", + "<=": "$lte", + ">": "$gt", + ">=": "$gte", + "contains": "$regex", +} + + +class MongoDbDriver(TracingDatabaseDriver): + """TracingDatabaseDriver implementation using MongoDB as a backend. + + A production-ready database driver suitable for efficiently handling semi-structured + data. + + Checkout [MongoDB Atlas](https://www.mongodb.com/cloud/atlas/register) for a hosted + MongoDB solution. + """ + + is_production_ready = True + + mongo_connection_string: str + mongo_database: str + + def __init__(self) -> None: + super().__init__() + if self.mongo_connection_string is None or self.mongo_database is None: + raise ValueError( + "Please configure the MongoDB access options by calling " + "MongoDbDriver.configure_credentials" + ) + + with MongoClient[Any](self.mongo_connection_string) as client: + client[self.mongo_database].traces.create_index( + [("tags", ASCENDING), ("created", DESCENDING)], background=True + ) + + @classmethod + def configure_credentials( # type: ignore + cls, + *, + mongo_connection_string: str, + mongo_database: str, + **_: Any, + ) -> None: + """Configure the connection details for MongoDB. + + Args: + mongo_connection_string: For example: + 'mongodb://my_user:my_pass@localhost:27017' + mongo_database: Name of the database to use. If doesn't exist, it is + created and initialised. + """ + cls.mongo_connection_string = mongo_connection_string + cls.mongo_database = mongo_database + super().configure_credentials() + + def save(self, trace: Trace) -> str: + serialized = trace.to_flat_dict() + serialized["_id"] = trace.trace_id + + with MongoClient[Any](self.mongo_connection_string) as client: + return client[self.mongo_database].traces.insert_one(serialized).inserted_id + + def save_batch(self, documents: List[Trace]) -> List[str]: + serialized = [d.to_flat_dict() for d in documents] + for s in serialized: + s["_id"] = s["trace_id"] + + with MongoClient[Any](self.mongo_connection_string) as client: + return ( + client[self.mongo_database] + .traces.insert_many(serialized, ordered=False) + .inserted_ids + ) + + def get(self, id: str) -> Optional[Trace]: + with MongoClient[Any](self.mongo_connection_string) as client: + value = client[self.mongo_database].traces.find_one(id) + + if value: + value = Trace.model_validate(value) + + return value + + def _get_operator(self, filter: Filter) -> str: + if filter.operator == "contains" and not isinstance(filter.value, str): + return operator_mapping["="] + return operator_mapping[filter.operator] + + def query( + self, + *, + skip: int = 0, + take: Optional[int] = None, + conjunctive_filters: Sequence[Filter] = [], + conjunctive_tags: Sequence[str] = [], + since: Optional[datetime] = None, + until: Optional[datetime] = None, + has_feedback: Optional[bool] = None, + sort_by: Sequence[SortBy] = [], + ) -> Tuple[List[Trace], int]: + + query: Dict[str, Any] = { + "filter": {}, + } + + and_query: List[Dict[str, Any]] = [] + and_query.extend({"tags": tag} for tag in conjunctive_tags) + and_query.extend( + {f.property: {self._get_operator(f): f.value}} for f in conjunctive_filters + ) + if not and_query: + and_query.append({}) + + if since: + and_query.append({"created": {"$gte": since}}) + + if until: + and_query.append({"created": {"$lte": until}}) + + if has_feedback is not None: + and_query.append( + {"feedback": {"$ne": None}} if has_feedback else {"feedback": None} + ) + query["filter"]["$and"] = and_query + + with MongoClient[Any](self.mongo_connection_string) as client: + count = client[self.mongo_database].traces.count_documents(**query) + + if skip: + query["skip"] = skip + + if take: + query["limit"] = take + + query["sort"] = [ + (col.column_id, 1 if col.direction == "asc" else -1) for col in sort_by + ] + + with client[self.mongo_database].traces.find(**query) as cursor: + documents = [Trace[Any].model_validate(t) for t in cursor] + return documents, count + + def update(self, id: str, new_version: Trace) -> None: + serialized = new_version.to_flat_dict() + serialized["_id"] = new_version.trace_id + + with MongoClient[Any](self.mongo_connection_string) as client: + client[self.mongo_database].traces.update_one({"_id": id}, serialized) + + def delete(self, id: str) -> None: + with MongoClient[Any](self.mongo_connection_string) as client: + client[self.mongo_database].traces.delete_one({"_id": id}) + + def delete_batch(self, ids: List[str]) -> None: + with MongoClient[Any](self.mongo_connection_string) as client: + for c in chunk( + ids, chunk_size=10000 + ): # avoid: 'delete' command document too large + delete_filter = {"_id": {"$in": c}} + client[self.mongo_database].traces.delete_many(delete_filter) diff --git a/src/great_ai/great_ai/persistence/parallel_tinydb_driver.py b/great_ai/persistence/parallel_tinydb_driver.py similarity index 60% rename from src/great_ai/great_ai/persistence/parallel_tinydb_driver.py rename to great_ai/persistence/parallel_tinydb_driver.py index 61b0761..6e278a1 100644 --- a/src/great_ai/great_ai/persistence/parallel_tinydb_driver.py +++ b/great_ai/persistence/parallel_tinydb_driver.py @@ -1,7 +1,7 @@ from datetime import datetime from multiprocessing import Lock from pathlib import Path -from typing import Any, Callable, Dict, List, Optional, Sequence, Tuple, cast +from typing import Any, Callable, Dict, List, Optional, Sequence, Tuple import pandas as pd from tinydb import TinyDB @@ -17,20 +17,28 @@ operator_mapping = {"=": "eq", "!=": "ne", "<": "lt", "<=": "le", ">": "gt", ">= class ParallelTinyDbDriver(TracingDatabaseDriver): + """TracingDatabaseDriver with TinyDB as a backend. + + Saves the database as a JSON into a single file. Highly inefficient on inserting, + not advised for production use. + + A multiprocessing lock protects the database file to avoid parallelisation issues. + """ + is_production_ready = False path_to_db = Path(DEFAULT_TRACING_DB_FILENAME) def save(self, trace: Trace) -> str: - return self._safe_execute(lambda db: db.insert(trace.dict())) + return self._safe_execute(lambda db: db.insert(trace.model_dump())) def save_batch(self, documents: List[Trace]) -> List[str]: - traces = [d.dict() for d in documents] + traces = [d.model_dump() for d in documents] return self._safe_execute(lambda db: db.insert_multiple(traces)) def get(self, id: str) -> Optional[Trace]: value = self._safe_execute(lambda db: db.get(lambda d: d["trace_id"] == id)) if value: - value = Trace.parse_obj(value) + value = Trace.model_validate(value) return value def query( @@ -43,33 +51,27 @@ class ParallelTinyDbDriver(TracingDatabaseDriver): since: Optional[datetime] = None, until: Optional[datetime] = None, has_feedback: Optional[bool] = None, - sort_by: Sequence[SortBy] = [] + sort_by: Sequence[SortBy] = [], ) -> Tuple[List[Trace], int]: def does_match(d: Dict[str, Any]) -> bool: return ( not set(conjunctive_tags) - set(d["tags"]) - and ( - since is None - or cast(datetime, datetime.fromisoformat(d["created"])) >= since - ) - and ( - until is None - or cast(datetime, datetime.fromisoformat(d["created"])) <= until - ) + and (since is None or datetime.fromisoformat(d["created"]) >= since) + and (until is None or datetime.fromisoformat(d["created"]) <= until) and ( has_feedback is None or has_feedback == (d["feedback"] is not None) ) ) - documents: List[Trace] = [ - Trace.parse_obj(t) - for t in self._safe_execute(lambda db: db.search(does_match)) - ] - + documents = self._safe_execute(lambda db: db.search(does_match)) if not documents: return [], 0 - df = pd.DataFrame([d.to_flat_dict() for d in documents]) + traces: List[Trace] = [Trace.model_validate(d) for d in documents] + # The DataFrame keeps its default 0..n-1 index, so filtering/sorting below + # preserve the row labels that index back into `traces`. This avoids + # reconstructing Traces from the lossy flattened rows. + df = pd.DataFrame([t.to_flat_dict() for t in traces]) for f in conjunctive_filters: operator = f.operator.lower() @@ -78,7 +80,12 @@ class ParallelTinyDbDriver(TracingDatabaseDriver): getattr(df[f.property], operator_mapping[f.operator])(f.value) ] elif operator == "contains": - df = df.loc[df[f.property].str.contains(f.value, case=False)] + df = df.loc[ + df[f.property].str.contains( + str(int(f.value)) if isinstance(f.value, float) else f.value, + case=False, + ) + ] if sort_by: df.sort_values( @@ -89,22 +96,23 @@ class ParallelTinyDbDriver(TracingDatabaseDriver): count = len(df) result = df.iloc[skip:] if take is None else df.iloc[skip : skip + take] - return [ - next(d for d in documents if d.trace_id == trace_id) - for trace_id in result["trace_id"] - ], count + return [traces[i] for i in result.index], count def update(self, id: str, new_version: Trace) -> None: self._safe_execute( - lambda db: db.update(new_version.dict(), lambda d: d["trace_id"] == id) + lambda db: db.update( + new_version.model_dump(), lambda d: d["trace_id"] == id + ) ) def delete(self, id: str) -> None: self._safe_execute(lambda db: db.remove(lambda d: d["trace_id"] == id)) - def delete_batch(self, ids: List[str]) -> List[str]: - for i in ids: - self.delete(i) + def delete_batch(self, ids: List[str]) -> None: + with lock: + with TinyDB(self.path_to_db) as db: + for id in ids: + db.remove(lambda d: d["trace_id"] == id) def _safe_execute(self, func: Callable[[TinyDB], Any]) -> Any: with lock: diff --git a/src/great_ai/great_ai/persistence/tracing_database_driver.py b/great_ai/persistence/tracing_database_driver.py similarity index 79% rename from src/great_ai/great_ai/persistence/tracing_database_driver.py rename to great_ai/persistence/tracing_database_driver.py index e26a8ae..3491237 100644 --- a/src/great_ai/great_ai/persistence/tracing_database_driver.py +++ b/great_ai/persistence/tracing_database_driver.py @@ -3,20 +3,24 @@ from datetime import datetime from pathlib import Path from typing import List, Optional, Sequence, Tuple, Union -from ...utilities import ConfigFile +from ..utilities import ConfigFile from ..views import Filter, SortBy, Trace class TracingDatabaseDriver(ABC): + """Interface expected from a database to be used for storing traces.""" + is_production_ready: bool initialized: bool = False @classmethod def configure_credentials_from_file( cls, - secrets_path: Union[Path, str], + secrets: Union[Path, str, ConfigFile], ) -> None: - cls.configure_credentials(**ConfigFile(secrets_path)) + if not isinstance(secrets, ConfigFile): + secrets = ConfigFile(secrets) + cls.configure_credentials(**{k.lower(): v for k, v in secrets.items()}) @classmethod def configure_credentials( @@ -50,7 +54,7 @@ class TracingDatabaseDriver(ABC): until: Optional[datetime] = None, since: Optional[datetime] = None, has_feedback: Optional[bool] = None, - sort_by: Sequence[SortBy] = [] + sort_by: Sequence[SortBy] = [], ) -> Tuple[List[Trace], int]: pass diff --git a/great_ai/remote/__init__.py b/great_ai/remote/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/great_ai/remote/call_remote_great_ai.py b/great_ai/remote/call_remote_great_ai.py new file mode 100644 index 0000000..7c124a3 --- /dev/null +++ b/great_ai/remote/call_remote_great_ai.py @@ -0,0 +1,44 @@ +import asyncio +from typing import Any, Mapping, Optional, Type, TypeVar + +from pydantic import BaseModel + +from great_ai.utilities import get_logger + +from ..views import Trace +from .call_remote_great_ai_async import call_remote_great_ai_async + +logger = get_logger("call_remote_great_ai") + +T = TypeVar("T", bound=BaseModel) + + +def call_remote_great_ai( + base_uri: str, + data: Mapping[str, Any], + retry_count: int = 4, + timeout_in_seconds: Optional[int] = 300, + model_class: Optional[Type[T]] = None, +) -> Trace[T]: + """Communicate with a GreatAI object through an HTTP request. + + Wrapper over `call_remote_great_ai_async` making it synchronous. For more info, see + `call_remote_great_ai_async`. + """ + try: + asyncio.get_running_loop() + raise Exception( + f"Already running in an event loop, you have to call `{call_remote_great_ai_async.__name__}`" + ) + except RuntimeError: + pass + + future = call_remote_great_ai_async( + base_uri=base_uri, + data=data, + retry_count=retry_count, + timeout_in_seconds=timeout_in_seconds, + model_class=model_class, + ) + + return asyncio.run(future) diff --git a/great_ai/remote/call_remote_great_ai_async.py b/great_ai/remote/call_remote_great_ai_async.py new file mode 100644 index 0000000..eac83ee --- /dev/null +++ b/great_ai/remote/call_remote_great_ai_async.py @@ -0,0 +1,70 @@ +from typing import Any, Mapping, Optional, Type, TypeVar + +import httpx +from pydantic import BaseModel + +from ..errors.remote_call_error import RemoteCallError +from ..views import Trace + +T = TypeVar("T", bound=BaseModel) + + +async def call_remote_great_ai_async( + base_uri: str, + data: Mapping[str, Any], + retry_count: int = 4, + timeout_in_seconds: Optional[int] = 300, + model_class: Optional[Type[T]] = None, +) -> Trace[T]: + """Communicate with a GreatAI object through an HTTP request. + + Send a POST request using [httpx](https://www.python-httpx.org/) to implement a + remote call. Error-handling and retries are provided by httpx. + + The return value is inflated into a Trace. If `model_class` is specified, the + original output is deserialised. + + Args: + base_uri: Address of the remote instance, example: 'http://localhost:6060' + data: The input sent as a json to the remote instance. + retry_count: Retry on any HTTP communication failure. + timeout_in_seconds: Overall permissible max length of the request. `None` means + no timeout. + model_class: A subtype of BaseModel to be used for deserialising the `.output` + of the trace. + """ + + if base_uri.endswith("/"): + base_uri = base_uri[:-1] + + if not base_uri.endswith("/predict"): + base_uri = f"{base_uri}/predict" + + transport = httpx.AsyncHTTPTransport(retries=retry_count) + + try: + async with httpx.AsyncClient( + transport=transport, timeout=timeout_in_seconds + ) as client: + response = await client.post(base_uri, json=data) + try: + response.raise_for_status() + except Exception: + raise RemoteCallError( + f"Unexpected status code, reason: {response.text}" + ) + except Exception as e: + raise RemoteCallError from e + + try: + trace = response.json() + except Exception: + raise RemoteCallError( + f"JSON parsing failed {response.text}", + ) + try: + if model_class is not None: + trace["output"] = model_class.model_validate(trace["output"]) + return Trace.model_validate(trace) + except Exception: + raise RemoteCallError("Could not parse Trace") diff --git a/great_ai/tracing/__init__.py b/great_ai/tracing/__init__.py new file mode 100644 index 0000000..47ec644 --- /dev/null +++ b/great_ai/tracing/__init__.py @@ -0,0 +1 @@ +from .tracing_context import TracingContext diff --git a/great_ai/tracing/add_ground_truth.py b/great_ai/tracing/add_ground_truth.py new file mode 100644 index 0000000..15d87a9 --- /dev/null +++ b/great_ai/tracing/add_ground_truth.py @@ -0,0 +1,116 @@ +from datetime import datetime, timezone +from math import ceil +from random import shuffle +from typing import Any, Iterable, List, TypeVar, Union, cast +from uuid import uuid4 + +from ..constants import ( + GROUND_TRUTH_TAG_NAME, + TEST_SPLIT_TAG_NAME, + TRAIN_SPLIT_TAG_NAME, + VALIDATION_SPLIT_TAG_NAME, +) +from ..context import get_context +from ..views import Trace + +T = TypeVar("T") + + +def add_ground_truth( + inputs: Iterable[Any], + expected_outputs: Iterable[T], + *, + tags: Union[List[str], str] = [], + train_split_ratio: float = 1, + test_split_ratio: float = 0, + validation_split_ratio: float = 0, +) -> None: + """Add training data (with optional train-test splitting). + + Add and tag data-points, wrap them into traces. The `inputs` are available via the + `.input` property, while `expected_outputs` under both the `.output` and `.feedback` + properties. + + All generated traces are tagged with `ground_truth` by default. Additional tags can + be also provided. Using the `split_ratio` arguments, tags can be given randomly with + a user-defined distribution. Only the ratio of the splits matter, they don't have to + add up to 1. + + Examples: + >>> add_ground_truth( + ... [1, 2, 3], + ... ['odd', 'even', 'odd'], + ... tags='my_tag', + ... train_split_ratio=1, + ... test_split_ratio=1, + ... validation_split_ratio=0.5, + ... ) + + >>> add_ground_truth( + ... [1, 2], + ... ['odd', 'even', 'odd'], + ... tags='my_tag', + ... train_split_ratio=1, + ... test_split_ratio=1, + ... validation_split_ratio=0.5, + ... ) + Traceback (most recent call last): + ... + AssertionError: The length of the inputs and expected_outputs must be equal + + Args: + inputs: The inputs. (X in scikit-learn) + expected_outputs: The ground-truth values corresponding to the inputs. (y in + scikit-learn) + tags: A single tag or a list of tags to append to each generated trace's tags. + train_split_ratio: The probability-weight of giving each trace the `train` tag. + test_split_ratio: The probability-weight of giving each trace the `test` tag. + validation_split_ratio: The probability-weight of giving each trace the + `validation` tag. + """ + + inputs = list(inputs) + expected_outputs = list(expected_outputs) + assert len(inputs) == len( + expected_outputs + ), "The length of the inputs and expected_outputs must be equal" + + tags = tags if isinstance(tags, list) else [tags] + + sum_ratio = train_split_ratio + test_split_ratio + validation_split_ratio + assert sum_ratio > 0, "The sum of the split ratios must be a positive number" + + train_split_ratio /= sum_ratio + test_split_ratio /= sum_ratio + validation_split_ratio /= sum_ratio + + values = list(zip(inputs, expected_outputs)) + shuffle(values) + + split_tags = ( + [TRAIN_SPLIT_TAG_NAME] * ceil(train_split_ratio * len(inputs)) + + [TEST_SPLIT_TAG_NAME] * ceil(test_split_ratio * len(inputs)) + + [VALIDATION_SPLIT_TAG_NAME] * ceil(validation_split_ratio * len(inputs)) + ) + shuffle(split_tags) + + created = datetime.now(timezone.utc).replace(tzinfo=None).isoformat() + traces = [ + cast( + Trace[T], + Trace( # avoid ValueError: "Trace" object has no field "__orig_class__" + trace_id=str(uuid4()), + created=created, + original_execution_time_ms=0, + logged_values=X if isinstance(X, dict) else {"input": X}, + models=[], + output=y, + feedback=y, + exception=None, + tags=[GROUND_TRUTH_TAG_NAME, split_tag, *tags], + ), + ) + for ((X, y), split_tag) in zip(values, split_tags) + ] + + get_context().tracing_database.save_batch(traces) diff --git a/great_ai/tracing/delete_ground_truth.py b/great_ai/tracing/delete_ground_truth.py new file mode 100644 index 0000000..9984488 --- /dev/null +++ b/great_ai/tracing/delete_ground_truth.py @@ -0,0 +1,41 @@ +from datetime import datetime +from typing import List, Optional, Union + +from ..context import get_context + + +def delete_ground_truth( + conjunctive_tags: Union[List[str], str] = [], + *, + since: Optional[datetime] = None, + until: Optional[datetime] = None, +) -> None: + """Delete traces matching the given criteria. + + Takes the same arguments as `query_ground_truth` but instead of returning them, + it simply deletes them. + + You can rely on the efficiency of the delete's implementation. + + Examples: + >>> delete_ground_truth(['train', 'test', 'validation']) + + Args: + conjunctive_tags: Single tag or a list of tags which the deleted traces have to + match. The relationship between the tags is conjunctive (AND). + since: Only delete traces created after the given timestamp. `None` means no + filtering. + until: Only delete traces created before the given timestamp. `None` means no + filtering. + """ + + tags = ( + conjunctive_tags if isinstance(conjunctive_tags, list) else [conjunctive_tags] + ) + db = get_context().tracing_database + + items, length = db.query( + conjunctive_tags=tags, until=until, since=since, has_feedback=True + ) + + db.delete_batch([i.trace_id for i in items]) diff --git a/great_ai/tracing/query_ground_truth.py b/great_ai/tracing/query_ground_truth.py new file mode 100644 index 0000000..d30739f --- /dev/null +++ b/great_ai/tracing/query_ground_truth.py @@ -0,0 +1,51 @@ +from datetime import datetime +from typing import List, Optional, Union + +from ..context import get_context +from ..views import Trace + + +def query_ground_truth( + conjunctive_tags: Union[List[str], str] = [], + *, + since: Optional[datetime] = None, + until: Optional[datetime] = None, + return_max_count: Optional[int] = None, +) -> List[Trace]: + """Return training samples. + + Combines, filters, and returns data-points that have been either added by + `add_ground_truth` or were the result of a prediction after which their trace got + feedback through the RESP API-s `/traces/{trace_id}/feedback` endpoint + (end-to-end feedback). + + Filtering can be used to only return points matching all given tags (or the single + given tag) and by time of creation. + + Examples: + >>> query_ground_truth() + [...] + + Args: + conjunctive_tags: Single tag or a list of tags which the returned traces have to + match. The relationship between the tags is conjunctive (AND). + since: Only return traces created after the given timestamp. `None` means no + filtering. + until: Only return traces created before the given timestamp. `None` means no + filtering. + return_max_count: Return at-most this many traces. (take, limit) + """ + + tags = ( + conjunctive_tags if isinstance(conjunctive_tags, list) else [conjunctive_tags] + ) + db = get_context().tracing_database + + items, length = db.query( + conjunctive_tags=tags, + since=since, + until=until, + take=return_max_count, + has_feedback=True, + ) + return items diff --git a/great_ai/tracing/tracing_context.py b/great_ai/tracing/tracing_context.py new file mode 100644 index 0000000..9180061 --- /dev/null +++ b/great_ai/tracing/tracing_context.py @@ -0,0 +1,106 @@ +from contextvars import ContextVar +from datetime import datetime, timezone +from time import perf_counter +from types import TracebackType +from typing import Any, Dict, Generic, List, Literal, Optional, Type, TypeVar, cast +from uuid import uuid4 + +from ..constants import DEVELOPMENT_TAG_NAME, ONLINE_TAG_NAME, PRODUCTION_TAG_NAME +from ..context import get_context +from ..views import Model, Trace + +T = TypeVar("T") + + +class TracingContext(Generic[T]): + """Provide a global context variable throughout the life-cycle of a prediction. + + Should only be used by internal great-ai functions. + """ + + def __init__(self, function_name: str, do_not_persist_traces: bool) -> None: + self._do_not_persist_traces = do_not_persist_traces + self._models: List[Model] = [] + self._values: Dict[str, Any] = {} + self._trace: Optional[Trace[T]] = None + self._start_datetime = datetime.now(timezone.utc).replace(tzinfo=None) + self._start_time = perf_counter() + self._name = function_name + + def log_value(self, name: str, value: Any) -> None: + self._values[name] = value + + def log_model(self, model: Model) -> None: + self._models.append(model) + + def finalise( + self, output: Optional[T] = None, exception: Optional[BaseException] = None + ) -> Trace[T]: + assert self._trace is None, "has been already finalised" + + delta_time = round((perf_counter() - self._start_time) * 1000, 4) + self._trace = ( + cast( # avoid ValueError: "Trace" object has no field "__orig_class__" + Trace[T], + Trace( + trace_id=str(uuid4()), + created=self._start_datetime.isoformat(), + original_execution_time_ms=delta_time, + logged_values=self._values, + models=self._models, + output=output, + exception=( + None + if exception is None + else f"{type(exception).__name__}: {exception}" + ), + tags=[ + self._name, + ONLINE_TAG_NAME, + ( + PRODUCTION_TAG_NAME + if get_context().is_production + else DEVELOPMENT_TAG_NAME + ), + ], + ), + ) + ) + + return self._trace + + @staticmethod + def get_current_tracing_context() -> Optional["TracingContext"]: + return _current_tracing_context.get() + + def __enter__(self) -> "TracingContext": + _current_tracing_context.set(self) + return self + + def __exit__( + self, + type: Optional[Type[BaseException]], + exception: Optional[BaseException], + traceback: Optional[TracebackType], + ) -> Literal[False]: + _current_tracing_context.set(None) + + if exception is not None and type is not None: + self.finalise(exception=exception) + if get_context().should_log_exception_stack: + get_context().logger.exception("Could not finish operation") + else: + get_context().logger.error( + f"Could not finish operation because of {type.__name__}: {exception}" + ) + + assert self._trace is not None + if not self._do_not_persist_traces: + get_context().tracing_database.save(self._trace) + + return False + + +_current_tracing_context: ContextVar[Optional[TracingContext]] = ContextVar( + "_current_tracing_context", default=None +) diff --git a/great_ai/utilities/__init__.py b/great_ai/utilities/__init__.py new file mode 100644 index 0000000..2b52017 --- /dev/null +++ b/great_ai/utilities/__init__.py @@ -0,0 +1,16 @@ +from .chunk import chunk +from .clean import clean +from .config_file.config_file import ConfigFile +from .config_file.parse_error import ParseError +from .evaluate_ranking.evaluate_ranking import evaluate_ranking +from .get_sentences import get_sentences +from .language.english_name_of_language import english_name_of_language +from .language.is_english import is_english +from .language.predict_language import predict_language +from .logger.get_logger import get_logger +from .parallel_map.parallel_map import parallel_map +from .parallel_map.simple_parallel_map import simple_parallel_map +from .parallel_map.threaded_parallel_map import threaded_parallel_map +from .parallel_map.worker_exception import WorkerException +from .unchunk import unchunk +from .unique import unique diff --git a/great_ai/utilities/chunk.py b/great_ai/utilities/chunk.py new file mode 100644 index 0000000..a0663d1 --- /dev/null +++ b/great_ai/utilities/chunk.py @@ -0,0 +1,36 @@ +from typing import Iterable, List, TypeVar + +T = TypeVar("T") + + +def chunk(values: Iterable[T], chunk_size: int) -> Iterable[List[T]]: + """Turn an iterable of items into an iterable of lists (chunks) of items. + + Each returned chunk is of length `chunk_size` except the last one the length of + which is between 1 and `chunk_size`. + + Useful for parallel processing. + + Examples: + >>> list(chunk(range(10), chunk_size=3)) + [[0, 1, 2], [3, 4, 5], [6, 7, 8], [9]] + + Args: + values: The stream of items to pack into chunks. + chunk_size: Desired length of each (but the last) chunk. + + Yields: + The next chunk. + """ + + assert chunk_size >= 1 + + result: List[T] = [] + for v in values: + result.append(v) + if len(result) == chunk_size: + yield result + result = [] + + if len(result) > 0: + yield result diff --git a/src/great_ai/utilities/clean.py b/great_ai/utilities/clean.py similarity index 58% rename from src/great_ai/utilities/clean.py rename to great_ai/utilities/clean.py index 378320b..521ae52 100644 --- a/src/great_ai/utilities/clean.py +++ b/great_ai/utilities/clean.py @@ -6,7 +6,7 @@ import unidecode from .data import left_regular_punctuations, right_regular_punctuations from .external.pylatexenc.latex2text import LatexNodes2Text -from .logger import get_logger +from .logger.get_logger import get_logger logger = get_logger("clean") latex = LatexNodes2Text() @@ -23,6 +23,43 @@ def clean( remove_brackets: bool = False, convert_to_ascii: bool = False, ) -> str: + """Clean all XML, LaTeX, PDF-extraction, and Unicode artifacts from the text. + + The cleaning is quite heavy-weight and can be destructive. However, when working + with text, this is usually required to achieve sufficient cleanliness before further + processing. + + Optionally, the text can be turned into ASCII. Carefully consider whether this is + absolutely needed for your use-case. + + Examples: + >>> clean('

Bj\\\\"{o}rn is \\t \\\\textit{happy} 🙂 <3

') + 'Björn is happy 🙂 <3' + + >>> clean( + ... '

Bj\\\\"{o}rn is \\t \\\\textit{happy} 🙂 <3

', + ... convert_to_ascii=True + ... ) + 'Bjorn is happy <3' + + >>> clean( + ... '

Bj\\\\"{o}rn is \\t \\\\textit{happy} 🙂 <3

', + ... ignore_xml=True + ... ) + '

Björn is happy 🙂 lt;3

' + + Args: + text: Text to be cleaned. + ignore_xml: Do not process/remove XML-tags. + ignore_latex: Do not process/remove LaTeX-tags. + remove_brackets: Do not remove brackets ([]) + convert_to_ascii: Strip (or convert) non-ascii characters. + + Returns: + The cleaned input text with sensibly collapsed whitespace and optionally no + markup. + """ + if not ignore_xml: text = re.sub(r"<[^>]*>", " ", text) text = html.unescape(text) diff --git a/great_ai/utilities/config_file/__init__.py b/great_ai/utilities/config_file/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/great_ai/utilities/config_file/config_file.py b/great_ai/utilities/config_file/config_file.py new file mode 100644 index 0000000..1116833 --- /dev/null +++ b/great_ai/utilities/config_file/config_file.py @@ -0,0 +1,160 @@ +import os +from pathlib import Path +from typing import Dict, ItemsView, Iterator, KeysView, Mapping, Union, ValuesView + +from ..logger.get_logger import get_logger +from .parse_error import ParseError +from .pattern import pattern + +logger = get_logger("ConfigFile") + + +class ConfigFile(Mapping[str, str]): + """A small and safe `INI`-style configuration loader with `dict` and `ENV` support. + + The values can be accessed using both dot- and index-notation. It is compatible + with the `dict` interface. + + File format example: + + ```toml + # comments are allowed everywhere + + key = value # you can leave or omit whitespace around the equal-sign + my_hashtag = "#great_ai" # the r-value can be quoted with " or ' or `. + + my_var = my_default_value # Default values can be given to env-vars, + # see next line. The default value must come first. + + my_var = ENV:MY_ENV_VAR # If the value starts with the `ENV:` prefix, + # it is looked up from the environment variables. + ``` + + Examples: + >>> ConfigFile('tests/utilities/data/simple.conf') + ConfigFile(path=tests/utilities/data/simple.conf) {'zeroth_key': 'test', 'first_key': 'András'} + + >>> ConfigFile('tests/utilities/data/simple.conf').zeroth_key + 'test' + + >>> ConfigFile('tests/utilities/data/simple.conf').second_key + Traceback (most recent call last): + ... + KeyError: 'Key `second_key` is not found in configuration file ... + + >>> a = ConfigFile('tests/utilities/data/simple.conf') + >>> {**a} + {'zeroth_key': 'test', 'first_key': 'András'} + + """ + + ENVIRONMENT_VARIABLE_KEY_PREFIX = "ENV" + + def __init__(self, path: Union[Path, str], *, ignore_missing: bool = False) -> None: + """Load and parse a configuration file. + + Everything is eager-loaded, thus, exceptions may be thrown here. + + Args: + path: Local path of the configuration file. + ignore_missing: Don't raise an exception on missing environment variables. + + Raises: + FileNotFoundError: If there is no file at the specified path. + ParseError: If the provided file does not conform to the expected format. + KeyError: If there is duplication in the keys. + ValueError: If an environment variable is referenced but it is not set in + the system and `ignore_missing=False`. + """ + + if not isinstance(path, Path): + path = Path(path) + + if not path.exists(): + raise FileNotFoundError(path.absolute()) + + self._ignore_missing = ignore_missing + + self._path = path + self._key_values: Dict[str, str] = {} + + self._parse() + + @property + def path(self) -> Path: + """Original path from where the configuration was loaded.""" + return self._path + + def _parse(self) -> None: + with open(self._path, encoding="utf-8") as f: + lines: str = f.read() + + matches = pattern.findall(lines) + for key, *values in matches: + try: + value = next(v for v in values if v) + except StopIteration: + raise ParseError( + f"""Cannot parse config file ({ + self._path.absolute() + }), error at key `{key}`""" + ) + + already_exists = key in self._key_values + if already_exists and not value.startswith( + f"{self.ENVIRONMENT_VARIABLE_KEY_PREFIX}:" + ): + raise KeyError( + f"Key `{key}` has been already defined and its value is `{self._key_values[key]}`" + ) + + if value.startswith(f"{self.ENVIRONMENT_VARIABLE_KEY_PREFIX}:"): + _, value = value.split(":") + if value not in os.environ: + issue = f"""The value of `{key}` contains the "{ + self.ENVIRONMENT_VARIABLE_KEY_PREFIX + }` prefix but `{value}` is not defined as an environment variable""" + if already_exists: + logger.warning( + f"""{issue}, using the default value defined above (`{ + self._key_values[key] + }`)""" + ) + continue + elif self._ignore_missing: + logger.warning(issue) + else: + raise ValueError( + f"{issue} and no default value has been provided" + ) + else: + value = os.environ[value] + + self._key_values[key] = value + + def __getattr__(self, key: str) -> str: + if key in self._key_values: + return self._key_values[key] + raise KeyError( + f"Key `{key}` is not found in configuration file ({self._path.absolute()})" + ) + + __getitem__ = __getattr__ + + def __iter__(self) -> Iterator[str]: + return iter(self._key_values) + + def __len__(self) -> int: + return len(self._key_values) + + def keys(self) -> KeysView[str]: + return self._key_values.keys() + + def values(self) -> ValuesView[str]: + return self._key_values.values() + + def items(self) -> ItemsView[str, str]: + return self._key_values.items() + + def __repr__(self) -> str: + return f"{type(self).__name__}(path={self._path.as_posix()}) {self._key_values}" diff --git a/src/great_ai/utilities/config_file/parse_error.py b/great_ai/utilities/config_file/parse_error.py similarity index 100% rename from src/great_ai/utilities/config_file/parse_error.py rename to great_ai/utilities/config_file/parse_error.py diff --git a/src/great_ai/utilities/config_file/pattern.py b/great_ai/utilities/config_file/pattern.py similarity index 100% rename from src/great_ai/utilities/config_file/pattern.py rename to great_ai/utilities/config_file/pattern.py diff --git a/src/great_ai/utilities/data/__init__.py b/great_ai/utilities/data/__init__.py similarity index 100% rename from src/great_ai/utilities/data/__init__.py rename to great_ai/utilities/data/__init__.py diff --git a/src/great_ai/utilities/data/american_spellings.py b/great_ai/utilities/data/american_spellings.py similarity index 100% rename from src/great_ai/utilities/data/american_spellings.py rename to great_ai/utilities/data/american_spellings.py diff --git a/src/great_ai/utilities/data/punctuations.py b/great_ai/utilities/data/punctuations.py similarity index 100% rename from src/great_ai/utilities/data/punctuations.py rename to great_ai/utilities/data/punctuations.py diff --git a/great_ai/utilities/evaluate_ranking/__init__.py b/great_ai/utilities/evaluate_ranking/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/great_ai/utilities/evaluate_ranking/draw_f1_iso_lines.py b/great_ai/utilities/evaluate_ranking/draw_f1_iso_lines.py similarity index 100% rename from src/great_ai/utilities/evaluate_ranking/draw_f1_iso_lines.py rename to great_ai/utilities/evaluate_ranking/draw_f1_iso_lines.py diff --git a/src/great_ai/utilities/evaluate_ranking/evaluate_ranking.py b/great_ai/utilities/evaluate_ranking/evaluate_ranking.py similarity index 55% rename from src/great_ai/utilities/evaluate_ranking/evaluate_ranking.py rename to great_ai/utilities/evaluate_ranking/evaluate_ranking.py index 78d9a80..a613c93 100644 --- a/src/great_ai/utilities/evaluate_ranking/evaluate_ranking.py +++ b/great_ai/utilities/evaluate_ranking/evaluate_ranking.py @@ -1,17 +1,19 @@ from pathlib import Path -from typing import Dict, List, Optional, Union +from typing import Dict, List, Optional, TypeVar import matplotlib import matplotlib.pyplot as plt import numpy as np -from sklearn.metrics import average_precision_score, precision_recall_curve +from sklearn.metrics import average_precision_score from ..unique import unique from .draw_f1_iso_lines import draw_f1_iso_lines +T = TypeVar("T", str, float) + def evaluate_ranking( - expected: List[Union[str, float]], + expected: List[T], actual_scores: List[float], target_recall: float, title: Optional[str] = "", @@ -20,15 +22,35 @@ def evaluate_ranking( output_svg: Optional[Path] = None, reverse_order: bool = False, plot: bool = True, -) -> Dict[Union[str, float], float]: +) -> Dict[T, float]: + """Render the Precision-Recall curve of a ranking. + + And improved version of scikit-learn's [PR-curve](https://scikit-learn.org/stable/auto_examples/model_selection/plot_precision_recall.html#sphx-glr-auto-examples-model-selection-plot-precision-recall-py) + + Args: + expected: Expected ordering of the elements + (rank if it's an integer, alphabetical if a string) + actual_scores: Actual ranking scores (need not be on the same scale as + `expected`) + title: Title of the plot. + disable_interpolation: Do not interpolate. + axes: Matplotlib axes for plotting inside a subplot. + output_svg: If specified, save the chart as an svg to the given Path. + reverse_order: Reverse the ranking specified by `expected`. + plot: Display a plot on the screen. + + Returns: + Precision values at given recall. + """ + assert 0 <= target_recall <= 1 if plot and axes is None: - fig = plt.figure(figsize=(20, 10)) + fig = plt.figure(figsize=(10, 10)) fig.patch.set_facecolor("white") ax = plt.axes() else: - ax = axes + ax = axes # type: ignore[assignment] classes = sorted(unique(expected), reverse=reverse_order) str_classes = [str(c) for c in classes] @@ -39,21 +61,29 @@ def evaluate_ranking( draw_f1_iso_lines(axes=ax) - results: Dict[Union[str, float], float] = {} + results: Dict[T, float] = {} for i in range(len(classes) - 1): binarized_expected = [ (v < classes[i]) if reverse_order else (v > classes[i]) for v in expected ] - precision, recall, _ = precision_recall_curve( - binarized_expected, actual_scores + + sorted_expected_actual = sorted( + zip(binarized_expected, actual_scores), key=lambda v: v[1], reverse=True ) + precision = [] + recall = [] + correct = 0 + for all, (e, score) in enumerate(sorted_expected_actual, start=1): + correct += int(e) + precision.append(correct / all) + recall.append(all / len(sorted_expected_actual)) if not disable_interpolation: - for j in range(1, len(precision)): - precision[j] = max(precision[j - 1], precision[j]) + for j in range(len(precision) - 2, -1, -1): + precision[j] = max(precision[j], precision[j + 1]) - closest_recall_index = np.argmin(np.abs(recall - target_recall)) + closest_recall_index = np.argmin(np.abs(np.array(recall) - target_recall)) precision_at_closest_recall = precision[closest_recall_index] average_precision = average_precision_score( binarized_expected, actual_scores diff --git a/great_ai/utilities/external/__init__.py b/great_ai/utilities/external/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/great_ai/utilities/external/pylatexenc/README.md b/great_ai/utilities/external/pylatexenc/README.md similarity index 100% rename from src/great_ai/utilities/external/pylatexenc/README.md rename to great_ai/utilities/external/pylatexenc/README.md diff --git a/src/great_ai/utilities/external/pylatexenc/__init__.py b/great_ai/utilities/external/pylatexenc/__init__.py similarity index 100% rename from src/great_ai/utilities/external/pylatexenc/__init__.py rename to great_ai/utilities/external/pylatexenc/__init__.py diff --git a/src/great_ai/utilities/external/pylatexenc/_util.py b/great_ai/utilities/external/pylatexenc/_util.py similarity index 100% rename from src/great_ai/utilities/external/pylatexenc/_util.py rename to great_ai/utilities/external/pylatexenc/_util.py diff --git a/src/great_ai/utilities/external/pylatexenc/latex2text/__init__.py b/great_ai/utilities/external/pylatexenc/latex2text/__init__.py similarity index 99% rename from src/great_ai/utilities/external/pylatexenc/latex2text/__init__.py rename to great_ai/utilities/external/pylatexenc/latex2text/__init__.py index d8ae865..41b23b0 100644 --- a/src/great_ai/utilities/external/pylatexenc/latex2text/__init__.py +++ b/great_ai/utilities/external/pylatexenc/latex2text/__init__.py @@ -1549,7 +1549,7 @@ def latex2text( "in favor of the `pylatexenc.latex2text.LatexNodes2Text` class.", ) - (nodelist, tpos, tlen) = latexwalker.get_latex_nodes( + nodelist, tpos, tlen = latexwalker.get_latex_nodes( content, keep_inline_math=keep_inline_math, tolerant_parsing=tolerant_parsing ) diff --git a/src/great_ai/utilities/external/pylatexenc/latex2text/__main__.py b/great_ai/utilities/external/pylatexenc/latex2text/__main__.py similarity index 99% rename from src/great_ai/utilities/external/pylatexenc/latex2text/__main__.py rename to great_ai/utilities/external/pylatexenc/latex2text/__main__.py index a19f9b6..4f9808f 100644 --- a/src/great_ai/utilities/external/pylatexenc/latex2text/__main__.py +++ b/great_ai/utilities/external/pylatexenc/latex2text/__main__.py @@ -289,7 +289,7 @@ def main(argv=None): latex, tolerant_parsing=args.tolerant_parsing, strict_braces=args.strict_braces ) - (nodelist, pos, len_) = lw.get_latex_nodes() + nodelist, pos, len_ = lw.get_latex_nodes() ln2t = LatexNodes2Text( math_mode=args.math_mode, diff --git a/src/great_ai/utilities/external/pylatexenc/latex2text/_defaultspecs.py b/great_ai/utilities/external/pylatexenc/latex2text/_defaultspecs.py similarity index 99% rename from src/great_ai/utilities/external/pylatexenc/latex2text/_defaultspecs.py rename to great_ai/utilities/external/pylatexenc/latex2text/_defaultspecs.py index e4a3e76..86e3ef0 100644 --- a/src/great_ai/utilities/external/pylatexenc/latex2text/_defaultspecs.py +++ b/great_ai/utilities/external/pylatexenc/latex2text/_defaultspecs.py @@ -1774,7 +1774,7 @@ def make_accented_char(node, combining, l2tobj): for u in unicode_accents_list: - (mname, mcombining) = u + mname, mcombining = u _latex_specs_base["macros"].append( MacroTextSpec( mname, lambda x, l2tobj, c=mcombining: make_accented_char(x, c, l2tobj) diff --git a/src/great_ai/utilities/external/pylatexenc/latexencode/__init__.py b/great_ai/utilities/external/pylatexenc/latexencode/__init__.py similarity index 97% rename from src/great_ai/utilities/external/pylatexenc/latexencode/__init__.py rename to great_ai/utilities/external/pylatexenc/latexencode/__init__.py index 06f4a61..ce77cd7 100644 --- a/src/great_ai/utilities/external/pylatexenc/latexencode/__init__.py +++ b/great_ai/utilities/external/pylatexenc/latexencode/__init__.py @@ -30,7 +30,6 @@ convert a unicode string to LaTeX escape sequences. For basic usage you can use the :py:func:`unicode_to_latex()` function directly:: - >>> from pylatexenc.latexencode import unicode_to_latex >>> print(unicode_to_latex('À votre santé')) \`A votre sant\'e >>> print(unicode_to_latex('The length of samples #3 & #4 is 3μm')) @@ -41,21 +40,16 @@ you are converting multiple strings, you may create an instance with the flags you like and invoke its method :py:meth:`~UnicodeToLatexEncoder.unicode_to_latex()` as many times as necessary:: - >>> from pylatexenc.latexencode import UnicodeToLatexEncoder >>> u = UnicodeToLatexEncoder(unknown_char_policy='replace') >>> print(u.unicode_to_latex('À votre santé')) \`A votre sant\'e >>> print(u.unicode_to_latex('The length of samples #3 & #4 is 3μm')) The length of samples \#3 \& \#4 is 3\ensuremath{\mu}m >>> print(u.unicode_to_latex('À votre santé: 乾杯')) - No known latex representation for character: U+4E7E - ‘乾’ - No known latex representation for character: U+676F - ‘杯’ \`A votre sant\'e: {\bfseries ?}{\bfseries ?} Example using custom conversion rules:: - - >>> from pylatexenc.latexencode import UnicodeToLatexEncoder, \ - ... UnicodeToLatexConversionRule, RULE_REGEX + >>> import re >>> u = UnicodeToLatexEncoder( ... conversion_rules=[ ... UnicodeToLatexConversionRule(rule_type=RULE_REGEX, rule=[ diff --git a/src/great_ai/utilities/external/pylatexenc/latexencode/__main__.py b/great_ai/utilities/external/pylatexenc/latexencode/__main__.py similarity index 100% rename from src/great_ai/utilities/external/pylatexenc/latexencode/__main__.py rename to great_ai/utilities/external/pylatexenc/latexencode/__main__.py diff --git a/src/great_ai/utilities/external/pylatexenc/latexencode/_partial_latex_encoder.py b/great_ai/utilities/external/pylatexenc/latexencode/_partial_latex_encoder.py similarity index 99% rename from src/great_ai/utilities/external/pylatexenc/latexencode/_partial_latex_encoder.py rename to great_ai/utilities/external/pylatexenc/latexencode/_partial_latex_encoder.py index 393551d..6162ad6 100644 --- a/src/great_ai/utilities/external/pylatexenc/latexencode/_partial_latex_encoder.py +++ b/great_ai/utilities/external/pylatexenc/latexencode/_partial_latex_encoder.py @@ -71,7 +71,7 @@ class PartialLatexToLatexEncoder(UnicodeToLatexEncoder): # keyword arguments: keep_latex_chars=r"\${}^_", conversion_rules=None, - **kwargs + **kwargs, ): base_conversion_rules = conversion_rules @@ -89,7 +89,7 @@ class PartialLatexToLatexEncoder(UnicodeToLatexEncoder): ) ] + base_conversion_rules, - **kwargs + **kwargs, ) self.keep_latex_chars = keep_latex_chars diff --git a/src/great_ai/utilities/external/pylatexenc/latexencode/_uni2latexmap.py b/great_ai/utilities/external/pylatexenc/latexencode/_uni2latexmap.py similarity index 100% rename from src/great_ai/utilities/external/pylatexenc/latexencode/_uni2latexmap.py rename to great_ai/utilities/external/pylatexenc/latexencode/_uni2latexmap.py diff --git a/src/great_ai/utilities/external/pylatexenc/latexencode/_uni2latexmap_xml.py b/great_ai/utilities/external/pylatexenc/latexencode/_uni2latexmap_xml.py similarity index 100% rename from src/great_ai/utilities/external/pylatexenc/latexencode/_uni2latexmap_xml.py rename to great_ai/utilities/external/pylatexenc/latexencode/_uni2latexmap_xml.py diff --git a/src/great_ai/utilities/external/pylatexenc/latexencode/_unicode_to_latex_encoder.py b/great_ai/utilities/external/pylatexenc/latexencode/_unicode_to_latex_encoder.py similarity index 99% rename from src/great_ai/utilities/external/pylatexenc/latexencode/_unicode_to_latex_encoder.py rename to great_ai/utilities/external/pylatexenc/latexencode/_unicode_to_latex_encoder.py index fbc5a47..af54052 100644 --- a/src/great_ai/utilities/external/pylatexenc/latexencode/_unicode_to_latex_encoder.py +++ b/great_ai/utilities/external/pylatexenc/latexencode/_unicode_to_latex_encoder.py @@ -617,7 +617,7 @@ class UnicodeToLatexEncoder(object): res = rulecallable(s, p.pos) if res is None: return None - (consumed, repl) = res + consumed, repl = res self._apply_replacement(p, repl, consumed, rule) return True diff --git a/src/great_ai/utilities/external/pylatexenc/latexwalker/__init__.py b/great_ai/utilities/external/pylatexenc/latexwalker/__init__.py similarity index 98% rename from src/great_ai/utilities/external/pylatexenc/latexwalker/__init__.py rename to great_ai/utilities/external/pylatexenc/latexwalker/__init__.py index 4b12068..60685e9 100644 --- a/src/great_ai/utilities/external/pylatexenc/latexwalker/__init__.py +++ b/great_ai/utilities/external/pylatexenc/latexwalker/__init__.py @@ -34,7 +34,6 @@ database searches of LaTeX content.) Simple example usage:: - >>> from pylatexenc.latexwalker import LatexWalker, LatexEnvironmentNode >>> w = LatexWalker(r""" ... \textbf{Hi there!} Here is \emph{a list}: ... \begin{enumerate}[label=(i)] @@ -45,12 +44,9 @@ Simple example usage:: ... """) >>> (nodelist, pos, len_) = w.get_latex_nodes(pos=0) >>> nodelist[0] - LatexCharsNode(pos=0, len=1, chars='\n') + LatexCharsNode(parsing_state=..., pos=0, len=1, chars='\n') >>> nodelist[1] - LatexMacroNode(pos=1, len=18, macroname='textbf', - nodeargd=ParsedMacroArgs(argnlist=[LatexGroupNode(pos=8, len=11, - nodelist=[LatexCharsNode(pos=9, len=9, chars='Hi there!')], - delimiters=('{', '}'))], argspec='{'), macro_post_space='') + LatexMacroNode(parsing_state=..., pos=1, len=18, macroname='textbf', nodeargd=ParsedMacroArgs(argspec='{', argnlist=[LatexGroupNode(parsing_state=..., pos=8, len=11, nodelist=[LatexCharsNode(parsing_state=..., pos=9, len=9, chars='Hi there!')], delimiters=('{', '}'))]), macro_post_space='') >>> nodelist[5].isNodeType(LatexEnvironmentNode) True >>> nodelist[5].environmentname @@ -58,8 +54,7 @@ Simple example usage:: >>> nodelist[5].nodeargd.argspec '[' >>> nodelist[5].nodeargd.argnlist - [LatexGroupNode(pos=60, len=11, nodelist=[LatexCharsNode(pos=61, len=9, - chars='label=(i)')], delimiters=('[', ']'))] + [LatexGroupNode(parsing_state=..., pos=60, len=11, nodelist=[LatexCharsNode(parsing_state=..., pos=61, len=9, chars='label=(i)')], delimiters=('[', ']'))] >>> nodelist[7].latex_verbatim() '$x$' @@ -482,7 +477,7 @@ class LatexNode(object): parsing_state=None, pos=None, len=None, - **kwargs + **kwargs, ): # Important: subclasses must specify a list of fields they set in the @@ -612,7 +607,7 @@ class LatexGroupNode(LatexNode): "nodelist", "delimiters", ), - **kwargs + **kwargs, ) self.nodelist = nodelist self.delimiters = delimiters @@ -644,7 +639,7 @@ class LatexCommentNode(LatexNode): "comment", "comment_post_space", ), - **kwargs + **kwargs, ) self.comment = comment @@ -720,7 +715,7 @@ class LatexMacroNode(LatexNode): super(LatexMacroNode, self).__init__( _fields=("macroname", "nodeargd", "macro_post_space"), _redundant_fields=("nodeoptarg", "nodeargs"), - **kwargs + **kwargs, ) self.macroname = macroname @@ -806,7 +801,7 @@ class LatexEnvironmentNode(LatexNode): "optargs", "args", ), - **kwargs + **kwargs, ) self.environmentname = environmentname @@ -1269,7 +1264,7 @@ class LatexWalker(object): environments=True, keep_inline_math=None, parsing_state=None, - **kwargs + **kwargs, ): r""" Parses the latex content given to the constructor (and stored in `self.s`), @@ -1633,7 +1628,7 @@ class LatexWalker(object): r"Expected expression, got \end", self.s, pos, - **self.pos_to_lineno_colno(pos, as_dict=True) + **self.pos_to_lineno_colno(pos, as_dict=True), ) else: return self._mknodeposlen( @@ -1679,7 +1674,7 @@ class LatexWalker(object): "Expected expression, got closing brace '{}'".format(tok.arg), self.s, pos, - **self.pos_to_lineno_colno(pos, as_dict=True) + **self.pos_to_lineno_colno(pos, as_dict=True), ) return self._mknodeposlen( LatexCharsNode, @@ -1722,7 +1717,7 @@ class LatexWalker(object): "Unknown token type: {}".format(tok.tok), self.s, pos, - **self.pos_to_lineno_colno(pos, as_dict=True) + **self.pos_to_lineno_colno(pos, as_dict=True), ) def get_latex_maybe_optional_arg(self, pos, parsing_state=None): @@ -1826,10 +1821,10 @@ class LatexWalker(object): pos=pos, msg="get_latex_braced_group: not an opening brace/bracket: %s" % (self.s[pos]), - **self.pos_to_lineno_colno(pos, as_dict=True) + **self.pos_to_lineno_colno(pos, as_dict=True), ) - (nodelist, npos, nlen) = self.get_latex_nodes( + nodelist, npos, nlen = self.get_latex_nodes( firsttok.pos + firsttok.len, stop_upon_closing_brace=(brace_type, closing_brace), parsing_state=parsing_state, @@ -1888,12 +1883,14 @@ class LatexWalker(object): pos=pos, msg=r"get_latex_environment: expected \begin{%s}: %s" % ( - environmentname - if environmentname is not None - else "", + ( + environmentname + if environmentname is not None + else "" + ), firsttok.arg, ), - **self.pos_to_lineno_colno(pos, as_dict=True) + **self.pos_to_lineno_colno(pos, as_dict=True), ) if environmentname is None: environmentname = firsttok.arg @@ -1920,9 +1917,9 @@ class LatexWalker(object): argsresult = (None, pos, 0, {}) if len(argsresult) == 4: - (argd, apos, alen, adic) = argsresult + argd, apos, alen, adic = argsresult else: - (argd, apos, alen) = argsresult + argd, apos, alen = argsresult adic = {} pos = apos + alen @@ -1935,7 +1932,7 @@ class LatexWalker(object): math_mode_delimiter="{" + environmentname + "}", ) - (nodelist, npos, nlen) = self.get_latex_nodes( + nodelist, npos, nlen = self.get_latex_nodes( pos, stop_upon_end_environment=environmentname, parsing_state=parsing_state_inner, @@ -1980,7 +1977,7 @@ class LatexWalker(object): s=self.s, pos=tok.pos, msg="End of input while parsing {}".format(what), - **self.pos_to_lineno_colno(tok.pos, as_dict=True) + **self.pos_to_lineno_colno(tok.pos, as_dict=True), ) if getattr(e, "pos", None) is not None and e.lineno is None and e.colno is None: @@ -2232,7 +2229,7 @@ class LatexWalker(object): s=self.s, pos=tok.pos, msg="Unexpected mismatching closing brace: '%s'" % (tok.arg), - **self.pos_to_lineno_colno(tok.pos, as_dict=True) + **self.pos_to_lineno_colno(tok.pos, as_dict=True), ) return True @@ -2244,7 +2241,7 @@ class LatexWalker(object): s=self.s, pos=tok.pos, msg=("Unexpected closing environment: '{}'".format(tok.arg)), - **self.pos_to_lineno_colno(tok.pos, as_dict=True) + **self.pos_to_lineno_colno(tok.pos, as_dict=True), ) elif tok.arg != stop_upon_end_environment: # p.push_lastchars(tok_to_pos_and_chars_from_ppos(tok)) @@ -2257,7 +2254,7 @@ class LatexWalker(object): tok.arg, stop_upon_end_environment ) ), - **self.pos_to_lineno_colno(tok.pos, as_dict=True) + **self.pos_to_lineno_colno(tok.pos, as_dict=True), ) return True @@ -2281,7 +2278,7 @@ class LatexWalker(object): tok.arg, stop_upon_closing_mathmode, ), - **self.pos_to_lineno_colno(tok.pos, as_dict=True) + **self.pos_to_lineno_colno(tok.pos, as_dict=True), ) # all ok, this is a new math mode opening. Keep an assert # in case we forget to include some math-mode delimiters in @@ -2296,7 +2293,7 @@ class LatexWalker(object): s=self.s, pos=tok.pos, msg="Unexpected closing math mode: '{}'".format(tok.arg), - **self.pos_to_lineno_colno(tok.pos, as_dict=True) + **self.pos_to_lineno_colno(tok.pos, as_dict=True), ) # we have encountered a new math inline, parse the math expression @@ -2311,7 +2308,7 @@ class LatexWalker(object): ) try: - (mathinline_nodelist, mpos, mlen) = self.get_latex_nodes( + mathinline_nodelist, mpos, mlen = self.get_latex_nodes( p.pos, stop_upon_closing_mathmode=corresponding_closing_mathmode, parsing_state=parsing_state_inner, @@ -2321,7 +2318,7 @@ class LatexWalker(object): _maketuple( 'math mode "{}"'.format(tok.arg), tok.pos, - *self.pos_to_lineno_colno(tok.pos) + *self.pos_to_lineno_colno(tok.pos), ) ) raise @@ -2359,7 +2356,7 @@ class LatexWalker(object): if tok.tok == "brace_open": # another braced group to read. try: - (groupnode, bpos, blen) = self.get_latex_braced_group( + groupnode, bpos, blen = self.get_latex_braced_group( tok.pos, brace_type=tok.arg, parsing_state=p.parsing_state ) # except LatexWalkerEndOfStream as e: @@ -2381,7 +2378,7 @@ class LatexWalker(object): if tok.tok == "begin_environment": # an environment to read. try: - (envnode, epos, elen) = self.get_latex_environment( + envnode, epos, elen = self.get_latex_environment( tok.pos, environmentname=tok.arg, parsing_state=p.parsing_state ) except LatexWalkerParseError as e: @@ -2389,7 +2386,7 @@ class LatexWalker(object): _maketuple( 'begin environment "{}"'.format(tok.arg), tok.pos, - *self.pos_to_lineno_colno(tok.pos) + *self.pos_to_lineno_colno(tok.pos), ) ) raise @@ -2420,9 +2417,9 @@ class LatexWalker(object): margsresult = (None, tok.pos + tok.len, 0, {}) if len(margsresult) == 4: - (nodeargd, mapos, malen, mdic) = margsresult + nodeargd, mapos, malen, mdic = margsresult else: - (nodeargd, mapos, malen) = margsresult + nodeargd, mapos, malen = margsresult mdic = {} p.pos = mapos + malen @@ -2478,9 +2475,9 @@ class LatexWalker(object): if res is not None: # specials expects arguments, read them if len(res) == 4: - (nodeargd, mapos, malen, spdic) = res + nodeargd, mapos, malen, spdic = res else: - (nodeargd, mapos, malen) = res + nodeargd, mapos, malen = res spdic = {} p.pos = mapos + malen @@ -2510,7 +2507,7 @@ class LatexWalker(object): s=self.s, pos=p.pos, msg="Unknown token: {!r}".format(tok), - **self.pos_to_lineno_colno(p.pos, as_dict=True) + **self.pos_to_lineno_colno(p.pos, as_dict=True), ) while True: @@ -2536,7 +2533,7 @@ class LatexWalker(object): msg="Unexpected end of stream, was expecting {}".format( expecting ), - **self.pos_to_lineno_colno(len(self.s), as_dict=True) + **self.pos_to_lineno_colno(len(self.s), as_dict=True), ) if self.tolerant_parsing: r_endnow = True @@ -2656,7 +2653,7 @@ def get_latex_nodes( stop_upon_closing_brace=None, stop_upon_end_environment=None, stop_upon_closing_mathmode=None, - **parse_flags + **parse_flags, ): """ Parses latex content `s`. diff --git a/src/great_ai/utilities/external/pylatexenc/latexwalker/__main__.py b/great_ai/utilities/external/pylatexenc/latexwalker/__main__.py similarity index 99% rename from src/great_ai/utilities/external/pylatexenc/latexwalker/__main__.py rename to great_ai/utilities/external/pylatexenc/latexwalker/__main__.py index fe95f0b..46eccff 100644 --- a/src/great_ai/utilities/external/pylatexenc/latexwalker/__main__.py +++ b/great_ai/utilities/external/pylatexenc/latexwalker/__main__.py @@ -184,7 +184,7 @@ def main(argv=None): latex, tolerant_parsing=args.tolerant_parsing, strict_braces=args.strict_braces ) - (nodelist, pos, len_) = latexwalker.get_latex_nodes() + nodelist, pos, len_ = latexwalker.get_latex_nodes() if args.output_format == "human": print("\n--- NODES ---\n") diff --git a/src/great_ai/utilities/external/pylatexenc/latexwalker/_defaultspecs.py b/great_ai/utilities/external/pylatexenc/latexwalker/_defaultspecs.py similarity index 100% rename from src/great_ai/utilities/external/pylatexenc/latexwalker/_defaultspecs.py rename to great_ai/utilities/external/pylatexenc/latexwalker/_defaultspecs.py diff --git a/src/great_ai/utilities/external/pylatexenc/macrospec/__init__.py b/great_ai/utilities/external/pylatexenc/macrospec/__init__.py similarity index 99% rename from src/great_ai/utilities/external/pylatexenc/macrospec/__init__.py rename to great_ai/utilities/external/pylatexenc/macrospec/__init__.py index 9975837..66ab0de 100644 --- a/src/great_ai/utilities/external/pylatexenc/macrospec/__init__.py +++ b/great_ai/utilities/external/pylatexenc/macrospec/__init__.py @@ -34,7 +34,6 @@ macros and environments, specifying how they should be parsed by `pylatexenc 2.0`. """ - import sys if sys.version_info.major > 2: @@ -154,7 +153,7 @@ class EnvironmentSpec(object): environmentname, args_parser=MacroStandardArgsParser(), is_math_mode=False, - **kwargs + **kwargs, ): super(EnvironmentSpec, self).__init__(**kwargs) self.environmentname = environmentname @@ -776,9 +775,9 @@ class LatexContextDb(object): new_context.add_context_category( cat, macros=self.d[cat]["macros"].values() if keep_macros else [], - environments=self.d[cat]["environments"].values() - if keep_environments - else [], + environments=( + self.d[cat]["environments"].values() if keep_environments else [] + ), specials=self.d[cat]["specials"].values() if keep_specials else [], ) diff --git a/src/great_ai/utilities/external/pylatexenc/macrospec/_argparsers.py b/great_ai/utilities/external/pylatexenc/macrospec/_argparsers.py similarity index 99% rename from src/great_ai/utilities/external/pylatexenc/macrospec/_argparsers.py rename to great_ai/utilities/external/pylatexenc/macrospec/_argparsers.py index 7fb20e8..abadc40 100644 --- a/src/great_ai/utilities/external/pylatexenc/macrospec/_argparsers.py +++ b/great_ai/utilities/external/pylatexenc/macrospec/_argparsers.py @@ -296,7 +296,7 @@ class MacroStandardArgsParser(object): for j, argt in enumerate(self.argspec): if argt == "{": - (node, np, nl) = w.get_latex_expression( + node, np, nl = w.get_latex_expression( p, strict_braces=False, parsing_state=get_inner_parsing_state(j) ) p = np + nl @@ -315,7 +315,7 @@ class MacroStandardArgsParser(object): if optarginfotuple is None: argnlist.append(None) continue - (node, np, nl) = optarginfotuple + node, np, nl = optarginfotuple p = np + nl argnlist.append(node) diff --git a/src/great_ai/utilities/external/pylatexenc/version.py b/great_ai/utilities/external/pylatexenc/version.py similarity index 100% rename from src/great_ai/utilities/external/pylatexenc/version.py rename to great_ai/utilities/external/pylatexenc/version.py diff --git a/src/great_ai/utilities/get_sentences.py b/great_ai/utilities/get_sentences.py similarity index 54% rename from src/great_ai/utilities/get_sentences.py rename to great_ai/utilities/get_sentences.py index 1a507dc..8cb05f3 100644 --- a/src/great_ai/utilities/get_sentences.py +++ b/great_ai/utilities/get_sentences.py @@ -16,6 +16,32 @@ def get_sentences( true_case: bool = False, remove_punctuation: bool = False, ) -> List[str]: + """Return the list of sentences found in the input text. + + Use [syntok](https://github.com/fnl/syntok) to segment the sentences. Further + processing can be enabled with optional arguments. + + Examples: + >>> get_sentences('This is a sentence. This is a half') + ['This is a sentence.', 'This is a half'] + + >>> get_sentences('This is a sentence. This is a half', ignore_partial=True) + ['This is a sentence.'] + + >>> get_sentences('I like Apple.', true_case=True, remove_punctuation=True) + ['i like Apple'] + + Args: + text: Text to be segmented into sentences. + ignore_partial: Filter out sentences that are not capitalised/don't end with a + punctuation. + true_case: Crude method: lowercase the first word of each sentence. + remove_punctuation: Remove all kinds of punctuation. + + Returns: + The found sentences (with partial sentences optionally filtered out). + """ + tokenizer = Tokenizer( emit_hyphen_or_underscore_sep=True, replace_not_contraction=False ) diff --git a/great_ai/utilities/language/__init__.py b/great_ai/utilities/language/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/great_ai/utilities/language/english_name_of_language.py b/great_ai/utilities/language/english_name_of_language.py new file mode 100644 index 0000000..2503c98 --- /dev/null +++ b/great_ai/utilities/language/english_name_of_language.py @@ -0,0 +1,30 @@ +from typing import Optional + +from langcodes import Language + + +def english_name_of_language(language_code: Optional[str]) -> str: + """Human-friendly English name of language from its `language_code`. + + A thin wrapper over [langcodes](https://github.com/rspeer/langcodes) for convenient + language tagging. + + Examples: + >>> english_name_of_language('en-US') + 'English (United States)' + + >>> english_name_of_language('und') + 'Unknown language' + + Args: + language_code: Language code, for example, returned by + [great_ai.utilities.language.predict_language.predict_language][]. + + Returns: + English name of language. + """ + + if not language_code: + language_code = "und" + + return Language.get(language_code).display_name() diff --git a/great_ai/utilities/language/is_english.py b/great_ai/utilities/language/is_english.py new file mode 100644 index 0000000..3652f57 --- /dev/null +++ b/great_ai/utilities/language/is_english.py @@ -0,0 +1,33 @@ +from typing import Optional + +from langcodes import standardize_tag, tag_distance + + +def is_english(language_code: Optional[str]) -> bool: + """Decide whether the `language_code` is of an English language. + + A thin wrapper over [langcodes](https://github.com/rspeer/langcodes) for convenient + language tagging. + + Examples: + >>> is_english('en-US') + True + + >>> is_english(None) + False + + >>> is_english('und') + False + + Args: + language_code: Language code, for example, returned by + `[great_ai.utilities.language.predict_language.predict_language][]. + + Returns: + Boolean indicating whether it's English. + """ + if not language_code: + language_code = "und" + + language_code = standardize_tag(language_code) + return tag_distance(language_code, "en") < 15 diff --git a/great_ai/utilities/language/predict_language.py b/great_ai/utilities/language/predict_language.py new file mode 100644 index 0000000..475994a --- /dev/null +++ b/great_ai/utilities/language/predict_language.py @@ -0,0 +1,33 @@ +from typing import Optional + +from langcodes import Language +from langdetect import LangDetectException, detect + + +def predict_language(text: Optional[str]) -> str: + """Predict the language code from text. + + A thin wrapper over [langcodes](https://github.com/rspeer/langcodes) for convenient + language tagging. + + Examples: + >>> predict_language('This is a sentence.') + 'en' + + Args: + text: Text used for prediction. + + Returns: + The predicted language code (en, en-US) or `und` if a prediction could not be + made. + """ + + if not text: + return Language.make().to_tag() + + try: + language_code = detect(text) + except LangDetectException: + return Language.make().to_tag() + + return Language.get(language_code).to_tag() diff --git a/great_ai/utilities/logger/__init__.py b/great_ai/utilities/logger/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/great_ai/utilities/logger/colors.py b/great_ai/utilities/logger/colors.py similarity index 100% rename from src/great_ai/utilities/logger/colors.py rename to great_ai/utilities/logger/colors.py diff --git a/great_ai/utilities/logger/custom_formatter.py b/great_ai/utilities/logger/custom_formatter.py new file mode 100644 index 0000000..6d3fcf1 --- /dev/null +++ b/great_ai/utilities/logger/custom_formatter.py @@ -0,0 +1,23 @@ +import logging +from typing import Any + +from .colors import BLUE, BOLD_RED, GREY, RED, RESET, YELLOW + + +class CustomFormatter(logging.Formatter): + def __init__(self, fmt: str, *args: Any, **kwargs: Any): + self._log_format = fmt + self._date_format = "%Y-%m-%d %H:%M:%S" + + self._color_mapping = { + logging.DEBUG: GREY + fmt + RESET, + logging.INFO: BLUE + fmt + RESET, + logging.WARNING: YELLOW + fmt + RESET, + logging.ERROR: RED + fmt + RESET, + logging.CRITICAL: BOLD_RED + fmt + RESET, + } + + def format(self, record: logging.LogRecord) -> str: + log_format = self._color_mapping.get(record.levelno) + formatter = logging.Formatter(log_format, self._date_format) + return formatter.format(record) diff --git a/great_ai/utilities/logger/get_logger.py b/great_ai/utilities/logger/get_logger.py new file mode 100644 index 0000000..c12ed19 --- /dev/null +++ b/great_ai/utilities/logger/get_logger.py @@ -0,0 +1,36 @@ +import logging +from typing import Dict + +from .custom_formatter import CustomFormatter + +loggers: Dict[str, logging.Logger] = {} + + +def get_logger( + name: str, level: int = logging.INFO, disable_colors: bool = False +) -> logging.Logger: + """Return a customised logger used throughout the GreatAI codebase. + + Uses colors, and only prints timestamps when not running inside notebook. + """ + + if name not in loggers: + logger = logging.getLogger(name) + logger.setLevel(level) + + try: + get_ipython() # type: ignore + log_format = "%(message)s" + except NameError: + # will fail outside of a notebook https://ipython.org/ + log_format = "%(asctime)s | %(levelname)8s | %(message)s" + + stdout_handler = logging.StreamHandler() + stdout_handler.setLevel(level) + if not disable_colors: + stdout_handler.setFormatter(CustomFormatter(log_format)) + + logger.addHandler(stdout_handler) + loggers[name] = logger + + return loggers[name] diff --git a/great_ai/utilities/parallel_map/__init__.py b/great_ai/utilities/parallel_map/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/great_ai/utilities/parallel_map/get_config.py b/great_ai/utilities/parallel_map/get_config.py new file mode 100644 index 0000000..6d42bb7 --- /dev/null +++ b/great_ai/utilities/parallel_map/get_config.py @@ -0,0 +1,52 @@ +import os +from math import ceil +from typing import Callable, Iterable, Optional, Sequence, Union + +from ..logger.get_logger import get_logger +from .parallel_map_configuration import ParallelMapConfiguration + +logger = get_logger("parallel_map") + + +def get_config( + *, + function: Callable, + input_values: Union[Sequence, Iterable], + chunk_size: Optional[int], + concurrency: Optional[int], +) -> ParallelMapConfiguration: + + is_input_sequence = hasattr(input_values, "__len__") + input_length = len(input_values) if is_input_sequence else None # type: ignore + + if concurrency is None: + concurrency = os.cpu_count() or 1 + assert concurrency >= 1, "At least one mapper process has to be created" + + if chunk_size is None: + if input_length is not None: + chunk_size = max(1, ceil(input_length / concurrency / 10)) + else: + raise ValueError( + "The argument for `values` does not implement `__len__`, therefore, you must provide a `chunk_size`" + ) + assert chunk_size >= 1, "Chunks have to contain at least one element" + + chunk_count: Optional[int] = None + if input_length is not None: + chunk_count = ceil(input_length / chunk_size) + if chunk_count < concurrency: + logger.warning( + f"Limiting concurrency to {chunk_count} because there are only {chunk_count} chunks" + ) + concurrency = chunk_count + + config = ParallelMapConfiguration( + concurrency=concurrency, + chunk_count=chunk_count, + chunk_size=chunk_size, + input_length=input_length, + function_name=function.__name__ if hasattr(function, "__name__") else "unknown", + ) + + return config diff --git a/great_ai/utilities/parallel_map/manage_communication.py b/great_ai/utilities/parallel_map/manage_communication.py new file mode 100644 index 0000000..4d53d2b --- /dev/null +++ b/great_ai/utilities/parallel_map/manage_communication.py @@ -0,0 +1,76 @@ +import multiprocessing as mp +import queue +import traceback +from typing import Dict, Iterable, List, TypeVar, Union + +from ..chunk import chunk +from ..logger.get_logger import get_logger +from .map_result import MapResult +from .worker_exception import WorkerException + +logger = get_logger("parallel_map") + +T = TypeVar("T") +V = TypeVar("V") + + +def manage_communication( + *, + input_values: Iterable[T], + chunk_size: int, + input_queue: Union[mp.Queue, queue.Queue], + output_queue: Union[mp.Queue, queue.Queue], + unordered: bool, + ignore_exceptions: bool, +) -> Iterable[V]: + chunks = iter(chunk(enumerate(input_values), chunk_size=chunk_size)) + indexed_results: Dict[int, V] = {} + next_output_index = 0 + read_input_length = 0 + is_iteration_over = False + + while not is_iteration_over or next_output_index < read_input_length: + if not is_iteration_over: + try: + next_chunk = next(chunks) + input_queue.put(next_chunk) + read_input_length += len(next_chunk) + except StopIteration: + is_iteration_over = True + except Exception as e: + if ignore_exceptions: + logger.error( + f"""Exception {e} encountered in input, traceback:\n{ + traceback.format_exc() + }""" + ) + else: + raise + + try: + result_chunk: List[MapResult] = output_queue.get_nowait() + for r in result_chunk: + if r.exception is not None: + if ignore_exceptions: + logger.error( + f"""Exception { + r.exception + } encountered in worker, traceback:\n{r.worker_traceback}""" + ) + else: + raise WorkerException(r.exception) + + if unordered: + + yield r.value + next_output_index += 1 + else: + indexed_results[r.order] = r.value + + if not unordered: + while next_output_index in indexed_results: + yield indexed_results[next_output_index] + del indexed_results[next_output_index] + next_output_index += 1 + except queue.Empty: + pass diff --git a/great_ai/utilities/parallel_map/map_result.py b/great_ai/utilities/parallel_map/map_result.py new file mode 100644 index 0000000..481ce5d --- /dev/null +++ b/great_ai/utilities/parallel_map/map_result.py @@ -0,0 +1,8 @@ +from typing import Any, NamedTuple, Optional + + +class MapResult(NamedTuple): + order: int + value: Any + exception: Optional[str] = None + worker_traceback: Optional[str] = None diff --git a/great_ai/utilities/parallel_map/mapper_function.py b/great_ai/utilities/parallel_map/mapper_function.py new file mode 100644 index 0000000..1aa4721 --- /dev/null +++ b/great_ai/utilities/parallel_map/mapper_function.py @@ -0,0 +1,78 @@ +import asyncio +import inspect +import multiprocessing as mp +import queue +import threading +import traceback +from multiprocessing.synchronize import Event +from typing import Any, Awaitable, Callable, List, TypeVar, Union, cast + +import dill + +from .map_result import MapResult + +T = TypeVar("T") +V = TypeVar("V") + + +def mapper_function( + input_queue: Union[mp.Queue, queue.Queue], + output_queue: Union[mp.Queue, queue.Queue], + should_stop: Union[Event, threading.Event], + func: Union[bytes, Callable[[T], V], Callable[[T], Awaitable[V]]], +) -> None: + try: + if isinstance(func, bytes): + func = cast(Callable[[T], V], dill.loads(func)) + + is_asynchronous = inspect.iscoroutinefunction(func) + + last_chunk: List[MapResult] = [] + while not should_stop.wait(0.1): + if not last_chunk: + try: + input_chunk = input_queue.get_nowait() + if is_asynchronous: + + async def safe(i: int, value: T) -> Any: + try: + return MapResult( + i, + await cast(Callable[[T], Awaitable[V]], func)( + value + ), + ) + except Exception as e: + # `e` has to be stringified in order to avoid any + # surprising serialization error when returning it + return MapResult( + i, None, str(e), traceback.format_exc() + ) + + async def main() -> List[MapResult]: + return await asyncio.gather( + *[safe(i, v) for i, v in input_chunk] + ) + + last_chunk = asyncio.run(main()) + else: + for i, value in input_chunk: + try: + last_chunk.append(MapResult(i, func(value))) + except Exception as e: + last_chunk.append( + # `e` has to be stringified in order to avoid any + # surprising serialization error when returning it + MapResult(i, None, str(e), traceback.format_exc()) + ) + except queue.Empty: + pass + + if last_chunk: + try: + output_queue.put_nowait(last_chunk) + last_chunk = [] + except queue.Full: + pass + except (KeyboardInterrupt, BrokenPipeError): + pass diff --git a/great_ai/utilities/parallel_map/parallel_map.py b/great_ai/utilities/parallel_map/parallel_map.py new file mode 100644 index 0000000..f8c8e1f --- /dev/null +++ b/great_ai/utilities/parallel_map/parallel_map.py @@ -0,0 +1,186 @@ +import multiprocessing as mp +from typing import ( + Awaitable, + Callable, + Iterable, + Literal, + Optional, + Sequence, + TypeVar, + Union, + overload, +) + +import dill + +from .get_config import get_config +from .manage_communication import manage_communication +from .mapper_function import mapper_function +from .worker_exception import WorkerException + +T = TypeVar("T") +V = TypeVar("V") + + +@overload +def parallel_map( + func: Callable[[T], Union[V, Awaitable[V]]], + input_values: Sequence[T], + *, + ignore_exceptions: Literal[True], + chunk_size: Optional[int] = ..., + concurrency: Optional[int] = ..., + unordered: bool = ..., +) -> Iterable[Optional[V]]: ... + + +@overload +def parallel_map( + func: Callable[[T], Union[V, Awaitable[V]]], + input_values: Union[Iterable[T], Sequence[T]], + *, + chunk_size: int, + ignore_exceptions: Literal[True], + concurrency: Optional[int] = ..., + unordered: bool = ..., +) -> Iterable[Optional[V]]: ... + + +@overload +def parallel_map( + func: Callable[[T], Union[V, Awaitable[V]]], + input_values: Sequence[T], + *, + chunk_size: Optional[int] = ..., + ignore_exceptions: Literal[False] = ..., + concurrency: Optional[int] = ..., + unordered: bool = ..., +) -> Iterable[V]: ... + + +@overload +def parallel_map( + func: Callable[[T], Union[V, Awaitable[V]]], + input_values: Union[Iterable[T], Sequence[T]], + *, + chunk_size: int, + ignore_exceptions: Literal[False] = ..., + concurrency: Optional[int] = ..., + unordered: bool = ..., +) -> Iterable[V]: ... + + +def parallel_map( + func: Callable[[T], Union[V, Awaitable[V]]], + input_values: Union[Iterable[T], Sequence[T]], + *, + chunk_size: Optional[int] = None, + ignore_exceptions: bool = False, + concurrency: Optional[int] = None, + unordered: bool = False, +) -> Iterable[Optional[V]]: + """Execute a map operation on an iterable stream. + + A custom parallel map operation supporting both synchronous and `async` map + functions. The `func` function is serialised with `dill`. Exceptions encountered in + the map function are sent to the host process where they are either raised (default) + or ignored. + + The new processes are forked if the OS allows it, otherwise, new Python processes + are bootstrapped which can incur some start-up cost. Each process processes a single + chunk at once. + + Examples: + >>> import math + >>> list(parallel_map(math.sqrt, [9, 4, 1], concurrency=2)) + [3.0, 2.0, 1.0] + + Args: + func: The function that should be applied to each element of `input_values`. + It can `async`, in that case, a new event loop is started for each chunk. + input_values: An iterable of items that `func` is applied to. + chunk_size: Tune the number of items processed in each step. Larger numbers + result in smaller communication overhead but less parallelism at the start + and end. If `chunk_size` has a `__len__` property, the `chunk_size` is + calculated automatically if not given. + ignore_exceptions: Ignore chunks if `next()` raises an exception on + `input_values`. And return `None` if `func` raised an exception in a worker + process. + concurrency: Number of new processes to start. Shouldn't be too much more than + the number of physical cores. + unordered: Do not preserve the order of the elements, yield them as soon as they + have been processed. This decreases the latency caused by + difficult-to-process items. + + Yields: + The next result obtained from applying `func` to each input value. May + contain `None`-s if `ignore_exceptions=True`. May have different order than + the input if `unordered=True`. + + Raises: + WorkerException: If there was an error in the `func` function in a background + process and `ignore_exceptions=False`. + """ + + config = get_config( + function=func, + input_values=input_values, + chunk_size=chunk_size, + concurrency=concurrency, + ) + + ctx = ( + mp.get_context("fork") + if "fork" in mp.get_all_start_methods() + else mp.get_context("spawn") + ) + ctx.freeze_support() + manager = ctx.Manager() + input_queue = manager.Queue(config.concurrency * 2) + output_queue = manager.Queue(config.concurrency * 2) + + should_stop = ctx.Event() + serialized_map_function = dill.dumps(func, byref=True, recurse=False) + + processes = [ + ctx.Process( + name=f"parallel_map_{config.function_name}_{i}", + target=mapper_function, + daemon=True, + kwargs=dict( + input_queue=input_queue, + output_queue=output_queue, + should_stop=should_stop, + func=serialized_map_function, + ), + ) + for i in range(config.concurrency) + ] + + for p in processes: + p.start() + + try: + yield from manage_communication( + input_values=input_values, + chunk_size=config.chunk_size, + input_queue=input_queue, + output_queue=output_queue, + unordered=unordered, + ignore_exceptions=ignore_exceptions, + ) + should_stop.set() + except WorkerException: + should_stop.set() + raise + except Exception: + for p in processes: + p.terminate() + p.kill() + raise + finally: + for p in processes: + p.join() # terminated processes have to be joined else they remain zombies + p.close() + + manager.shutdown() diff --git a/great_ai/utilities/parallel_map/parallel_map_configuration.py b/great_ai/utilities/parallel_map/parallel_map_configuration.py new file mode 100644 index 0000000..6959b94 --- /dev/null +++ b/great_ai/utilities/parallel_map/parallel_map_configuration.py @@ -0,0 +1,15 @@ +from typing import Optional + +from pydantic import BaseModel + +from ..logger.get_logger import get_logger + +logger = get_logger("parallel_map") + + +class ParallelMapConfiguration(BaseModel): + concurrency: int + chunk_count: Optional[int] + chunk_size: int + input_length: Optional[int] + function_name: str diff --git a/great_ai/utilities/parallel_map/simple_parallel_map.py b/great_ai/utilities/parallel_map/simple_parallel_map.py new file mode 100644 index 0000000..7a506b3 --- /dev/null +++ b/great_ai/utilities/parallel_map/simple_parallel_map.py @@ -0,0 +1,61 @@ +from typing import Awaitable, Callable, List, Optional, Sequence, TypeVar, Union + +from tqdm import tqdm + +from .parallel_map import parallel_map + +T = TypeVar("T") +V = TypeVar("V") + + +def simple_parallel_map( + func: Callable[[T], Union[V, Awaitable[V]]], + input_values: Sequence[T], + *, + chunk_size: Optional[int] = None, + concurrency: Optional[int] = None, +) -> List[V]: + """Execute a map operation on an list mimicking the API of the built-in `map()`. + + A thin-wrapper over [parallel_map][great_ai.utilities.parallel_map.parallel_map.parallel_map]. + For more options, consult the documentation of + [parallel_map][great_ai.utilities.parallel_map.parallel_map.parallel_map]. + + Examples: + >>> import math + >>> list(simple_parallel_map(math.sqrt, [9, 4, 1])) + [3.0, 2.0, 1.0] + + Args: + func: The function that should be applied to each element of `input_values`. + It can `async`, in that case, a new event loop is started for each chunk. + input_values: An iterable of items that `func` is applied to. + chunk_size: Tune the number of items processed in each step. Larger numbers + result in smaller communication overhead but less parallelism at the start + and end. If `chunk_size` has a `__len__` property, the `chunk_size` is + calculated automatically if not given. + concurrency: Number of new processes to start. Shouldn't be too much more than + the number of physical cores. + + Returns: + An iterable of results obtained from applying `func` to each input value. + + Raises: + WorkerException: If there was an error in the `func` function in a background + process. + """ + + input_values = list(input_values) # in case the input is mistakenly not a sequence + generator = parallel_map( + func=func, + input_values=input_values, + chunk_size=chunk_size, + concurrency=concurrency, + ) + + return list( + tqdm( + generator, + total=len(input_values), + ) + ) diff --git a/great_ai/utilities/parallel_map/threaded_parallel_map.py b/great_ai/utilities/parallel_map/threaded_parallel_map.py new file mode 100644 index 0000000..21d80e5 --- /dev/null +++ b/great_ai/utilities/parallel_map/threaded_parallel_map.py @@ -0,0 +1,160 @@ +import queue +import threading +from typing import ( + Awaitable, + Callable, + Iterable, + Literal, + Optional, + Sequence, + TypeVar, + Union, + overload, +) + +from .get_config import get_config +from .manage_communication import manage_communication +from .mapper_function import mapper_function + +T = TypeVar("T") +V = TypeVar("V") + + +@overload +def threaded_parallel_map( + func: Callable[[T], Union[V, Awaitable[V]]], + input_values: Sequence[T], + *, + ignore_exceptions: Literal[True], + chunk_size: Optional[int] = ..., + concurrency: Optional[int] = ..., + unordered: bool = ..., +) -> Iterable[Optional[V]]: ... + + +@overload +def threaded_parallel_map( + func: Callable[[T], Union[V, Awaitable[V]]], + input_values: Union[Iterable[T], Sequence[T]], + *, + chunk_size: int, + ignore_exceptions: Literal[True], + concurrency: Optional[int] = ..., + unordered: bool = ..., +) -> Iterable[Optional[V]]: ... + + +@overload +def threaded_parallel_map( + func: Callable[[T], Union[V, Awaitable[V]]], + input_values: Sequence[T], + *, + chunk_size: Optional[int] = ..., + ignore_exceptions: Literal[False] = ..., + concurrency: Optional[int] = ..., + unordered: bool = ..., +) -> Iterable[V]: ... + + +@overload +def threaded_parallel_map( + func: Callable[[T], Union[V, Awaitable[V]]], + input_values: Union[Iterable[T], Sequence[T]], + *, + chunk_size: int, + ignore_exceptions: Literal[False] = ..., + concurrency: Optional[int] = ..., + unordered: bool = ..., +) -> Iterable[V]: ... + + +def threaded_parallel_map( + func: Callable[[T], Union[V, Awaitable[V]]], + input_values: Union[Iterable[T], Sequence[T]], + *, + chunk_size: Optional[int] = None, + ignore_exceptions: bool = False, + concurrency: Optional[int] = None, + unordered: bool = False, +) -> Iterable[Optional[V]]: + """Execute a map operation on an iterable stream. + + Similar to [parallel_map][great_ai.utilities.parallel_map.parallel_map.parallel_map] + but uses threads instead of processes. Hence, it is not helpful in CPU-bound + situations. + + A custom parallel map operation supporting both synchronous and `async` map + functions. Exceptions encountered in the map function are sent to the host thread + where they are either raised (default) or ignored. Each process processes a single + chunk at once. + + Examples: + >>> list(threaded_parallel_map(lambda x: x ** 2, [1, 2, 3])) + [1, 4, 9] + + Args: + func: The function that should be applied to each element of `input_values`. + It can `async`, in that case, a new event loop is started for each chunk. + input_values: An iterable of items that `func` is applied to. + chunk_size: Tune the number of items processed in each step. Larger numbers + result in smaller communication overhead but less parallelism at the start + and end. If `chunk_size` has a `__len__` property, the `chunk_size` is + calculated automatically if not given. + ignore_exceptions: Ignore chunks if `next()` raises an exception on + `input_values`. And return `None` if `func` raised an exception in a worker + process. + concurrency: Number of new threads to start. + unordered: Do not preserve the order of the elements, yield them as soon as they + have been processed. This decreases the latency caused by + difficult-to-process items. + + Yields: + The next result obtained from applying `func` to each input value. May + contain `None`-s if `ignore_exceptions=True`. May have different order than + the input if `unordered=True`. + + Raises: + WorkerException: If there was an error in the `func` function in a background + thread and `ignore_exceptions=False`. + """ + + config = get_config( + function=func, + input_values=input_values, + chunk_size=chunk_size, + concurrency=concurrency, + ) + + input_queue: queue.Queue = queue.Queue(config.concurrency * 2) + output_queue: queue.Queue = queue.Queue(config.concurrency * 2) + should_stop = threading.Event() + + threads = [ + threading.Thread( + name=f"threaded_parallel_map_{config.function_name}_{i}", + target=mapper_function, + daemon=True, + kwargs=dict( + input_queue=input_queue, + output_queue=output_queue, + should_stop=should_stop, + func=func, + ), + ) + for i in range(config.concurrency) + ] + + for t in threads: + t.start() + + yield from manage_communication( + input_values=input_values, + chunk_size=config.chunk_size, + input_queue=input_queue, + output_queue=output_queue, + unordered=unordered, + ignore_exceptions=ignore_exceptions, + ) + should_stop.set() + for t in threads: + t.join(1) diff --git a/great_ai/utilities/parallel_map/worker_exception.py b/great_ai/utilities/parallel_map/worker_exception.py new file mode 100644 index 0000000..92babc3 --- /dev/null +++ b/great_ai/utilities/parallel_map/worker_exception.py @@ -0,0 +1,2 @@ +class WorkerException(Exception): + pass diff --git a/great_ai/utilities/unchunk.py b/great_ai/utilities/unchunk.py new file mode 100644 index 0000000..fc3d5fa --- /dev/null +++ b/great_ai/utilities/unchunk.py @@ -0,0 +1,27 @@ +from typing import Iterable, Optional, TypeVar + +T = TypeVar("T") + + +def unchunk(chunks: Iterable[Optional[Iterable[T]]]) -> Iterable[T]: + """Turn a stream of chunks of items into a stream of items (flatten operation). + + The inverse operation of [chunk][great_ai.utilities.chunk.chunk]. + Useful for parallel processing. + + Similar to itertools.chain but ignores `None` chunks. + + Examples: + >>> list(unchunk([[0, 1, 2], [3, 4, 5], [6, 7, 8], [9]])) + [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] + + Args: + chunks: Stream of chunks to unpack. + + Yields: + The next item in the flattened iterable. + """ + + for chunk in chunks: + if chunk is not None: + yield from chunk diff --git a/great_ai/utilities/unique.py b/great_ai/utilities/unique.py new file mode 100644 index 0000000..bd8e8d5 --- /dev/null +++ b/great_ai/utilities/unique.py @@ -0,0 +1,36 @@ +from typing import Any, Callable, Iterable, List, TypeVar + +T = TypeVar("T") + + +def unique(values: Iterable[T], *, key: Callable[[T], Any] = lambda v: v) -> List[T]: + """Keep only the first occurrences while maintaining original order. + + The equality check used for deduplication can be overridden using the `key` argument. + + Examples: + >>> unique([1, 1, 5, 3, 3]) + [1, 5, 3] + + >>> unique([{'a': 1, 'b': 2}, {'a': 1, 'b': 3}], key=lambda v: v['a']) + [{'a': 1, 'b': 2}] + + >>> unique([{'a': 1, 'b': 2}, {'a': 1, 'b': 3}], key=lambda v: v['b']) + [{'a': 1, 'b': 2}, {'a': 1, 'b': 3}] + + Args: + values: An iterable containing your values + key: Override the identity function of the equality check. + + Returns: + A deduplicated list. + """ + + key_values = {} + for v in values: + k = key(v) + if k not in key_values: + # dicts maintain insertion order: https://mail.python.org/pipermail/python-dev/2017-December/151283.html + key_values[k] = v + + return list(key_values.values()) diff --git a/src/great_ai/great_ai/views/__init__.py b/great_ai/views/__init__.py similarity index 91% rename from src/great_ai/great_ai/views/__init__.py rename to great_ai/views/__init__.py index 65ef6f8..cf82c4f 100644 --- a/src/great_ai/great_ai/views/__init__.py +++ b/great_ai/views/__init__.py @@ -7,5 +7,6 @@ from .health_check_response import HealthCheckResponse from .model import Model from .operators import operators from .query import Query +from .route_config import RouteConfig from .sort_by import SortBy from .trace import Trace diff --git a/src/great_ai/great_ai/views/api_metadata.py b/great_ai/views/api_metadata.py similarity index 100% rename from src/great_ai/great_ai/views/api_metadata.py rename to great_ai/views/api_metadata.py diff --git a/src/great_ai/great_ai/views/cache_statistics.py b/great_ai/views/cache_statistics.py similarity index 100% rename from src/great_ai/great_ai/views/cache_statistics.py rename to great_ai/views/cache_statistics.py diff --git a/src/great_ai/great_ai/views/evaluation_feedback_request.py b/great_ai/views/evaluation_feedback_request.py similarity index 100% rename from src/great_ai/great_ai/views/evaluation_feedback_request.py rename to great_ai/views/evaluation_feedback_request.py diff --git a/src/great_ai/great_ai/views/filter.py b/great_ai/views/filter.py similarity index 100% rename from src/great_ai/great_ai/views/filter.py rename to great_ai/views/filter.py diff --git a/src/great_ai/great_ai/views/function_metadata.py b/great_ai/views/function_metadata.py similarity index 87% rename from src/great_ai/great_ai/views/function_metadata.py rename to great_ai/views/function_metadata.py index 97dc4b9..e59d1ff 100644 --- a/src/great_ai/great_ai/views/function_metadata.py +++ b/great_ai/views/function_metadata.py @@ -4,7 +4,7 @@ from pydantic import BaseModel class FunctionMetadata(BaseModel): + is_asynchronous: bool input_parameter_names: List[str] = [] model_parameter_names: List[str] = [] - model_versions: str = "" is_finalised: bool = False diff --git a/src/great_ai/great_ai/helper/hashable_base_model.py b/great_ai/views/hashable_base_model.py similarity index 100% rename from src/great_ai/great_ai/helper/hashable_base_model.py rename to great_ai/views/hashable_base_model.py diff --git a/src/great_ai/great_ai/views/health_check_response.py b/great_ai/views/health_check_response.py similarity index 100% rename from src/great_ai/great_ai/views/health_check_response.py rename to great_ai/views/health_check_response.py diff --git a/src/great_ai/great_ai/views/model.py b/great_ai/views/model.py similarity index 100% rename from src/great_ai/great_ai/views/model.py rename to great_ai/views/model.py diff --git a/src/great_ai/great_ai/views/operators.py b/great_ai/views/operators.py similarity index 100% rename from src/great_ai/great_ai/views/operators.py rename to great_ai/views/operators.py diff --git a/great_ai/views/outputs/__init__.py b/great_ai/views/outputs/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/great_ai/great_ai/output_models/classification_output.py b/great_ai/views/outputs/classification_output.py similarity index 60% rename from src/great_ai/great_ai/output_models/classification_output.py rename to great_ai/views/outputs/classification_output.py index 6956aa4..7e3cccc 100644 --- a/src/great_ai/great_ai/output_models/classification_output.py +++ b/great_ai/views/outputs/classification_output.py @@ -1,9 +1,9 @@ from typing import Any, Optional, Union -from ..helper import HashableBaseModel +from ..hashable_base_model import HashableBaseModel class ClassificationOutput(HashableBaseModel): label: Union[str, int] confidence: float - explanation: Optional[Any] + explanation: Optional[Any] = None diff --git a/src/great_ai/great_ai/output_models/multi_label_classification_output.py b/great_ai/views/outputs/multi_label_classification_output.py similarity index 77% rename from src/great_ai/great_ai/output_models/multi_label_classification_output.py rename to great_ai/views/outputs/multi_label_classification_output.py index 52108c6..052e359 100644 --- a/src/great_ai/great_ai/output_models/multi_label_classification_output.py +++ b/great_ai/views/outputs/multi_label_classification_output.py @@ -1,6 +1,6 @@ from typing import List -from ..helper import HashableBaseModel +from ..hashable_base_model import HashableBaseModel from .classification_output import ClassificationOutput diff --git a/src/great_ai/great_ai/output_models/regression_output.py b/great_ai/views/outputs/regression_output.py similarity index 56% rename from src/great_ai/great_ai/output_models/regression_output.py rename to great_ai/views/outputs/regression_output.py index 058ea75..997c92e 100644 --- a/src/great_ai/great_ai/output_models/regression_output.py +++ b/great_ai/views/outputs/regression_output.py @@ -1,8 +1,8 @@ from typing import Any, Optional, Union -from ..helper import HashableBaseModel +from ..hashable_base_model import HashableBaseModel class RegressionOutput(HashableBaseModel): value: Union[int, float] - explanation: Optional[Any] + explanation: Optional[Any] = None diff --git a/great_ai/views/outputs/sequence_labeling_output.py b/great_ai/views/outputs/sequence_labeling_output.py new file mode 100644 index 0000000..7dceb8c --- /dev/null +++ b/great_ai/views/outputs/sequence_labeling_output.py @@ -0,0 +1,15 @@ +from typing import Any, List, Literal, Optional + +from ..hashable_base_model import HashableBaseModel + + +class LabeledToken(HashableBaseModel): + token: str + tag: Literal["B", "I", "O", "E", "S"] + confidence: float + explanation: Optional[Any] = None + + +class SequenceLabelingOutput(HashableBaseModel): + labeled_tokens: List[LabeledToken] + explanation: Optional[Any] = None diff --git a/src/great_ai/great_ai/views/query.py b/great_ai/views/query.py similarity index 89% rename from src/great_ai/great_ai/views/query.py rename to great_ai/views/query.py index 7257a7b..ece1d21 100644 --- a/src/great_ai/great_ai/views/query.py +++ b/great_ai/views/query.py @@ -1,7 +1,7 @@ from datetime import datetime from typing import List, Optional, Sequence -from pydantic import BaseModel +from pydantic import BaseModel, ConfigDict from .filter import Filter from .sort_by import SortBy @@ -15,8 +15,8 @@ class Query(BaseModel): until: Optional[datetime] = None has_feedback: Optional[bool] = None - class Config: - schema_extra = { + model_config = ConfigDict( + json_schema_extra={ "example": { "filter": [ { @@ -33,3 +33,4 @@ class Query(BaseModel): "has_feedback": False, } } + ) diff --git a/great_ai/views/route_config.py b/great_ai/views/route_config.py new file mode 100644 index 0000000..33c8ebd --- /dev/null +++ b/great_ai/views/route_config.py @@ -0,0 +1,10 @@ +from pydantic import BaseModel + + +class RouteConfig(BaseModel): + prediction_endpoint_enabled: bool = True + docs_endpoints_enabled: bool = True + dashboard_enabled: bool = True + feedback_endpoints_enabled: bool = True + trace_endpoints_enabled: bool = True + meta_endpoints_enabled: bool = True diff --git a/src/great_ai/great_ai/views/sort_by.py b/great_ai/views/sort_by.py similarity index 100% rename from src/great_ai/great_ai/views/sort_by.py rename to great_ai/views/sort_by.py diff --git a/src/great_ai/great_ai/views/trace.py b/great_ai/views/trace.py similarity index 51% rename from src/great_ai/great_ai/views/trace.py rename to great_ai/views/trace.py index adc744b..f7c6328 100644 --- a/src/great_ai/great_ai/views/trace.py +++ b/great_ai/views/trace.py @@ -1,34 +1,43 @@ from pprint import pformat from typing import Any, Dict, Generic, List, Optional, TypeVar -from uuid import uuid4 -from pydantic import Extra, validator +from pydantic import ConfigDict -from ..helper import HashableBaseModel +from .hashable_base_model import HashableBaseModel from .model import Model T = TypeVar("T") -class Trace(Generic[T], HashableBaseModel): - trace_id: Optional[str] +class Trace(HashableBaseModel, Generic[T]): + """Universal structure for storing prediction traces and training data. + + Attributes: + trace_id: UUID4 identifier for uniquely referring to a trace. + created: Timestamp of its (original) construction. + original_execution_time_ms: Wall-time elapsed while its generating + TracingContext was alive. + logged_values: Values persisted through using `@parameter` or `log_metric()`. + models: Marks left by each encountered `@use_model` decorated function. + exception: Exception description if any was encountered. + output: Return value of the function wrapped by GreatAI. + feedback: Feedback obtained using the REST API of `add_ground_truth`. + tags: Tags used for filtering traces. Contains the name of the original + function, value of `ENVIRONMENT`, its split if has any, and either + `ground_truth` or `online` depending on the origin of the Trace. + """ + + trace_id: str created: str original_execution_time_ms: float logged_values: Dict[str, Any] models: List[Model] - exception: Optional[str] - output: T + exception: Optional[str] = None + output: Optional[T] = None feedback: Any = None tags: List[str] - class Config: - extra = Extra.ignore - - @validator("trace_id", always=True) - def generate_id(cls, v: Optional[str], values: Dict[str, Any]) -> Optional[str]: - if not v: - return str(uuid4()) - return v + model_config = ConfigDict(extra="ignore") @property def input(self) -> Any: @@ -69,7 +78,7 @@ class Trace(Generic[T], HashableBaseModel): def to_flat_dict(self, include_original: bool = True) -> Dict[str, Any]: return { **( - self.dict() + self.model_dump() if include_original else { "trace_id": self.trace_id, @@ -77,10 +86,23 @@ class Trace(Generic[T], HashableBaseModel): "original_execution_time_ms": self.original_execution_time_ms, } ), - **self.logged_values, + **{ + k: ( + v + if (isinstance(v, float) or isinstance(v, int)) + else pformat(v, indent=2, compact=True) + ) + for k, v in self.logged_values.items() + }, "models_flat": self.models_flat, "exception_flat": self.exception_flat, "output_flat": self.output_flat, "feedback_flat": self.feedback_flat, "tags_flat": self.tags_flat, } + + def __repr__(self) -> str: + formatted = pformat(self.model_dump(), indent=2, compact=True).replace( + "{ ", "{", 1 + ) + return f"Trace[{type(self.output).__name__}]({formatted})" diff --git a/mkdocs.yaml b/mkdocs.yaml new file mode 100644 index 0000000..1014fc7 --- /dev/null +++ b/mkdocs.yaml @@ -0,0 +1,119 @@ +site_name: GreatAI documentation +site_description: GreatAI helps you easily transform your prototype AI code into production-ready software. +site_author: András Schmelczer + +repo_url: https://github.com/schmelczer/great-ai +repo_name: schmelczer/great-ai +edit_uri: edit/main/docs/ + +copyright: GNU General Public License v3 + +extra: + generator: false + social: + - icon: fontawesome/solid/code + link: https://schmelczer.dev + name: about the author + - icon: fontawesome/brands/github + link: https://github.com/schmelczer/great-ai + name: great-ai on Github + - icon: fontawesome/brands/docker + link: https://hub.docker.com/repository/docker/schmelczera/great-ai + name: great-ai on DockerHub + - icon: fontawesome/brands/python + link: https://pypi.org/project/great-ai + name: great-ai on PyPI + +theme: + name: "material" + custom_dir: docs/overrides + homepage: https://great-ai.scoutinscience.com + favicon: media/favicon.ico + features: + - content.code.annotate + - content.tooltips + palette: + - scheme: default + primary: light blue + media: "(prefers-color-scheme: light)" + toggle: + icon: material/lightbulb + name: Switch to dark mode + + - scheme: slate + primary: light blue + media: "(prefers-color-scheme: dark)" + toggle: + icon: material/lightbulb-outline + name: Switch to light mode + +watch: + - docs + - mkdocs.yaml + +plugins: + - git-revision-date-localized: + - mkdocstrings: + handlers: + python: + options: + show_root_toc_entry: false + show_root_full_path: false + heading_level: 3 + - search + - mkdocs-jupyter: + include_source: true + +markdown_extensions: + - pymdownx.highlight: + anchor_linenums: true + - pymdownx.inlinehilite + - pymdownx.snippets + - pymdownx.superfences + - pymdownx.tasklist: + custom_checkbox: true + - toc: + permalink: "#" + - admonition + - pymdownx.details + - md_in_html + - pymdownx.emoji: + emoji_index: !!python/name:materialx.emoji.twemoji + emoji_generator: !!python/name:materialx.emoji.to_svg + - abbr + - attr_list + - pymdownx.caret + - pymdownx.mark + - pymdownx.tilde + +nav: + - Overview: index.md + - Tutorial: + - Tutorial overview: tutorial/index.md + - tutorial/train.ipynb + - tutorial/deploy.ipynb + - User Guides: + - how-to-guides/install.md + - how-to-guides/create-service.md + - how-to-guides/configure-service.md + - how-to-guides/use-service.md + - how-to-guides/handle-training-data.md + - how-to-guides/large-file.md + - how-to-guides/call-remote.md + - Reference: + - reference/index.md + - reference/utilities.md + - reference/large-file.md + - reference/views.md + - Examples: + - Explainable Naive Bayes: + - examples/simple/data.ipynb + - examples/simple/train.ipynb + - examples/simple/deploy.ipynb + - Explainable SciBERT: + - examples/scibert/index.md + - examples/scibert/data.ipynb + - examples/scibert/train.ipynb + - examples/scibert/deploy.ipynb + - examples/scibert/additional-files.md + - explanation.md diff --git a/pyproject.toml b/pyproject.toml index 4faf030..a02460d 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,7 +1,85 @@ [build-system] -requires = [ - "setuptools>=42", - "setuptools-git", - "wheel" +requires = ["flit_core >=3.2,<4"] +build-backend = "flit_core.buildapi" + +[tool.flit.module] +name = "great_ai" # Module's import name/local folder name + +[project] +name = "great-ai" # PyPI package name +dynamic = ["version", "description"] +readme = "README.md" +authors = [{ name = "András Schmelczer", email = "andras@schmelczer.dev" }] +license = { file = "LICENSE" } +classifiers = [ + "Operating System :: OS Independent", + "Programming Language :: Python :: 3", + "Topic :: Software Development :: Libraries :: Python Modules", + "Typing :: Typed", + "Development Status :: 3 - Alpha", + "License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)", + "Natural Language :: English", ] -build-backend = "setuptools.build_meta" +keywords = ["SE4ML", "MLOps", "AI engineering", "general", "robust", "end-to-end", "automated", "trustworthy", "ai", "deployment"] +requires-python = ">= 3.10" +dependencies = [ + "scikit-learn >= 1.3, < 2", + "matplotlib >= 3.7, < 4", + "numpy >= 1.24, < 3", + "nbconvert >= 7.0, < 8", + "ipython >= 8.0, < 10", + "unidecode >= 1.3.0, < 2", + "syntok >= 1.4.0, < 2", + "langcodes[data] >= 3.3.0, < 4", + "langdetect >= 1.0.9, < 2", + "tinydb >= 4.7.0, < 5", + "boto3 >= 1.34, < 2", + "plotly >= 5.20, < 7", + "pandas >= 2.0, < 4", + "dash >= 2.16, < 5", + "fastapi >= 0.110, < 1", + "uvicorn[standard] >= 0.27, < 1", + "a2wsgi >= 1.9, < 2", + "watchdog >= 3.0, < 7", + "typeguard >= 4.0, < 5", + "pydantic >= 2.5, < 3", + "pymongo >= 4.6, < 5", + "dill >= 0.3.6, < 1", + "tqdm >= 4.64, < 5", + "httpx >= 0.24, < 1", +] + +[project.optional-dependencies] +dev = [ + "flit >= 3.9, < 4", + "mkdocs >= 1.5, < 2", + "mkdocstrings[python] >= 0.24, < 1", + "mkdocs-material >= 9.5, < 10", + "mkdocs-jupyter >= 0.24, < 1", + "mkdocs-git-revision-date-localized-plugin >= 1.2, < 2", + "autoflake >= 2.0, < 3", + "isort >= 5.12, < 7", + "black[jupyter] >= 25.1, < 26", + "mypy >= 1.8, < 2", + "flake8 >= 7.0, < 8", + "tox >= 4.0, < 5", + "pytest >= 7.4, < 9", + "pytest-cov >= 4.1, < 8", + "pytest-asyncio >= 0.23, < 2", +] + +[tool.pytest.ini_options] +# `...` in doctests (e.g. third-party exception messages that drift between +# dependency versions) is treated as a wildcard rather than a literal. +doctest_optionflags = ["ELLIPSIS"] + +[project.urls] +Documentation = "https://great-ai.scoutinscience.com" +GitHub = "https://github.com/schmelczer/great-ai" +DockerHub = "https://hub.docker.com/repository/docker/schmelczera/great-ai" + +[project.scripts] +great_ai = "great_ai.__main__:main" +great-ai = "great_ai.__main__:main" +large_file = "great_ai.large_file.__main__:main" +large-file = "great_ai.large_file.__main__:main" diff --git a/scripts/check-python.sh b/scripts/check-python.sh index d5bf925..1b36198 100755 --- a/scripts/check-python.sh +++ b/scripts/check-python.sh @@ -3,23 +3,23 @@ set -e echo "Installing dependencies if necessary" -python3 -m pip install --upgrade autoflake isort black[jupyter] mypy flake8 +python3 -m pip install autoflake isort black[jupyter] mypy flake8 -echo "Checking $1" +for dir in "$@"; do + echo "Checking $dir" -cd $1 + cd "$dir" -python3 -m autoflake --expand-star-imports --remove-all-unused-imports --ignore-init-module-imports --remove-unused-variables --in-place -r . --check -python3 -m isort --profile black --skip .env . --check -python3 -m black . --exclude .env --check + python3 -m autoflake --expand-star-imports --remove-all-unused-imports --ignore-init-module-imports --remove-unused-variables --in-place -r . --check + python3 -m isort --profile black --skip .env . --check + python3 -m black . --exclude .env --check -if ls *.py 1> /dev/null 2>&1; then - yes | python3 -m mypy . --install-types > /dev/null || true - python3 -m mypy --namespace-packages --ignore-missing-imports --install-types --non-interactive --disallow-untyped-defs --disallow-incomplete-defs --follow-imports=silent --exclude=external/ --exclude=/build/ --pretty . -fi + if find . -name "*.py" 2>/dev/null | grep -q .; then + yes | python3 -m mypy . --install-types > /dev/null || true + python3 -m mypy --namespace-packages --ignore-missing-imports --install-types --non-interactive --disallow-untyped-defs --disallow-incomplete-defs --follow-imports=silent --exclude=external/ --exclude=/build/ --exclude='(^|/)__main__\.py$' --pretty . + fi -python3 -m flake8 . --count --show-source --statistics --exclude=__init__.py,.env,external --ignore=E501,E722,E402,W503,E203 + python3 -m flake8 . --count --show-source --statistics --exclude=__init__.py,.env,external --extend-ignore=E501,E402,F821,W503,E722,E203,E704 -cd - - -echo "Finished checking" + cd - +done diff --git a/scripts/format-python.sh b/scripts/format-python.sh index 737a2b9..bed0322 100755 --- a/scripts/format-python.sh +++ b/scripts/format-python.sh @@ -2,30 +2,31 @@ set -e -echo "Installing dependencies if necessary" -python3 -m pip install --upgrade autoflake isort black[jupyter] mypy flake8 +for dir in "$@"; do + echo "Formatting and checking $dir" -echo "Formatting and checking $1" + cd "$dir" -cd $1 + echo Running autoflake + python3 -m autoflake --expand-star-imports --remove-all-unused-imports --ignore-init-module-imports --remove-unused-variables --in-place -r . -echo Running autoflake -python3 -m autoflake --expand-star-imports --remove-all-unused-imports --ignore-init-module-imports --remove-unused-variables --in-place -r . + echo Running isort + python3 -m isort --profile black --skip .env . -echo Running isort -python3 -m isort --profile black --skip .env . + echo Running black + python3 -m black . --exclude .env -echo Running black -python3 -m black . --exclude .env + if find . -name "*.py" 2>/dev/null | grep -q .; then + echo Running mypy -if ls *.py 1> /dev/null 2>&1; then - echo Running mypy - python3 -m mypy --namespace-packages --ignore-missing-imports --install-types --non-interactive --disallow-untyped-defs --disallow-incomplete-defs --pretty --follow-imports=silent --exclude=external/ --exclude=/build/ . -fi + if [ ! -d .mypy_cache ]; then + python3 -m mypy --namespace-packages --ignore-missing-imports --disallow-untyped-defs --disallow-incomplete-defs --follow-imports=silent --exclude=external/ --exclude=/build/ --pretty . || true + fi -echo Running Flake8 -python3 -m flake8 . --count --show-source --statistics --exclude=__init__.py,.env,external --ignore=E501,E722,E402,W503,E203 + python3 -m mypy --namespace-packages --ignore-missing-imports --install-types --non-interactive --disallow-untyped-defs --disallow-incomplete-defs --follow-imports=silent --exclude=external/ --exclude=/build/ --pretty . || true + fi -cd - + python3 -m flake8 . --count --show-source --statistics --exclude=__init__.py,.env,external --ignore=E501,E402,F821,W503,E722,E203 -echo "Finished formatting" + cd - +done diff --git a/setup.cfg b/setup.cfg deleted file mode 100644 index 6aa9b05..0000000 --- a/setup.cfg +++ /dev/null @@ -1,49 +0,0 @@ -[metadata] -name = great-ai -version = 0.0.3 -author = András Schmelczer -author_email = andras@scoutinscience.com -description = -long_description = file: README.md -long_description_content_type = text/markdown -url = https://github.com/ScoutinScience/great-ai -project_urls = - Bug Tracker = https://github.com/ScoutinScience/great-ai/issues -classifiers = - Programming Language :: Python :: 3 - Operating System :: OS Independent - -[options] -package_dir = - = src -packages = find: -include_package_data = True -python_requires = >=3.8 -install_requires = - unidecode >= 1.3.0 - multiprocess >= 0.70.0.0 - tqdm >= 4.0.0 - scikit-learn - matplotlib - numpy - syntok >= 1.4.0 - langcodes[data] >= 3.3.0 - langdetect >= 1.0.9 - tinydb >= 4.7.0 - pandas >= 1.4.0 - boto3 >= 1.23.0 - plotly >= 5.8.0 - dash >= 2.4.0 - nbconvert >= 6.5.0 - ipython >= 8.0.0 - fastapi >= 0.70.0 - uvicorn[standard] >= 0.18.0 - watchdog >= 2.1.0 - pymongo >= 3.0.0 - aiohttp >= 3.8.0 - -[options.package_data] -* = *.json, *.yaml, *.yml, *.css - -[options.packages.find] -where = src diff --git a/src/great_ai/__init__.py b/src/great_ai/__init__.py deleted file mode 100644 index a31d902..0000000 --- a/src/great_ai/__init__.py +++ /dev/null @@ -1,3 +0,0 @@ -from .great_ai import * -from .large_file import * -from .utilities import * diff --git a/src/great_ai/great_ai/__init__.py b/src/great_ai/great_ai/__init__.py deleted file mode 100644 index 176966f..0000000 --- a/src/great_ai/great_ai/__init__.py +++ /dev/null @@ -1,17 +0,0 @@ -from .context import configure -from .deploy import GreatAI -from .models import save_model, use_model -from .output_models import ( - ClassificationOutput, - MultiLabelClassificationOutput, - RegressionOutput, -) -from .parameters import log_metric, parameter -from .persistence import MongodbDriver, ParallelTinyDbDriver, TracingDatabaseDriver -from .remote import ( - HttpClient, - RemoteCallError, - call_remote_great_ai, - call_remote_great_ai_async, -) -from .tracing import add_ground_truth, delete_ground_truth, query_ground_truth diff --git a/src/great_ai/great_ai/deploy/great_ai.py b/src/great_ai/great_ai/deploy/great_ai.py deleted file mode 100644 index c8fb1b8..0000000 --- a/src/great_ai/great_ai/deploy/great_ai.py +++ /dev/null @@ -1,235 +0,0 @@ -import inspect -from functools import lru_cache, partial, wraps -from typing import ( - Any, - Callable, - Generic, - Iterable, - List, - Optional, - Type, - TypeVar, - cast, - overload, -) - -from fastapi import APIRouter, FastAPI, status -from pydantic import BaseModel, create_model - -from ...utilities import parallel_map -from ..constants import DASHBOARD_PATH -from ..context import get_context -from ..helper import ( - freeze_arguments, - get_function_metadata_store, - snake_case_to_text, - use_http_exceptions, -) -from ..parameters import automatically_decorate_parameters -from ..tracing.tracing_context import TracingContext -from ..views import ApiMetadata, CacheStatistics, HealthCheckResponse, Trace -from .routes import ( - bootstrap_docs_endpoints, - bootstrap_feedback_endpoints, - bootstrap_trace_endpoints, -) -from .routes.bootstrap_dashboard import bootstrap_dashboard - -T = TypeVar("T") - - -class GreatAI(Generic[T]): - def __init__(self, func: Callable[..., Any], version: str): - func = automatically_decorate_parameters(func) - get_function_metadata_store(func).is_finalised = True - - self._func = func - - def func_in_tracing_context( - *args: Any, do_not_persist_traces: bool = False, **kwargs: Any - ) -> Trace[T]: - with TracingContext[T]( - func.__name__, do_not_persist_traces=do_not_persist_traces - ) as t: - result = func(*args, **kwargs) - output = t.finalise(output=result) - return output - - self._cached_func = lru_cache(get_context().prediction_cache_size)( - func_in_tracing_context - ) # cannot put decorator on method, because it require the context to be setup - - wraps(func)(self) - - self._version = version - - self.app = FastAPI( - title=self.name, - version=self.version, - description=self.documentation - + f"\n\nFind out more in the [dashboard]({DASHBOARD_PATH}).", - docs_url=None, - redoc_url=None, - ) - - @overload - @staticmethod - def create( - func: Optional[Callable[..., T]] = None, - ) -> "GreatAI[T]": - ... - - @overload - @staticmethod - def create( - version: str = "0.0.1", - disable_rest_api: bool = False, - disable_docs: bool = False, - disable_dashboard: bool = False, - ) -> Callable[[Callable[..., T]], "GreatAI[T]"]: - ... - - @staticmethod - def create( - func: Optional[Callable[..., T]] = None, - *, - version: str = "0.0.1", - disable_rest_api: bool = False, - disable_docs: bool = False, - disable_dashboard: bool = False, - ): - if func is None: - return cast( - Callable[[Callable[..., T]], GreatAI[T]], - partial( - GreatAI.deploy, - disable_http=disable_rest_api, - disable_docs=disable_docs, - disable_dashboard=disable_dashboard, - ), - ) - - instance = GreatAI[T](func, version=version) - - if not disable_rest_api: - instance._bootstrap_rest_api( - disable_docs=disable_docs, disable_dashboard=disable_dashboard - ) - - return instance - - @freeze_arguments - def __call__(self, *args: Any, **kwargs: Any) -> Trace[T]: - return self._cached_func(*args, **kwargs) - - def process_batch( - self, - batch: Iterable[Any], - concurrency: Optional[int] = None, - do_not_persist_traces: bool = False, - ) -> List[Trace[T]]: - return parallel_map( - freeze_arguments( - partial(self._cached_func, do_not_persist_traces=do_not_persist_traces) - ), - batch, - concurrency=concurrency, - ) - - @property - def name(self) -> str: - return snake_case_to_text(self._func.__name__) - - @property - def version(self) -> str: - return ( - f"{self._version}+{get_function_metadata_store(self._func).model_versions}" - ) - - @property - def documentation(self) -> str: - return ( - f"GreatAI wrapper for interacting with the `{self._func.__name__}` function.\n\n" - + ( - "\n".join( - line.strip() - for line in (self._func.__doc__ or "").split("\n") - if line.strip() - ) - ) - ) - - def _bootstrap_rest_api(self, disable_docs: bool, disable_dashboard: bool) -> None: - self._bootstrap_prediction_endpoint() - - if not disable_docs: - bootstrap_docs_endpoints(self.app) - - if not disable_dashboard: - bootstrap_dashboard( - self.app, - function_name=self._func.__name__, - documentation=self.documentation, - ) - bootstrap_trace_endpoints(self.app) - - bootstrap_feedback_endpoints(self.app) - self._bootstrap_meta_endpoints() - - def _bootstrap_prediction_endpoint(self) -> None: - router = APIRouter( - prefix="/predict", - tags=["predictions"], - ) - - schema = self._get_schema() - - @router.post("/", status_code=status.HTTP_200_OK, response_model=Trace[T]) - @use_http_exceptions - def predict(input_value: schema) -> Trace[T]: # type: ignore - return self(**cast(BaseModel, input_value).dict()) - - self.app.include_router(router) - - def _get_schema(self) -> Type[BaseModel]: - signature = inspect.signature(self._func) - parameters = { - p.name: ( - p.annotation if p.annotation != inspect._empty else Any, - p.default if p.default != inspect._empty else ..., - ) - for p in signature.parameters.values() - if p.name in get_function_metadata_store(self._func).input_parameter_names - } - - schema: Type[BaseModel] = create_model("InputModel", **parameters) # type: ignore - return schema - - def _bootstrap_meta_endpoints(self) -> None: - router = APIRouter( - tags=["meta"], - ) - - @router.get("/health", status_code=status.HTTP_200_OK) - def check_health() -> HealthCheckResponse: - hits, misses, maxsize, cache_size = self._cached_func.cache_info() - cache_statistics = CacheStatistics( - hits=hits, misses=misses, size=cache_size, max_size=maxsize - ) - - return HealthCheckResponse( - is_healthy=True, cache_statistics=cache_statistics - ) - - @router.get( - "/version", response_model=ApiMetadata, status_code=status.HTTP_200_OK - ) - def get_version() -> ApiMetadata: - return ApiMetadata( - name=self.name, - version=self.version, - documentation=self.documentation, - configuration=get_context().to_flat_dict(), - ) - - self.app.include_router(router) diff --git a/src/great_ai/great_ai/deploy/routes/bootstrap_dashboard.py b/src/great_ai/great_ai/deploy/routes/bootstrap_dashboard.py deleted file mode 100644 index 01520a9..0000000 --- a/src/great_ai/great_ai/deploy/routes/bootstrap_dashboard.py +++ /dev/null @@ -1,27 +0,0 @@ -from pathlib import Path - -from fastapi import FastAPI -from fastapi.middleware.wsgi import WSGIMiddleware -from fastapi.responses import RedirectResponse -from fastapi.staticfiles import StaticFiles - -from ...constants import DASHBOARD_PATH -from .dashboard import create_dash_app - -PATH = Path(__file__).parent.resolve() - - -def bootstrap_dashboard(app: FastAPI, function_name: str, documentation: str) -> None: - dash_app = create_dash_app(function_name, documentation) - - app.mount(DASHBOARD_PATH, WSGIMiddleware(dash_app)) - - @app.get("/", include_in_schema=False) - def redirect_to_entrypoint() -> RedirectResponse: - return RedirectResponse(DASHBOARD_PATH) - - app.mount( - "/assets", - StaticFiles(directory=PATH / "dashboard/assets"), - name="static", - ) diff --git a/src/great_ai/great_ai/deploy/routes/dashboard/assets/github.png b/src/great_ai/great_ai/deploy/routes/dashboard/assets/github.png deleted file mode 100644 index ea6ff54..0000000 Binary files a/src/great_ai/great_ai/deploy/routes/dashboard/assets/github.png and /dev/null differ diff --git a/src/great_ai/great_ai/deploy/routes/dashboard/get_description.py b/src/great_ai/great_ai/deploy/routes/dashboard/get_description.py deleted file mode 100644 index 433442c..0000000 --- a/src/great_ai/great_ai/deploy/routes/dashboard/get_description.py +++ /dev/null @@ -1,32 +0,0 @@ -from dash import dcc, html - -from ....helper import snake_case_to_text, strip_lines - - -def get_description( - function_name: str, function_docs: str, accent_color: str -) -> html.Div: - return html.Div( - [ - html.H1( - f"{snake_case_to_text(function_name)} - dashboard", - style={"color": accent_color}, - ), - dcc.Markdown( - strip_lines( - f""" - > View the live data of your deployment here. - - ## Using the API - - You can find the available endpoints at [/docs](/docs). - - ## Details - - {function_docs} - """ - ), - className="description", - ), - ] - ) diff --git a/src/great_ai/great_ai/helper/assert_function_is_not_finalised.py b/src/great_ai/great_ai/helper/assert_function_is_not_finalised.py deleted file mode 100644 index b2110c2..0000000 --- a/src/great_ai/great_ai/helper/assert_function_is_not_finalised.py +++ /dev/null @@ -1,15 +0,0 @@ -from typing import Any, Callable - -from ..context import get_context -from .get_function_metadata_store import get_function_metadata_store - - -def assert_function_is_not_finalised(func: Callable[..., Any]) -> None: - error_message = ( - "The outer-most (first) decorator has to be `@GreatAI.deploy`. " - + f"In the case of `{func.__name__}`, it is not: fix this by moving `@GreatAI.deploy` to the top." - ) - - if get_function_metadata_store(func).is_finalised: - get_context().logger.error(error_message) - exit(-1) diff --git a/src/great_ai/great_ai/helper/freeze_arguments.py b/src/great_ai/great_ai/helper/freeze_arguments.py deleted file mode 100644 index 3847ea5..0000000 --- a/src/great_ai/great_ai/helper/freeze_arguments.py +++ /dev/null @@ -1,25 +0,0 @@ -from functools import wraps -from typing import Any, Callable, Dict, List - - -class FrozenDict(dict): - def __hash__(self) -> int: # type: ignore - return hash(frozenset(self.items())) - - -def freeze_arguments(func: Callable[..., Any]) -> Callable[..., Any]: - """Transform mutable dictionary - Into immutable - Useful to be compatible with cache - source: https://stackoverflow.com/questions/6358481/using-functools-lru-cache-with-dictionary-arguments - """ - - @wraps(func) - def wrapper(*args: List[Any], **kwargs: Dict[str, Any]) -> Any: - args = tuple(FrozenDict(arg) if isinstance(arg, dict) else arg for arg in args) - kwargs = { - k: FrozenDict(v) if isinstance(v, dict) else v for k, v in kwargs.items() - } - return func(*args, **kwargs) - - return wrapper diff --git a/src/great_ai/great_ai/helper/get_function_metadata_store.py b/src/great_ai/great_ai/helper/get_function_metadata_store.py deleted file mode 100644 index 8694636..0000000 --- a/src/great_ai/great_ai/helper/get_function_metadata_store.py +++ /dev/null @@ -1,12 +0,0 @@ -from typing import Any, Callable, cast - -from ..views.function_metadata import FunctionMetadata - - -def get_function_metadata_store(func: Callable[..., Any]) -> FunctionMetadata: - any_func = cast(Any, func) - - if not hasattr(any_func, "_great_ai_metadata"): - any_func._great_ai_metadata = FunctionMetadata() - - return any_func._great_ai_metadata diff --git a/src/great_ai/great_ai/helper/use_http_exceptions.py b/src/great_ai/great_ai/helper/use_http_exceptions.py deleted file mode 100644 index 8eae30a..0000000 --- a/src/great_ai/great_ai/helper/use_http_exceptions.py +++ /dev/null @@ -1,20 +0,0 @@ -from functools import wraps -from typing import Any, Callable, Dict, List, TypeVar, cast - -from fastapi import HTTPException, status - -F = TypeVar("F", bound=Callable[..., Any]) - - -def use_http_exceptions(func: F) -> F: - @wraps(func) - def wrapper(*args: List[Any], **kwargs: Dict[str, Any]) -> Any: - try: - return func(*args, **kwargs) - except Exception as e: - raise HTTPException( - status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, - detail=f"The following exception has occurred: {type(e).__name__}: {e}", - ) - - return cast(F, wrapper) diff --git a/src/great_ai/great_ai/models/__init__.py b/src/great_ai/great_ai/models/__init__.py deleted file mode 100644 index bf988ae..0000000 --- a/src/great_ai/great_ai/models/__init__.py +++ /dev/null @@ -1,2 +0,0 @@ -from .save_model import save_model -from .use_model import use_model diff --git a/src/great_ai/great_ai/models/load_model.py b/src/great_ai/great_ai/models/load_model.py deleted file mode 100644 index 5d4bf8c..0000000 --- a/src/great_ai/great_ai/models/load_model.py +++ /dev/null @@ -1,17 +0,0 @@ -from typing import Any, Optional, Tuple - -from joblib import load - -from ..context import get_context - - -def load_model( - key: str, version: Optional[int] = None, return_path: bool = False -) -> Tuple[Any, int]: - file = get_context().large_file_implementation(name=key, mode="rb", version=version) - - if return_path: - return file.get(), file.version - - with file as f: - return load(f), file.version diff --git a/src/great_ai/great_ai/models/save_model.py b/src/great_ai/great_ai/models/save_model.py deleted file mode 100644 index bf0f10e..0000000 --- a/src/great_ai/great_ai/models/save_model.py +++ /dev/null @@ -1,24 +0,0 @@ -from pathlib import Path -from typing import Optional, Union - -from joblib import dump - -from ..context import get_context - - -def save_model( - model: Union[Path, str, object], key: str, *, keep_last_n: Optional[int] = None -) -> str: - file = get_context().large_file_implementation( - name=key, mode="wb", keep_last_n=keep_last_n - ) - - if isinstance(model, Path) or isinstance(model, str): - file.push(model) - else: - with file as f: - dump(model, f) - - get_context().logger.info(f"Model {key} uploaded with version {file.version}") - - return f"{key}:{file.version}" diff --git a/src/great_ai/great_ai/models/use_model.py b/src/great_ai/great_ai/models/use_model.py deleted file mode 100644 index 4b57229..0000000 --- a/src/great_ai/great_ai/models/use_model.py +++ /dev/null @@ -1,48 +0,0 @@ -from functools import wraps -from typing import Any, Callable, Dict, List, Literal, TypeVar, Union, cast - -from ..helper import get_function_metadata_store -from ..helper.assert_function_is_not_finalised import assert_function_is_not_finalised -from ..tracing.tracing_context import TracingContext -from ..views import Model -from .load_model import load_model - -F = TypeVar("F", bound=Callable[..., Any]) - - -def use_model( - key: str, - *, - version: Union[int, Literal["latest"]], - return_path: bool = False, - model_kwarg_name: str = "model", -) -> Callable[[F], F]: - assert ( - isinstance(version, int) or version == "latest" - ), "Only integers or the string literal `latest` is allowed as version" - - model, actual_version = load_model( - key=key, - version=None if version == "latest" else version, - return_path=return_path, - ) - - def decorator(func: F) -> F: - assert_function_is_not_finalised(func) - - store = get_function_metadata_store(func) - store.model_parameter_names.append(model_kwarg_name) - if store.model_versions: - store.model_versions += "." - store.model_versions += f"{key}-v{actual_version}" - - @wraps(func) - def wrapper(*args: List[Any], **kwargs: Dict[str, Any]) -> Any: - tracing_context = TracingContext.get_current_tracing_context() - if tracing_context: - tracing_context.log_model(Model(key=key, version=actual_version)) - return func(*args, **kwargs, **{model_kwarg_name: model}) - - return cast(F, wrapper) - - return decorator diff --git a/src/great_ai/great_ai/output_models/__init__.py b/src/great_ai/great_ai/output_models/__init__.py deleted file mode 100644 index eb9f1e0..0000000 --- a/src/great_ai/great_ai/output_models/__init__.py +++ /dev/null @@ -1,3 +0,0 @@ -from .classification_output import ClassificationOutput -from .multi_label_classification_output import MultiLabelClassificationOutput -from .regression_output import RegressionOutput diff --git a/src/great_ai/great_ai/output_models/sequence_labeling_output.py b/src/great_ai/great_ai/output_models/sequence_labeling_output.py deleted file mode 100644 index 044a482..0000000 --- a/src/great_ai/great_ai/output_models/sequence_labeling_output.py +++ /dev/null @@ -1 +0,0 @@ -# todo diff --git a/src/great_ai/great_ai/parameters/__init__.py b/src/great_ai/great_ai/parameters/__init__.py deleted file mode 100644 index 195ecae..0000000 --- a/src/great_ai/great_ai/parameters/__init__.py +++ /dev/null @@ -1,3 +0,0 @@ -from .automatically_decorate_parameters import automatically_decorate_parameters -from .log_metric import log_metric -from .parameter import parameter diff --git a/src/great_ai/great_ai/parameters/log_metric.py b/src/great_ai/great_ai/parameters/log_metric.py deleted file mode 100644 index 30a1f4c..0000000 --- a/src/great_ai/great_ai/parameters/log_metric.py +++ /dev/null @@ -1,15 +0,0 @@ -import inspect -from typing import Any - -from ..context import get_context -from ..tracing import TracingContext - - -def log_metric(argument_name: str, value: Any) -> None: - tracing_context = TracingContext.get_current_tracing_context() - caller = inspect.stack()[1].function - actual_name = f"metric:{caller}:{argument_name}" - if tracing_context: - tracing_context.log_value(name=actual_name, value=value) - - get_context().logger.info(f"{actual_name}={value}") diff --git a/src/great_ai/great_ai/parameters/parameter.py b/src/great_ai/great_ai/parameters/parameter.py deleted file mode 100644 index 5312498..0000000 --- a/src/great_ai/great_ai/parameters/parameter.py +++ /dev/null @@ -1,51 +0,0 @@ -from functools import wraps -from typing import Any, Callable, Dict, TypeVar, cast - -from ..exceptions import ArgumentValidationError -from ..helper import get_arguments, get_function_metadata_store -from ..helper.assert_function_is_not_finalised import assert_function_is_not_finalised -from ..tracing.tracing_context import TracingContext - -F = TypeVar("F", bound=Callable[..., Any]) - - -def parameter( - parameter_name: str, - *, - validator: Callable[[Any], bool] = lambda _: True, - disable_logging: bool = False, -) -> Callable[[F], F]: - def decorator(func: F) -> F: - get_function_metadata_store(func).input_parameter_names.append(parameter_name) - assert_function_is_not_finalised(func) - - actual_name = f"arg:{parameter_name}" - - @wraps(func) - def wrapper(*args: Any, **kwargs: Dict[str, Any]) -> Any: - arguments = get_arguments(func, args, kwargs) - argument = arguments[parameter_name] - - expected_type = func.__annotations__.get(parameter_name) - - if expected_type is not None and not isinstance(argument, expected_type): - raise ArgumentValidationError( - f"Argument {parameter_name} in {func.__name__} has the wrong type, expected: {expected_type.__name__}, got: {type(argument).__name__}" - ) - - if not validator(argument): - raise ArgumentValidationError( - f"Argument {parameter_name} in {func.__name__} did not pass validation" - ) - - context = TracingContext.get_current_tracing_context() - if context and not disable_logging: - context.log_value(name=f"{actual_name}:value", value=argument) - if isinstance(argument, str): - context.log_value(name=f"{actual_name}:length", value=len(argument)) - - return func(*args, **kwargs) - - return cast(F, wrapper) - - return decorator diff --git a/src/great_ai/great_ai/persistence/__init__.py b/src/great_ai/great_ai/persistence/__init__.py deleted file mode 100644 index a2a97fe..0000000 --- a/src/great_ai/great_ai/persistence/__init__.py +++ /dev/null @@ -1,3 +0,0 @@ -from .mongodb_driver import MongodbDriver -from .parallel_tinydb_driver import ParallelTinyDbDriver -from .tracing_database_driver import TracingDatabaseDriver diff --git a/src/great_ai/great_ai/persistence/mongodb_driver.py b/src/great_ai/great_ai/persistence/mongodb_driver.py deleted file mode 100644 index 97926ca..0000000 --- a/src/great_ai/great_ai/persistence/mongodb_driver.py +++ /dev/null @@ -1,137 +0,0 @@ -from datetime import datetime -from typing import Any, List, Mapping, Optional, Sequence, Tuple - -from pymongo import MongoClient - -from ..views import Filter, SortBy, Trace -from .tracing_database_driver import TracingDatabaseDriver - -operator_mapping = { - "=": "$eq", - "!=": "$ne", - "<": "$lt", - "<=": "$lte", - ">": "$gt", - ">=": "$gte", - "contains": "$regex", -} - - -class MongodbDriver(TracingDatabaseDriver): - is_production_ready = True - - def __init__(self) -> None: - super().__init__() - if self.mongo_connection_string is None or self.mongo_database is None: - raise ValueError( - "Please configure the MongoDB access options by calling MongodbDriver.configure_credentials" - ) - - @classmethod - def configure_credentials( # type: ignore - cls, - *, - mongo_connection_string: str, - mongo_database: str, - **_: Mapping[str, Any], - ) -> None: - cls.mongo_connection_string = mongo_connection_string - cls.mongo_database = mongo_database - super().configure_credentials() - - def save(self, trace: Trace) -> str: - serialized = trace.to_flat_dict() - serialized["_id"] = trace.trace_id - - with MongoClient(self.mongo_connection_string) as client: - return client[self.mongo_database].traces.insert_one(serialized) - - def save_batch(self, documents: List[Trace]) -> List[str]: - serialized = [d.to_flat_dict() for d in documents] - for s in serialized: - s["_id"] = s["trace_id"] - - with MongoClient(self.mongo_connection_string) as client: - return client[self.mongo_database].traces.insert_many( - serialized, ordered=False - ) - - def get(self, id: str) -> Optional[Trace]: - with MongoClient(self.mongo_connection_string) as client: - value = client[self.mongo_database].traces.find_one(id) - - if value: - value = Trace.parse_obj(value) - - return value - - def _get_operator(self, filter: Filter) -> str: - if filter.operator == "contains" and not isinstance(filter.value, str): - return operator_mapping["="] - return operator_mapping[filter.operator] - - def query( - self, - *, - skip: int = 0, - take: Optional[int] = None, - conjunctive_filters: Sequence[Filter] = [], - conjunctive_tags: Sequence[str] = [], - since: Optional[datetime] = None, - until: Optional[datetime] = None, - has_feedback: Optional[bool] = None, - sort_by: Sequence[SortBy] = [], - ) -> Tuple[List[Trace], int]: - - query = { - "filter": { - "$and": [{"tags": tag} for tag in conjunctive_tags] - + [ - {f.property: {self._get_operator(f): f.value}} - for f in conjunctive_filters - ] - + [{}] - }, - "sort": [ - (col.column_id, 1 if col.direction == "asc" else -1) for col in sort_by - ], - } - - if skip: - query["skip"] = skip - - if take: - query["limit"] = take - - if since: - query["filter"]["$and"].append({"created": {"$gte": since}}) - - if until: - query["filter"]["$and"].append({"created": {"$lte": until}}) - - if has_feedback is not None: - query["filter"]["$and"].append( - {"feedback": {"$ne": None}} if has_feedback else {"feedback": None} - ) - - with MongoClient(self.mongo_connection_string) as client: - values = client[self.mongo_database].traces.find(**query) - documents = [Trace.parse_obj(t) for t in values] - - return documents, len(documents) - - def update(self, id: str, new_version: Trace) -> None: - serialized = new_version.dict() - serialized["_id"] = new_version.trace_id - with MongoClient(self.mongo_connection_string) as client: - client[self.mongo_database].traces.update_one(id, new_version) - - def delete(self, id: str) -> None: - with MongoClient(self.mongo_connection_string) as client: - client[self.mongo_database].traces.delete_one(id) - - def delete_batch(self, ids: List[str]) -> List[str]: - delete_filter = {"_id": {"$in": ids}} - - with MongoClient(self.mongo_connection_string) as client: - return client[self.mongo_database].traces.delete_many(delete_filter) diff --git a/src/great_ai/great_ai/remote/__init__.py b/src/great_ai/great_ai/remote/__init__.py deleted file mode 100644 index 9399b96..0000000 --- a/src/great_ai/great_ai/remote/__init__.py +++ /dev/null @@ -1,4 +0,0 @@ -from .call_remote_great_ai import call_remote_great_ai -from .call_remote_great_ai_async import call_remote_great_ai_async -from .http_client import HttpClient -from .remote_call_error import RemoteCallError diff --git a/src/great_ai/great_ai/remote/call_remote_great_ai.py b/src/great_ai/great_ai/remote/call_remote_great_ai.py deleted file mode 100644 index 449c64b..0000000 --- a/src/great_ai/great_ai/remote/call_remote_great_ai.py +++ /dev/null @@ -1,26 +0,0 @@ -import asyncio -from typing import Any, Mapping - -from ...utilities import get_logger -from ..views import Trace -from .call_remote_great_ai_async import call_remote_great_ai_async - -logger = get_logger("call_remote_great_ai") - - -def call_remote_great_ai( - base_uri: str, data: Mapping[str, Any], retry_count: int = 4 -) -> Trace: - try: - asyncio.get_running_loop() - raise Exception( - f"Already running in an event loop, you have to call `{call_remote_great_ai_async.__name__}`" - ) - except RuntimeError: - pass - - future = call_remote_great_ai_async( - base_uri=base_uri, data=data, retry_count=retry_count - ) - - return asyncio.run(future) diff --git a/src/great_ai/great_ai/remote/call_remote_great_ai_async.py b/src/great_ai/great_ai/remote/call_remote_great_ai_async.py deleted file mode 100644 index 4e99d08..0000000 --- a/src/great_ai/great_ai/remote/call_remote_great_ai_async.py +++ /dev/null @@ -1,25 +0,0 @@ -from typing import Any, Mapping, Optional - -from ..views import Trace -from .http_client import HttpClient -from .remote_call_error import RemoteCallError - -http: Optional[HttpClient] = None - - -async def call_remote_great_ai_async( - base_uri: str, data: Mapping[str, Any], retry_count: int = 4 -) -> Trace: - global http - if http is None: - http = HttpClient() - - url = f"{base_uri}/predict/" - response = await http.post( - url=url, data=data, retry_count=retry_count, expected_status=200 - ) - - try: - return Trace.parse_obj(response) - except Exception: - raise RemoteCallError("Could not parse response") diff --git a/src/great_ai/great_ai/remote/http_client.py b/src/great_ai/great_ai/remote/http_client.py deleted file mode 100644 index c6d8255..0000000 --- a/src/great_ai/great_ai/remote/http_client.py +++ /dev/null @@ -1,60 +0,0 @@ -import logging -from asyncio import sleep -from typing import Any, Mapping, Optional - -import aiohttp - -from .remote_call_error import RemoteCallError - -logger = logging.getLogger("http") - - -class HttpClient: - timeout_seconds: int = 600 - wait_between_retries_seconds: float = 5 - - def __init__( - self, - ) -> None: - timeout = aiohttp.ClientTimeout(total=self.timeout_seconds) - - self._session = aiohttp.ClientSession( - raise_for_status=False, - timeout=timeout, - ) - - async def post( - self, - url: str, - data: Mapping[str, Any], - retry_count: int = 0, - expected_status: Optional[int] = None, - **kwargs: Any, - ) -> Any: - for i in range(retry_count + 1): - try: - async with self._session.post(url, json=data, **kwargs) as r: - if ( - expected_status is not None and r.status != expected_status - ) or r.status >= 500: - response_text = await r.text() - raise ValueError( - f"Found not-expected status code: {r.status}, response is: {response_text}" - ) - try: - return await r.json() - except Exception: - raise RemoteCallError( - "JSON parsing failed", - ) - except Exception as e: - logger.warning( - f"Request failed ({e}), {retry_count - i - 1} retries left", - ) - if retry_count - i > 1: - await sleep(self.wait_between_retries_seconds) - - raise RemoteCallError("Request has failed too many times") - - async def close(self) -> None: - await self._session.close() diff --git a/src/great_ai/great_ai/tracing/__init__.py b/src/great_ai/great_ai/tracing/__init__.py deleted file mode 100644 index e34184c..0000000 --- a/src/great_ai/great_ai/tracing/__init__.py +++ /dev/null @@ -1,4 +0,0 @@ -from .add_ground_truth import add_ground_truth -from .delete_ground_truth import delete_ground_truth -from .query_ground_truth import query_ground_truth -from .tracing_context import TracingContext diff --git a/src/great_ai/great_ai/tracing/add_ground_truth.py b/src/great_ai/great_ai/tracing/add_ground_truth.py deleted file mode 100644 index 3702756..0000000 --- a/src/great_ai/great_ai/tracing/add_ground_truth.py +++ /dev/null @@ -1,67 +0,0 @@ -from datetime import datetime -from math import ceil -from random import shuffle -from typing import Any, Iterable, List, TypeVar - -from ..constants import ( - GROUND_TRUTH_TAG_NAME, - TEST_SPLIT_TAG_NAME, - TRAIN_SPLIT_TAG_NAME, - VALIDATION_SPLIT_TAG_NAME, -) -from ..context import get_context -from ..views import Trace - -T = TypeVar("T") - - -def add_ground_truth( - inputs: Iterable[Any], - expected_outputs: Iterable[T], - *, - tags: List[str] = [], - train_split_ratio: float, - test_split_ratio: float, - validation_split_ratio: float = 0 -) -> None: - get_context() # this resets the seed - - inputs = list(inputs) - expected_outputs = list(expected_outputs) - assert len(inputs) == len( - expected_outputs - ), "The length of the inputs and expected_outputs must be equal" - - sum_ratio = train_split_ratio + test_split_ratio + validation_split_ratio - assert sum_ratio > 0, "The sum of the split ratios must be a positive number" - - train_split_ratio /= sum_ratio - test_split_ratio /= sum_ratio - validation_split_ratio /= sum_ratio - - values = list(zip(inputs, expected_outputs)) - shuffle(values) - - split_tags = ( - [TRAIN_SPLIT_TAG_NAME] * ceil(train_split_ratio * len(inputs)) - + [TEST_SPLIT_TAG_NAME] * ceil(test_split_ratio * len(inputs)) - + [VALIDATION_SPLIT_TAG_NAME] * ceil(validation_split_ratio * len(inputs)) - ) - shuffle(split_tags) - - created = datetime.utcnow().isoformat() - traces = [ - Trace( - created=created, - original_execution_time_ms=0, - logged_values=X if isinstance(X, dict) else {"input": X}, - models=[], - output=y, - feedback=y, - exception=None, - tags=[GROUND_TRUTH_TAG_NAME, split_tag, *tags], - ) - for ((X, y), split_tag) in zip(values, split_tags) - ] - - get_context().tracing_database.save_batch(traces) diff --git a/src/great_ai/great_ai/tracing/delete_ground_truth.py b/src/great_ai/great_ai/tracing/delete_ground_truth.py deleted file mode 100644 index ef1620e..0000000 --- a/src/great_ai/great_ai/tracing/delete_ground_truth.py +++ /dev/null @@ -1,22 +0,0 @@ -from datetime import datetime -from typing import List, Optional, Union - -from ..context import get_context - - -def delete_ground_truth( - conjunctive_tags: Union[List[str], str] = [], - *, - until: Optional[datetime] = None, - since: Optional[datetime] = None, -) -> None: - tags = ( - conjunctive_tags if isinstance(conjunctive_tags, list) else [conjunctive_tags] - ) - db = get_context().tracing_database - - items, length = db.query( - conjunctive_tags=tags, until=until, since=since, has_feedback=True - ) - - db.delete_batch([i.trace_id for i in items]) diff --git a/src/great_ai/great_ai/tracing/query_ground_truth.py b/src/great_ai/great_ai/tracing/query_ground_truth.py deleted file mode 100644 index b58d3ea..0000000 --- a/src/great_ai/great_ai/tracing/query_ground_truth.py +++ /dev/null @@ -1,22 +0,0 @@ -from datetime import datetime -from typing import List, Optional, Union - -from ..context import get_context -from ..views import Trace - - -def query_ground_truth( - conjunctive_tags: Union[List[str], str] = [], - *, - since: Optional[datetime] = None, - return_max_count: Optional[int] = None -) -> List[Trace]: - tags = ( - conjunctive_tags if isinstance(conjunctive_tags, list) else [conjunctive_tags] - ) - db = get_context().tracing_database - - items, length = db.query( - conjunctive_tags=tags, since=since, take=return_max_count, has_feedback=True - ) - return items diff --git a/src/great_ai/great_ai/tracing/tracing_context.py b/src/great_ai/great_ai/tracing/tracing_context.py deleted file mode 100644 index 21bc871..0000000 --- a/src/great_ai/great_ai/tracing/tracing_context.py +++ /dev/null @@ -1,97 +0,0 @@ -import threading -from collections import defaultdict -from datetime import datetime -from types import TracebackType -from typing import ( - Any, - DefaultDict, - Dict, - Generic, - List, - Literal, - Optional, - Type, - TypeVar, -) - -from ..constants import DEVELOPMENT_TAG_NAME, ONLINE_TAG_NAME, PRODUCTION_TAG_NAME -from ..context import get_context -from ..views import Model, Trace - -T = TypeVar("T") - - -class TracingContext(Generic[T]): - _contexts: DefaultDict[int, List["TracingContext"]] = defaultdict(lambda: []) - - def __init__(self, function_name: str, do_not_persist_traces: bool) -> None: - self._do_not_persist_traces = do_not_persist_traces - self._models: List[Model] = [] - self._values: Dict[str, Any] = {} - self._trace: Optional[Trace[T]] = None - self._start_time = datetime.utcnow() - self._name = function_name - - def log_value(self, name: str, value: Any) -> None: - self._values[name] = value - - def log_model(self, model: Model) -> None: - self._models.append(model) - - def finalise(self, output: T = None, exception: BaseException = None) -> Trace[T]: - assert self._trace is None, "has been already finalised" - - delta_time = (datetime.utcnow() - self._start_time).microseconds / 1000 - self._trace = Trace( - created=self._start_time.isoformat(), - original_execution_time_ms=delta_time, - logged_values=self._values, - models=self._models, - output=output, - exception=None - if exception is None - else f"{type(exception).__name__}: {exception}", - tags=[ - self._name, - ONLINE_TAG_NAME, - PRODUCTION_TAG_NAME - if get_context().is_production - else DEVELOPMENT_TAG_NAME, - ], - ) - - return self._trace - - @classmethod - def get_current_tracing_context(cls) -> Optional["TracingContext"]: - if cls._contexts[threading.get_ident()]: - return cls._contexts[threading.get_ident()][-1] - return None - - def __enter__(self) -> "TracingContext": - self._contexts[threading.get_ident()].append(self) - return self - - def __exit__( - self, - type: Optional[Type[BaseException]], - exception: Optional[BaseException], - traceback: Optional[TracebackType], - ) -> Literal[False]: - assert self._contexts[threading.get_ident()][-1] == self - self._contexts[threading.get_ident()].remove(self) - - if exception is not None and type is not None: - self.finalise(exception=exception) - if get_context().should_log_exception_stack: - get_context().logger.exception("Could not finish operation") - else: - get_context().logger.error( - f"Could not finish operation because of {type.__name__}: {exception}" - ) - - assert self._trace is not None - if not self._do_not_persist_traces: - get_context().tracing_database.save(self._trace) - - return False diff --git a/src/great_ai/large_file/__init__.py b/src/great_ai/large_file/__init__.py deleted file mode 100644 index 576173b..0000000 --- a/src/great_ai/large_file/__init__.py +++ /dev/null @@ -1 +0,0 @@ -from .large_file import LargeFile, LargeFileLocal, LargeFileMongo, LargeFileS3 diff --git a/src/great_ai/large_file/large_file/__init__.py b/src/great_ai/large_file/large_file/__init__.py deleted file mode 100644 index 60b5aaf..0000000 --- a/src/great_ai/large_file/large_file/__init__.py +++ /dev/null @@ -1,4 +0,0 @@ -from .large_file import LargeFile -from .large_file_local import LargeFileLocal -from .large_file_mongo import LargeFileMongo -from .large_file_s3 import LargeFileS3 diff --git a/src/great_ai/utilities/__init__.py b/src/great_ai/utilities/__init__.py deleted file mode 100644 index c06e891..0000000 --- a/src/great_ai/utilities/__init__.py +++ /dev/null @@ -1,9 +0,0 @@ -from .clean import clean -from .config_file import ConfigFile, ParseError -from .evaluate_ranking import evaluate_ranking -from .get_sentences import get_sentences -from .language import english_name_of_language, is_english, predict_language -from .logger import get_logger -from .match_names import match_names -from .parallel_map import parallel_map -from .unique import unique diff --git a/src/great_ai/utilities/config_file/__init__.py b/src/great_ai/utilities/config_file/__init__.py deleted file mode 100644 index 6eabc46..0000000 --- a/src/great_ai/utilities/config_file/__init__.py +++ /dev/null @@ -1,2 +0,0 @@ -from .config_file import ConfigFile -from .parse_error import ParseError diff --git a/src/great_ai/utilities/config_file/config_file.py b/src/great_ai/utilities/config_file/config_file.py deleted file mode 100644 index c6be097..0000000 --- a/src/great_ai/utilities/config_file/config_file.py +++ /dev/null @@ -1,87 +0,0 @@ -import os -from pathlib import Path -from typing import Dict, Iterable, Tuple, Union - -from ..logger import get_logger -from .parse_error import ParseError -from .pattern import pattern - -ENVIRONMENT_VARIABLE_KEY_PREFIX = "ENV" - -logger = get_logger("ConfigFile") - - -class ConfigFile: - def __init__( - self, path: Union[Path, str], ignore_missing_environment_variables: bool = False - ) -> None: - if not isinstance(path, Path): - path = Path(path) - - if not path.exists(): - raise FileNotFoundError(path.absolute()) - - self._path = path - self._ignore_missing_environment_variables = ( - ignore_missing_environment_variables - ) - self._key_values: Dict[str, str] = {} - - self._parse() - - def _parse(self): - with open(self._path, encoding="utf-8") as f: - lines: str = f.read() - - matches = pattern.findall(lines) - for key, *values in matches: - if key in self._key_values: - raise KeyError( - f"Key `{key}` has been already defined and its value is `{self._key_values[key]}`" - ) - - try: - value = next(v for v in values if v) - except StopIteration: - raise ParseError( - f"Cannot parse config file ({self._path.absolute()}), error at key `{key}`" - ) - - if value.startswith(f"{ENVIRONMENT_VARIABLE_KEY_PREFIX}:"): - _, value = value.split(":") - if value not in os.environ: - issue = f'The value of `{key}` contains the "{ENVIRONMENT_VARIABLE_KEY_PREFIX}` prefix but `{value}` is not defined as an environment variable' - if self._ignore_missing_environment_variables: - logger.warning(f"{issue}, defaulting to `None`") - else: - raise KeyError(issue) - value = os.environ[value] - - self._key_values[key] = value - - def __getattr__(self, key: str) -> str: - if key in self._key_values: - return self._key_values[key] - raise KeyError( - f"Key `{key}` is not found in configuration file ({self._path.absolute()})" - ) - - __getitem__ = __getattr__ - - def __iter__(self) -> Iterable[Tuple[str, str]]: - return iter(self._key_values) - - def __len__(self) -> int: - return len(self._key_values) - - def keys(self): - return self._key_values.keys() - - def values(self): - return self._key_values.values() - - def items(self): - return self._key_values.items() - - def __repr__(self): - return f"{type(self).__name__}(\n path={self._path},\n ignore_missing_environment_variables={self._ignore_missing_environment_variables}\n) {{{self._key_values}}}" diff --git a/src/great_ai/utilities/evaluate_ranking/__init__.py b/src/great_ai/utilities/evaluate_ranking/__init__.py deleted file mode 100644 index 94226bb..0000000 --- a/src/great_ai/utilities/evaluate_ranking/__init__.py +++ /dev/null @@ -1,2 +0,0 @@ -from .draw_f1_iso_lines import draw_f1_iso_lines -from .evaluate_ranking import evaluate_ranking diff --git a/src/great_ai/utilities/language/__init__.py b/src/great_ai/utilities/language/__init__.py deleted file mode 100644 index 1ec3102..0000000 --- a/src/great_ai/utilities/language/__init__.py +++ /dev/null @@ -1,3 +0,0 @@ -from .english_name_of_language import english_name_of_language -from .is_english import is_english -from .predict_language import predict_language diff --git a/src/great_ai/utilities/language/english_name_of_language.py b/src/great_ai/utilities/language/english_name_of_language.py deleted file mode 100644 index 9019c4d..0000000 --- a/src/great_ai/utilities/language/english_name_of_language.py +++ /dev/null @@ -1,10 +0,0 @@ -from typing import Optional - -from langcodes import Language - - -def english_name_of_language(language_code: Optional[str]) -> str: - if not language_code: - language_code = "und" - - return Language.get(language_code).display_name() diff --git a/src/great_ai/utilities/language/is_english.py b/src/great_ai/utilities/language/is_english.py deleted file mode 100644 index 24fb77c..0000000 --- a/src/great_ai/utilities/language/is_english.py +++ /dev/null @@ -1,11 +0,0 @@ -from typing import Optional - -from langcodes import standardize_tag, tag_distance - - -def is_english(language_code: Optional[str]) -> bool: - if not language_code: - language_code = "und" - - language_code = standardize_tag(language_code) - return tag_distance(language_code, "en") < 15 diff --git a/src/great_ai/utilities/language/predict_language.py b/src/great_ai/utilities/language/predict_language.py deleted file mode 100644 index 1fc3955..0000000 --- a/src/great_ai/utilities/language/predict_language.py +++ /dev/null @@ -1,16 +0,0 @@ -from typing import Optional - -from langcodes import Language -from langdetect import LangDetectException, detect - - -def predict_language(text: Optional[str]) -> str: - if not text: - return Language.make().to_tag() - - try: - language_code = detect(text) - except LangDetectException: - return Language.make().to_tag() - - return Language.get(language_code).to_tag() diff --git a/src/great_ai/utilities/logger/__init__.py b/src/great_ai/utilities/logger/__init__.py deleted file mode 100644 index 20f9099..0000000 --- a/src/great_ai/utilities/logger/__init__.py +++ /dev/null @@ -1,2 +0,0 @@ -from .custom_formatter import CustomFormatter -from .get_logger import get_logger diff --git a/src/great_ai/utilities/logger/custom_formatter.py b/src/great_ai/utilities/logger/custom_formatter.py deleted file mode 100644 index 81cb958..0000000 --- a/src/great_ai/utilities/logger/custom_formatter.py +++ /dev/null @@ -1,21 +0,0 @@ -import logging - -from .colors import BLUE, BOLD_RED, GREY, RED, RESET, YELLOW - - -class CustomFormatter(logging.Formatter): - def __init__(self, fmt: str): - super().__init__() - self._fmt = fmt - self._color_mapping = { - logging.DEBUG: GREY + self._fmt + RESET, - logging.INFO: BLUE + self._fmt + RESET, - logging.WARNING: YELLOW + self._fmt + RESET, - logging.ERROR: RED + self._fmt + RESET, - logging.CRITICAL: BOLD_RED + self._fmt + RESET, - } - - def format(self, record: logging.LogRecord) -> str: - log_fmt = self._color_mapping.get(record.levelno) - formatter = logging.Formatter(log_fmt) - return formatter.format(record) diff --git a/src/great_ai/utilities/logger/get_logger.py b/src/great_ai/utilities/logger/get_logger.py deleted file mode 100644 index 7f83634..0000000 --- a/src/great_ai/utilities/logger/get_logger.py +++ /dev/null @@ -1,23 +0,0 @@ -import logging -from typing import Dict - -from .custom_formatter import CustomFormatter - -loggers: Dict[str, logging.Logger] = {} - - -def get_logger(name: str, level: int = logging.INFO) -> logging.Logger: - if name not in loggers: - logger = logging.getLogger(name) - logger.setLevel(level) - - fmt = "%(asctime)s | %(levelname)8s | %(message)s" - - stdout_handler = logging.StreamHandler() - stdout_handler.setLevel(logging.DEBUG) - stdout_handler.setFormatter(CustomFormatter(fmt)) - - logger.addHandler(stdout_handler) - loggers[name] = logger - - return loggers[name] diff --git a/src/great_ai/utilities/match_names/__init__.py b/src/great_ai/utilities/match_names/__init__.py deleted file mode 100644 index d7bc1d1..0000000 --- a/src/great_ai/utilities/match_names/__init__.py +++ /dev/null @@ -1 +0,0 @@ -from .match_names import get_name_match_score, get_name_parts, match_names diff --git a/src/great_ai/utilities/match_names/config.py b/src/great_ai/utilities/match_names/config.py deleted file mode 100644 index 6c99041..0000000 --- a/src/great_ai/utilities/match_names/config.py +++ /dev/null @@ -1,5 +0,0 @@ -last_name_weight = 1.5 -first_name_weight = 0.9 -infixes_weight = 0.5 -initials_weight = 0.6 -match_threshold = 1.51 diff --git a/src/great_ai/utilities/match_names/match_names.py b/src/great_ai/utilities/match_names/match_names.py deleted file mode 100644 index ffc0197..0000000 --- a/src/great_ai/utilities/match_names/match_names.py +++ /dev/null @@ -1,162 +0,0 @@ -import functools -import re -from typing import List, Optional, Tuple - -from ..clean import clean -from .config import ( - first_name_weight, - infixes_weight, - initials_weight, - last_name_weight, - match_threshold, -) -from .name_parts import NameParts - - -def match_names(n1: Optional[str], n2: Optional[str]) -> bool: - score = get_name_match_score(n1, n2) - return score > match_threshold - - -def get_name_match_score(n1: Optional[str], n2: Optional[str]) -> float: - if not n1 or not n2: - return 0 - - p1 = get_name_parts(n1) - p2 = get_name_parts(n2) - - for f1 in p1.first_names: - for f2 in p2.first_names: - if f1[0] == f2[0]: - p1.initials = [i for i in p1.initials if i != f1[0]] - p2.initials = [i for i in p2.initials if i != f1[0]] - - last_name_score = last_name_weight * _match_percentage(p1.last_names, p2.last_names) - first_name_score = first_name_weight * _match_percentage( - p1.first_names, p2.first_names - ) - initials_score = initials_weight * _match_percentage(p1.initials, p2.initials) - infixes_score = min(0, infixes_weight * _match_percentage(p1.infixes, p2.infixes)) - - return last_name_score + first_name_score + initials_score + infixes_score - - -def get_name_parts(name: str) -> NameParts: - result = _get_name_parts(name) - return result.copy() - - -@functools.lru_cache(maxsize=None) -def _get_name_parts(name: str) -> NameParts: - name = _clean_name(name) - - first_names, name = _get_parenthesized_first_names(name) - initials, name = _get_initials(name) - - last_names = [] - infixes, name = _get_infixes(name) - if "," in name: - [last_name, *rest] = name.split(",") - rest_combined = " ".join(rest) - last_names.extend(last_name.split(" ")) - first_names.extend(rest_combined.split(" ")) - else: - parts = name.strip().split(" ") - if parts: - last_names.append(parts[-1]) - parts.pop(-1) - first_names.extend(parts) - else: - last_names.append(name) - - first_names = [f for f in first_names if f] - for f in first_names: - if all(f[0] != i for i in initials): - initials.append(f[0]) - - return NameParts( - first_names=first_names, - initials=initials, - infixes=infixes, - last_names=[ - name - for last_name in last_names - for name in (last_name.split("-") if "-" in last_name else [last_name]) - if name - ], - ) - - -def _clean_name(name: str) -> str: - name = clean(name, convert_to_ascii=True) - - name = re.sub( - r""" - (MD|PhD|Ir|dr|Dr|DR|MSc|MA|BSc|BA|Prof) - [,.]? - [ ]* - """, - "", - name, - flags=re.VERBOSE, - ) - - subs_made = 1 - while subs_made: - name, subs_made = re.subn(r"([A-Z]\.)\s+([A-Z])\b", r"\g<1>\g<2>", name) - - name = name.replace(r"\s+-\s+", "-") - name = " ".join(p for p in name.split(" ") if p) - name = re.sub(r"^([^,.]+) ([A-Z])$", r"\g<1>, \g<2>.", name) - return name - - -def _get_parenthesized_first_names(name: str) -> Tuple[List[str], str]: - groups = re.search(r"\(([a-zA-Z ]+)\)", name) - if groups: - return ( - groups.group(1).split(" "), - _remove_between_indices(name, groups.start(), groups.end()), - ) - - return [], name - - -def _get_initials(n: str) -> Tuple[List[str], str]: - initials = [] - - groups = re.search(r"\b(?P([A-Z]\.)*)(?P[A-Z])(\.|$)", n) - if groups: - first_name_abbreviations = [ - *groups.group("abr1").split("."), - groups.group("abr2"), - ] - first_name_abbreviations = [f for f in first_name_abbreviations if f != ""] - initials.extend(first_name_abbreviations) - n = _remove_between_indices(n, groups.start(), groups.end()) - - return initials, n - - -def _get_infixes(n: str) -> Tuple[List[str], str]: - infixes = ["de", "van", "der", "den", "te", "ter", "ten"] - - parts = n.split(" ") - return [p for p in parts if p.lower() in infixes], " ".join( - p for p in parts if p.lower() not in infixes - ) - - -def _remove_between_indices(s: str, start: int, end: int) -> str: - return s[:start] + s[end:] - - -def _match_percentage(l1: List[str], l2: List[str]) -> float: - if not l1 or not l2: - return 0 - - s1 = set(l1) - s2 = set(l2) - common_q = 2 * len(s1 & s2) / (len(s1) + len(s2)) - different_q = min(len(s1 - s2) / len(s1), len(s2 - s1) / len(s2)) - return common_q - different_q diff --git a/src/great_ai/utilities/match_names/name_parts.py b/src/great_ai/utilities/match_names/name_parts.py deleted file mode 100644 index 0d4c938..0000000 --- a/src/great_ai/utilities/match_names/name_parts.py +++ /dev/null @@ -1,10 +0,0 @@ -from typing import List - -from pydantic import BaseModel - - -class NameParts(BaseModel): - first_names: List[str] - initials: List[str] - infixes: List[str] - last_names: List[str] diff --git a/src/great_ai/utilities/parallel_map.py b/src/great_ai/utilities/parallel_map.py deleted file mode 100644 index 14fa621..0000000 --- a/src/great_ai/utilities/parallel_map.py +++ /dev/null @@ -1,52 +0,0 @@ -from math import ceil -from typing import Any, Callable, Iterable, List, Optional - -import multiprocess as mp -from tqdm.cli import tqdm - -from .logger import get_logger - -logger = get_logger("parallel_map") - - -def parallel_map( - function: Callable[[Any], Any], - values: Iterable[Any], - chunk_size: Optional[int] = None, - concurrency: Optional[int] = None, - disable_progress: bool = False, -) -> List[Any]: - if concurrency is None: - concurrency = mp.cpu_count() - - assert concurrency > 0 - assert chunk_size is None or chunk_size > 0 - - values = list(values) - - if not chunk_size: - chunk_size = max(1, ceil(len(values) / concurrency / 10)) - - chunk_count = ceil(len(values) / chunk_size) - if chunk_count < concurrency: - logger.warning( - f"Limiting concurrency to {chunk_count} because there are only {chunk_count} chunks" - ) - concurrency = chunk_count - - logger.info( - f"Starting parallel map (concurrency: {concurrency}, chunk size: {chunk_size})" - ) - - if concurrency == 1 or len(values) <= chunk_size: - logger.warning("Running in series, there is no reason for parallelism") - iterable = values if disable_progress else tqdm(values) - return [function(v) for v in iterable] - - with mp.Pool(processes=concurrency) as pool: - if disable_progress: - return pool.map(function, values, chunksize=chunk_size) - - return list( - tqdm(pool.imap(function, values, chunksize=chunk_size), total=len(values)) - ) diff --git a/src/great_ai/utilities/unique.py b/src/great_ai/utilities/unique.py deleted file mode 100644 index de3a634..0000000 --- a/src/great_ai/utilities/unique.py +++ /dev/null @@ -1,16 +0,0 @@ -from typing import Any, Callable, Iterable, List - - -def unique( - values: Iterable[Any], *, key: Callable[[Any], Any] = lambda v: v -) -> List[Any]: - """Only keep first occurrences and maintain order""" - - key_values = {} - for v in values: - k = key(v) - if k not in key_values: - # dicts maintain insertion order: https://mail.python.org/pipermail/python-dev/2017-December/151283.html - key_values[k] = v - - return list(key_values.values()) diff --git a/tests/external/__init__.py b/tests/external/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/external/conftest.py b/tests/external/conftest.py new file mode 100644 index 0000000..1fb0b17 --- /dev/null +++ b/tests/external/conftest.py @@ -0,0 +1,47 @@ +import asyncio +import gc +import os + +import pytest +from great_ai.external.async_lru import _CacheInfo + +asyncio.set_event_loop(None) + + +@pytest.fixture +def event_loop(request): + loop = asyncio.new_event_loop() + loop.set_debug(bool(os.environ.get("PYTHONASYNCIODEBUG"))) + + yield loop + + loop.call_soon(loop.stop) + loop.run_forever() + loop.close() + + gc.collect() + + +@pytest.fixture +def loop(event_loop, request): + asyncio.set_event_loop(None) + request.addfinalizer(lambda: asyncio.set_event_loop(None)) + + return event_loop + + +@pytest.fixture +def check_lru(request): + def _check_lru(wrapped, *, hits, misses, cache, tasks, maxsize=128): + assert wrapped.hits == hits + assert wrapped.misses == misses + assert len(wrapped._cache) == cache + assert len(wrapped.tasks) == tasks + assert wrapped.cache_info() == _CacheInfo( + hits=hits, + misses=misses, + maxsize=maxsize, + currsize=cache, + ) + + return _check_lru diff --git a/tests/external/test_basic.py b/tests/external/test_basic.py new file mode 100644 index 0000000..604662d --- /dev/null +++ b/tests/external/test_basic.py @@ -0,0 +1,187 @@ +import asyncio +from functools import partial + +import pytest +from great_ai.external.async_lru import alru_cache + +alru_cache_attrs = [ + "hits", + "misses", + "tasks", + "closed", + "cache_info", + "cache_clear", + "invalidate", + "close", + "open", +] + +alru_cache_calable_attrs = alru_cache_attrs.copy() +for attr in ["hits", "misses", "tasks", "closed"]: + alru_cache_calable_attrs.remove(attr) + + +def test_alru_cache_not_callable(loop): + with pytest.raises(NotImplementedError): + alru_cache("foo") + + +def test_alru_cache_not_coroutine(loop): + with pytest.raises(RuntimeError): + + @alru_cache + def not_coro(val): + return val + + +def test_alru_cache_deco(loop, check_lru): + asyncio.set_event_loop(loop) + + @alru_cache + async def coro(): + pass + + assert asyncio.iscoroutinefunction(coro) + + for attr in alru_cache_attrs: + assert hasattr(coro, attr) + for attr in alru_cache_calable_attrs: + assert callable(getattr(coro, attr)) + + assert isinstance(coro._cache, dict) + assert isinstance(coro.tasks, set) + check_lru(coro, hits=0, misses=0, cache=0, tasks=0) + + awaitable = coro() + assert asyncio.iscoroutine(awaitable) + loop.run_until_complete(awaitable) + + +def test_alru_cache_deco_called(check_lru, loop): + asyncio.set_event_loop(loop) + + @alru_cache() + async def coro(): + pass + + assert asyncio.iscoroutinefunction(coro) + + for attr in alru_cache_attrs: + assert hasattr(coro, attr) + for attr in alru_cache_calable_attrs: + assert callable(getattr(coro, attr)) + + assert isinstance(coro._cache, dict) + assert isinstance(coro.tasks, set) + check_lru(coro, hits=0, misses=0, cache=0, tasks=0) + + awaitable = coro() + assert asyncio.iscoroutine(awaitable) + loop.run_until_complete(awaitable) + + +def test_alru_cache_fn_called(check_lru, loop): + asyncio.set_event_loop(loop) + + async def coro(): + pass + + coro_wrapped = alru_cache(coro) + + assert asyncio.iscoroutinefunction(coro_wrapped) + + for attr in alru_cache_attrs: + assert hasattr(coro_wrapped, attr) + for attr in alru_cache_calable_attrs: + assert callable(getattr(coro_wrapped, attr)) + + assert isinstance(coro_wrapped._cache, dict) + assert isinstance(coro_wrapped.tasks, set) + check_lru(coro_wrapped, hits=0, misses=0, cache=0, tasks=0) + + awaitable = coro_wrapped() + assert asyncio.iscoroutine(awaitable) + loop.run_until_complete(awaitable) + + +def test_alru_cache_origin(loop): + asyncio.set_event_loop(loop) + + async def coro(): + pass + + coro_wrapped = alru_cache(coro) + + assert coro_wrapped._origin is coro + + coro_wrapped = alru_cache(partial(coro)) + + assert coro_wrapped._origin is coro + + +@pytest.mark.asyncio +async def test_alru_cache_await_same_result_async(check_lru, loop): + calls = 0 + val = object() + + @alru_cache() + async def coro(): + nonlocal calls + calls += 1 + + return val + + coros = [coro() for _ in range(100)] + ret = await asyncio.gather(*coros) + expected = [val] * 100 + assert ret == expected + check_lru(coro, hits=99, misses=1, cache=1, tasks=0) + + assert calls == 1 + assert await coro() is val + check_lru(coro, hits=100, misses=1, cache=1, tasks=0) + + +@pytest.mark.asyncio +async def test_alru_cache_await_same_result_coroutine(check_lru, loop): + calls = 0 + val = object() + + @alru_cache() + async def coro(): + nonlocal calls + calls += 1 + + return val + + coros = [coro() for _ in range(100)] + ret = await asyncio.gather(*coros) + expected = [val] * 100 + assert ret == expected + check_lru(coro, hits=99, misses=1, cache=1, tasks=0) + + assert calls == 1 + assert await coro() is val + check_lru(coro, hits=100, misses=1, cache=1, tasks=0) + + +@pytest.mark.asyncio +async def test_alru_cache_dict_not_shared(check_lru, loop): + async def coro(val): + return val + + coro1 = alru_cache()(coro) + coro2 = alru_cache()(coro) + + ret1 = await coro1(1) + check_lru(coro1, hits=0, misses=1, cache=1, tasks=0) + + ret2 = await coro2(1) + check_lru(coro2, hits=0, misses=1, cache=1, tasks=0) + + assert ret1 == ret2 + + assert coro1._cache[1].result() == coro2._cache[1].result() + assert coro1._cache != coro2._cache + assert coro1._cache.keys() == coro2._cache.keys() + assert coro1._cache is not coro2._cache diff --git a/tests/external/test_cache_clear.py b/tests/external/test_cache_clear.py new file mode 100644 index 0000000..4e59ea6 --- /dev/null +++ b/tests/external/test_cache_clear.py @@ -0,0 +1,22 @@ +import asyncio + +import pytest +from great_ai.external.async_lru import alru_cache + +pytestmark = pytest.mark.asyncio + + +async def test_cache_clear(check_lru, loop): + @alru_cache() + async def coro(val): + return val + + inputs = [1, 2, 3] + coros = [coro(v) for v in inputs] + ret = await asyncio.gather(*coros) + assert ret == inputs + check_lru(coro, hits=0, misses=3, cache=3, tasks=0) + + coro.cache_clear() + + check_lru(coro, hits=0, misses=0, cache=0, tasks=0) diff --git a/tests/external/test_cache_info.py b/tests/external/test_cache_info.py new file mode 100644 index 0000000..1a39b96 --- /dev/null +++ b/tests/external/test_cache_info.py @@ -0,0 +1,38 @@ +import asyncio + +import pytest +from great_ai.external.async_lru import alru_cache + +pytestmark = pytest.mark.asyncio + + +async def test_cache_info(check_lru, loop): + @alru_cache(maxsize=4) + async def coro(val): + return val + + inputs = [1, 2, 3] + coros = [coro(v) for v in inputs] + ret = await asyncio.gather(*coros) + assert ret == inputs + check_lru(coro, hits=0, misses=3, cache=3, tasks=0, maxsize=4) + + coro.cache_clear() + + check_lru(coro, hits=0, misses=0, cache=0, tasks=0, maxsize=4) + + inputs = [1, 1, 1] + coros = [coro(v) for v in inputs] + ret = await asyncio.gather(*coros) + assert ret == inputs + check_lru(coro, hits=2, misses=1, cache=1, tasks=0, maxsize=4) + + coro.cache_clear() + + check_lru(coro, hits=0, misses=0, cache=0, tasks=0, maxsize=4) + + inputs = [1, 2, 3, 4] * 2 + coros = [coro(v) for v in inputs] + ret = await asyncio.gather(*coros) + assert ret == inputs + check_lru(coro, hits=4, misses=4, cache=4, tasks=0, maxsize=4) diff --git a/tests/external/test_cache_invalidate.py b/tests/external/test_cache_invalidate.py new file mode 100644 index 0000000..48dfd8c --- /dev/null +++ b/tests/external/test_cache_invalidate.py @@ -0,0 +1,85 @@ +import asyncio + +import pytest +from great_ai.external.async_lru import alru_cache + +pytestmark = pytest.mark.asyncio + + +async def test_cache_invalidate(check_lru, loop): + @alru_cache() + async def coro(val): + return val + + inputs = [1, 2, 3] + + coro.invalidate(1) + coro.invalidate(2) + coro.invalidate(3) + + coros = [coro(v) for v in inputs] + + ret = await asyncio.gather(*coros) + + assert ret == inputs + check_lru(coro, hits=0, misses=3, cache=3, tasks=0) + + coro.invalidate(1) + check_lru(coro, hits=0, misses=3, cache=2, tasks=0) + coro.invalidate(2) + check_lru(coro, hits=0, misses=3, cache=1, tasks=0) + coro.invalidate(3) + check_lru(coro, hits=0, misses=3, cache=0, tasks=0) + + inputs = [1, 2, 3] + coros = [coro(v) for v in inputs] + + ret = await asyncio.gather(*coros) + + assert ret == inputs + check_lru(coro, hits=0, misses=6, cache=3, tasks=0) + + +async def test_cache_invalidate_multiple_args(check_lru, loop): + @alru_cache() + async def coro(*args): + return len(args) + + for i, size in enumerate(range(10)): + args = tuple(range(size)) + ret = await coro(*args) + assert ret == size + check_lru(coro, hits=0, misses=i + 1, cache=1, tasks=0) + coro.invalidate(*args) + check_lru(coro, hits=0, misses=i + 1, cache=0, tasks=0) + + for size in range(10): + args = tuple(range(size)) + ret = await coro(*args) + assert ret == size + check_lru(coro, hits=0, misses=20, cache=10, tasks=0) + + +async def test_cache_invalidate_multiple_args_different_order(check_lru, loop): + @alru_cache() + async def coro(*args): + return len(args) + + for i, size in enumerate(range(2, 10)): + args = tuple(range(size)) + rev_args = tuple(reversed(args)) + ret = await coro(*args) + assert ret == size + check_lru(coro, hits=0, misses=2 * i + 1, cache=i + 1, tasks=0) + ret = await coro(*rev_args) + # The reversed args should be a miss + check_lru(coro, hits=0, misses=2 * i + 2, cache=i + 2, tasks=0) + coro.invalidate(*rev_args) + # The reversed args should be invalidated + check_lru(coro, hits=0, misses=2 * i + 2, cache=i + 1, tasks=0) + + for i, size in enumerate(range(2, 10)): + args = tuple(range(size)) + ret = await coro(*args) + assert ret == size + check_lru(coro, hits=i + 1, misses=16, cache=8, tasks=0) diff --git a/tests/external/test_close.py b/tests/external/test_close.py new file mode 100644 index 0000000..3008899 --- /dev/null +++ b/tests/external/test_close.py @@ -0,0 +1,170 @@ +import asyncio + +import pytest +from great_ai.external.async_lru import alru_cache + +pytestmark = pytest.mark.asyncio + + +async def test_cache_close(check_lru, loop): + @alru_cache() + async def coro(val): + await asyncio.sleep(0.2) + + return val + + assert not coro.closed + + inputs = [1, 2, 3, 4, 5] + + coros = [coro(v) for v in inputs] + + gather = asyncio.gather(*coros) + + await asyncio.sleep(0.1) + + check_lru(coro, hits=0, misses=5, cache=5, tasks=5) + + close = coro.close() + + with pytest.raises(RuntimeError): + await coro(1) + + check_lru(coro, hits=0, misses=5, cache=5, tasks=5) + + ret_close = await close + + check_lru(coro, hits=0, misses=0, cache=0, tasks=0) + + ret_gather = await gather + + check_lru(coro, hits=0, misses=0, cache=0, tasks=0) + + assert set(ret_close) == set(ret_gather) == set(inputs) + + with pytest.raises(RuntimeError): + coro.close() + + +async def test_cache_close_cancel_return_exceptions(check_lru, loop): + @alru_cache() + async def coro(val): + await asyncio.sleep(0.2) + + return val + + inputs = [1, 2, 3, 4, 5] + + coros = [coro(v) for v in inputs] + + gather = asyncio.gather(*coros) + + await asyncio.sleep(0.1) + + close = coro.close(cancel=True) + + check_lru(coro, hits=0, misses=5, cache=5, tasks=5) + + ret_close = await close + + check_lru(coro, hits=0, misses=0, cache=0, tasks=0) + + for err in ret_close: + assert isinstance(err, asyncio.CancelledError) + + with pytest.raises(asyncio.CancelledError): + await gather + + +async def test_cache_close_cancel_not_return_exceptions(check_lru, loop): + @alru_cache() + async def coro(val): + await asyncio.sleep(0.2) + + return val + + inputs = [1, 2, 3, 4, 5] + + coros = [coro(v) for v in inputs] + + gather = asyncio.gather(*coros) + + await asyncio.sleep(0.1) + + close = coro.close(cancel=True, return_exceptions=False) + + check_lru(coro, hits=0, misses=5, cache=5, tasks=5) + + with pytest.raises(asyncio.CancelledError): + await close + + with pytest.raises(asyncio.CancelledError): + await gather + + check_lru(coro, hits=0, misses=0, cache=0, tasks=0) + + +async def test_cache_close_return_exceptions(check_lru, loop): + @alru_cache() + async def coro(val): + await asyncio.sleep(0.2) + + raise ZeroDivisionError + + inputs = [1, 2, 3, 4, 5] + + coros = [coro(v) for v in inputs] + + gather = asyncio.gather(*coros) + + await asyncio.sleep(0.1) + + close = coro.close() + + check_lru(coro, hits=0, misses=5, cache=5, tasks=5) + + with pytest.raises(ZeroDivisionError): + await gather + + check_lru(coro, hits=0, misses=5, cache=5, tasks=0) + + ret_close = await close + + check_lru(coro, hits=0, misses=0, cache=0, tasks=0) + + for err in ret_close: + assert isinstance(err, ZeroDivisionError) + + check_lru(coro, hits=0, misses=0, cache=0, tasks=0) + + +async def test_cache_close_not_return_exceptions(check_lru, loop): + @alru_cache() + async def coro(val): + await asyncio.sleep(0.2) + + raise ZeroDivisionError + + inputs = [1, 2, 3, 4, 5] + + coros = [coro(v) for v in inputs] + + gather = asyncio.gather(*coros, return_exceptions=True) + + await asyncio.sleep(0.1) + + close = coro.close(return_exceptions=False) + + check_lru(coro, hits=0, misses=5, cache=5, tasks=5) + + with pytest.raises(ZeroDivisionError): + await close + + check_lru(coro, hits=0, misses=0, cache=0, tasks=0) + + ret_gather = await gather + + for err in ret_gather: + assert isinstance(err, ZeroDivisionError) + + check_lru(coro, hits=0, misses=0, cache=0, tasks=0) diff --git a/tests/external/test_exception.py b/tests/external/test_exception.py new file mode 100644 index 0000000..3d4aa25 --- /dev/null +++ b/tests/external/test_exception.py @@ -0,0 +1,48 @@ +import asyncio + +import pytest +from great_ai.external.async_lru import alru_cache + +pytestmark = pytest.mark.asyncio + + +async def test_alru_cache_exception(check_lru, loop): + @alru_cache(cache_exceptions=True) + async def coro(val): + 1 / 0 + + inputs = [1, 1, 1] + coros = [coro(v) for v in inputs] + + ret = await asyncio.gather(*coros, return_exceptions=True) + + check_lru(coro, hits=2, misses=1, cache=1, tasks=0) + + for item in ret: + assert isinstance(item, ZeroDivisionError) + + with pytest.raises(ZeroDivisionError): + await coro(1) + + check_lru(coro, hits=3, misses=1, cache=1, tasks=0) + + +async def test_alru_not_cache_exception(check_lru, loop): + @alru_cache(cache_exceptions=False) + async def coro(val): + 1 / 0 + + inputs = [1, 1, 1] + coros = [coro(v) for v in inputs] + + ret = await asyncio.gather(*coros, return_exceptions=True) + + check_lru(coro, hits=2, misses=1, cache=1, tasks=0) + + for item in ret: + assert isinstance(item, ZeroDivisionError) + + with pytest.raises(ZeroDivisionError): + await coro(1) + + check_lru(coro, hits=2, misses=2, cache=1, tasks=0) diff --git a/tests/external/test_internals.py b/tests/external/test_internals.py new file mode 100644 index 0000000..142c1fa --- /dev/null +++ b/tests/external/test_internals.py @@ -0,0 +1,374 @@ +import asyncio +from collections import OrderedDict +from functools import _make_key, partial +from unittest import mock + +import pytest +from great_ai.external.async_lru import ( + __cache_touch, + _cache_clear, + _cache_hit, + _cache_info, + _cache_invalidate, + _cache_miss, + _close, + _close_waited, + _done_callback, + _open, + _wait_closed, +) + + +class Wrapped: + pass + + +@pytest.mark.asyncio +async def test_done_callback_cancelled(): + loop = asyncio.get_running_loop() + task = loop.create_future() + fut = loop.create_future() + + task.add_done_callback(partial(_done_callback, fut)) + + task.cancel() + + await asyncio.sleep(0) + + assert fut.cancelled() + + +@pytest.mark.asyncio +async def test_done_callback_exception(): + loop = asyncio.get_running_loop() + task = loop.create_future() + fut = loop.create_future() + + task.add_done_callback(partial(_done_callback, fut)) + + exc = ZeroDivisionError() + + task.set_exception(exc) + + await asyncio.sleep(0) + + with pytest.raises(ZeroDivisionError): + await fut + + with pytest.raises(ZeroDivisionError): + fut.result() + + assert fut.exception() is exc + + +@pytest.mark.asyncio +async def test_done_callback(): + loop = asyncio.get_running_loop() + task = loop.create_future() + fut = loop.create_future() + + task.add_done_callback(partial(_done_callback, fut)) + + task.set_result(1) + + await asyncio.sleep(0) + + assert fut.result() == 1 + + +def test_cache_invalidate_typed(): + wrapped = Wrapped() + wrapped._cache = {} + + args = (1,) + kwargs = {"1": 1} + + from_cache = _cache_invalidate(wrapped, True, *args, **kwargs) + + assert not from_cache + + key = _make_key(args, kwargs, True) + + wrapped._cache[key] = 0 + + from_cache = _cache_invalidate(wrapped, True, *args, **kwargs) + + assert from_cache + + assert len(wrapped._cache) == 0 + + wrapped._cache[key] = 0 + + args = (1.0,) + + from_cache = _cache_invalidate(wrapped, True, *args, **kwargs) + + assert not from_cache + + wrapped._cache[key] = 1 + + +def test_cache_invalidate_not_typed(): + wrapped = Wrapped() + wrapped._cache = {} + + args = (1,) + kwargs = {"1": 1} + + from_cache = _cache_invalidate(wrapped, False, *args, **kwargs) + + assert not from_cache + + key = _make_key(args, kwargs, False) + + wrapped._cache[key] = 0 + + from_cache = _cache_invalidate(wrapped, False, *args, **kwargs) + + assert from_cache + + assert len(wrapped._cache) == 0 + + wrapped._cache[key] = 0 + + args = (1.0,) + + from_cache = _cache_invalidate(wrapped, False, *args, **kwargs) + + assert from_cache + + assert len(wrapped._cache) == 0 + + +def test_cache_clear(): + wrapped = Wrapped() + + attrs = ["hits", "_cache", "tasks"] + for attr in attrs: + assert not hasattr(wrapped, attr) + + _cache_clear(wrapped) + + for attr in attrs: + assert hasattr(wrapped, attr) + + assert wrapped.hits == wrapped.misses == 0 + assert isinstance(wrapped._cache, dict) + assert len(wrapped._cache) == 0 + assert isinstance(wrapped.tasks, set) + assert len(wrapped.tasks) == 0 + + _cache = wrapped._cache + tasks = wrapped.tasks + + _cache_clear(wrapped) + + assert wrapped._cache is not _cache + assert wrapped.tasks is not tasks + + +def test_open(): + wrapped = Wrapped() + wrapped.hits = wrapped.misses = 1 + wrapped._cache = {} + wrapped.tasks = set() + wrapped.closed = True + + with pytest.raises(RuntimeError): + _open(wrapped) + + wrapped.hits = wrapped.misses = 0 + + _open(wrapped) + + assert not wrapped.closed + + with pytest.raises(RuntimeError): + _open(wrapped) + + +def test_close(loop): + wrapped = Wrapped() + wrapped.closed = False + wrapped.tasks = set() + + awaitable = _close(wrapped, cancel=False, return_exceptions=True) + loop.run_until_complete(awaitable) + + assert wrapped.closed + + with pytest.raises(RuntimeError): + _close(wrapped, cancel=False, return_exceptions=True) + + fut = loop.create_future() + wrapped.closed = False + wrapped.tasks = {fut} + + awaitable = _close(wrapped, cancel=True, return_exceptions=True) + loop.run_until_complete(awaitable) + + assert fut.cancelled() + + fut = loop.create_future() + fut.set_result(None) + wrapped.closed = False + wrapped.tasks = {fut} + + awaitable = _close(wrapped, cancel=True, return_exceptions=True) + loop.run_until_complete(awaitable) + + assert not fut.cancelled() + + fut = loop.create_future() + fut.set_exception(ZeroDivisionError) + wrapped.closed = False + wrapped.tasks = {fut} + + awaitable = _close(wrapped, cancel=True, return_exceptions=True) + loop.run_until_complete(awaitable) + + assert not fut.cancelled() + + +@pytest.mark.asyncio +async def test_wait_closed(): + loop = asyncio.get_running_loop() + wrapped = Wrapped() + wrapped.tasks = set() + + with mock.patch("great_ai.external.async_lru._close_waited") as mocked: + ret = await _wait_closed( + wrapped, + return_exceptions=True, + ) + assert ret == [] + mocked.assert_called_once() + + asyncio.set_event_loop(loop) + with mock.patch("great_ai.external.async_lru._close_waited") as mocked: + ret = await _wait_closed( + wrapped, + return_exceptions=True, + ) + assert ret == [] + mocked.assert_called_once() + asyncio.set_event_loop(None) + + fut = loop.create_future() + fut.set_result(None) + wrapped.tasks = {fut} + with mock.patch("great_ai.external.async_lru._close_waited") as mocked: + ret = await _wait_closed( + wrapped, + return_exceptions=True, + ) + assert ret == [None] + mocked.assert_called_once() + + exc = ZeroDivisionError() + fut = loop.create_future() + fut.set_exception(exc) + wrapped.tasks = {fut} + with mock.patch("great_ai.external.async_lru._close_waited") as mocked: + ret = await _wait_closed( + wrapped, + return_exceptions=True, + ) + assert ret == [exc] + mocked.assert_called_once() + + fut = loop.create_future() + fut.set_exception(ZeroDivisionError) + wrapped.tasks = {fut} + with mock.patch("great_ai.external.async_lru._close_waited") as mocked: + with pytest.raises(ZeroDivisionError): + await _wait_closed( + wrapped, + return_exceptions=False, + ) + # the awaited result raised before _wait_closed could flush its done + # callback, so yield once to let the scheduled _close_waited run + await asyncio.sleep(0) + mocked.assert_called_once() + + +def test_close_waited(): + wrapped = Wrapped() + # _close_waited calls wrapped.cache_clear(); mock that directly (patching the + # module-level _cache_clear would not affect the already-bound partial). + wrapped.cache_clear = mock.Mock() + + _close_waited(wrapped, None) + + wrapped.cache_clear.assert_called_once() + + +def test_cache_info(): + wrapped = Wrapped() + wrapped._cache = {} + wrapped.hits = wrapped.misses = 0 + + assert (0, 0, 3, 0) == _cache_info(wrapped, 3) + + wrapped._cache[1] = 1 + + assert (0, 0, 1, 1) == _cache_info(wrapped, 1) + + wrapped.hits = 2 + wrapped.misses = 3 + wrapped._cache[2] = 2 + + assert (2, 3, 5, 2) == _cache_info(wrapped, 5) + + +def test__cache_touch(): + wrapped = Wrapped() + + wrapped._cache = OrderedDict() + wrapped._cache[1] = 1 + wrapped._cache[2] = 2 + + __cache_touch(wrapped, 1) + assert list(wrapped._cache) == [2, 1] + + __cache_touch(wrapped, 2) + assert list(wrapped._cache) == [1, 2] + + # test KeyError + __cache_touch(wrapped, 100) + + +def test_cache_hit(): + wrapped = Wrapped() + wrapped.hits = 1 + wrapped._cache = OrderedDict() + wrapped._cache[1] = 1 + + with mock.patch("great_ai.external.async_lru.__cache_touch") as mocked: + _cache_hit(wrapped, 1) + + mocked.assert_called_once() + + assert wrapped.hits == 2 + + _cache_hit(wrapped, 1) + + assert wrapped.hits == 3 + + +def test_cache_miss(): + wrapped = Wrapped() + wrapped.misses = 1 + wrapped._cache = OrderedDict() + wrapped._cache[1] = 1 + + with mock.patch("great_ai.external.async_lru.__cache_touch") as mocked: + _cache_miss(wrapped, 1) + + mocked.assert_called_once() + + assert wrapped.misses == 2 + + _cache_miss(wrapped, 1) + + assert wrapped.misses == 3 diff --git a/tests/external/test_open.py b/tests/external/test_open.py new file mode 100644 index 0000000..b749df4 --- /dev/null +++ b/tests/external/test_open.py @@ -0,0 +1,39 @@ +import pytest +from great_ai.external.async_lru import alru_cache + +pytestmark = pytest.mark.asyncio + + +async def test_alru_cache_open(check_lru, loop): + @alru_cache() + async def coro(val): + return val + + await coro(1) + + check_lru(coro, hits=0, misses=1, cache=1, tasks=0) + + with pytest.raises(RuntimeError): + coro.open() + + close = coro.close() + + assert coro.closed + + with pytest.raises(RuntimeError): + await coro() + + with pytest.raises(RuntimeError): + coro.open() + + await close + + check_lru(coro, hits=0, misses=0, cache=0, tasks=0) + + coro.open() + + ret = await coro(1) + + assert ret == 1 + + check_lru(coro, hits=0, misses=1, cache=1, tasks=0) diff --git a/tests/external/test_partialmethod.py b/tests/external/test_partialmethod.py new file mode 100644 index 0000000..dfa888f --- /dev/null +++ b/tests/external/test_partialmethod.py @@ -0,0 +1,50 @@ +import asyncio +from functools import partial, partialmethod + +import pytest +from great_ai.external.async_lru import alru_cache + +pytestmark = pytest.mark.asyncio + + +async def test_partialmethod_basic(check_lru, loop): + class Obj: + async def _coro(self, val): + return val + + coro = alru_cache(partialmethod(_coro, 2)) + + obj = Obj() + + coros = [obj.coro() for _ in range(5)] + + check_lru(obj.coro, hits=0, misses=0, cache=0, tasks=0) + + ret = await asyncio.gather(*coros) + + check_lru(obj.coro, hits=4, misses=1, cache=1, tasks=0) + + assert ret == [2, 2, 2, 2, 2] + + +async def test_partialmethod_partial(check_lru, loop): + class Obj: + def __init__(self): + self.coro = alru_cache(partial(self._coro, 2)) + + async def __coro(self, val1, val2): + return val1 + val2 + + _coro = partialmethod(__coro, 1) + + obj = Obj() + + coros = [obj.coro() for _ in range(5)] + + check_lru(obj.coro, hits=0, misses=0, cache=0, tasks=0) + + ret = await asyncio.gather(*coros) + + check_lru(obj.coro, hits=4, misses=1, cache=1, tasks=0) + + assert ret == [3, 3, 3, 3, 3] diff --git a/tests/external/test_size.py b/tests/external/test_size.py new file mode 100644 index 0000000..c683c8e --- /dev/null +++ b/tests/external/test_size.py @@ -0,0 +1,58 @@ +import asyncio + +import pytest +from great_ai.external.async_lru import _make_key, alru_cache + +pytestmark = pytest.mark.asyncio + + +async def test_alru_cache_removing_lru_keys(check_lru, loop): + @alru_cache(maxsize=3) + async def coro(val): + return val + + key5 = _make_key((5,), {}, False) + key4 = _make_key((4,), {}, False) + key3 = _make_key((3,), {}, False) + key2 = _make_key((2,), {}, False) + key1 = _make_key((1,), {}, False) + + for i, v in enumerate([3, 4, 5]): + await coro(v) + check_lru(coro, hits=0, misses=i + 1, cache=i + 1, tasks=0, maxsize=3) + + check_lru(coro, hits=0, misses=3, cache=3, tasks=0, maxsize=3) + assert list(coro._cache) == [key3, key4, key5] + + for v in [3, 2, 1]: + await coro(v) + check_lru(coro, hits=1, misses=5, cache=3, tasks=0, maxsize=3) + assert list(coro._cache) == [key3, key2, key1] + + +async def test_alru_cache_none_max_size(check_lru, loop): + @alru_cache(maxsize=None) + async def coro(val): + return val + + inputs = [1, 2, 3, 4] * 2 + coros = [coro(v) for v in inputs] + + ret = await asyncio.gather(*coros) + + check_lru(coro, hits=4, misses=4, cache=4, tasks=0, maxsize=None) + assert ret == inputs + + +async def test_alru_cache_zero_max_size(check_lru, loop): + @alru_cache(maxsize=0) + async def coro(val): + return val + + inputs = [1, 2, 3, 4] * 2 + coros = [coro(v) for v in inputs] + + ret = await asyncio.gather(*coros) + + check_lru(coro, hits=0, misses=8, cache=0, tasks=0, maxsize=0) + assert ret == inputs diff --git a/tests/external/test_utils.py b/tests/external/test_utils.py new file mode 100644 index 0000000..aa52d5d --- /dev/null +++ b/tests/external/test_utils.py @@ -0,0 +1,19 @@ +from functools import partial + +from great_ai.external.async_lru import unpartial + + +def test_unpartial(): + def foo(): + pass + + assert unpartial(foo) is foo + + bar = partial(foo) + + assert unpartial(bar) is foo + + for _ in range(10): + bar = partial(bar) + + assert unpartial(bar) is foo diff --git a/docs/example_secrets.ini b/tests/large_file/data/example_secrets.ini similarity index 100% rename from docs/example_secrets.ini rename to tests/large_file/data/example_secrets.ini diff --git a/tests/large_file/test_human_readable_to_byte.py b/tests/large_file/test_human_readable_to_byte.py index 271722e..b98eeb7 100644 --- a/tests/large_file/test_human_readable_to_byte.py +++ b/tests/large_file/test_human_readable_to_byte.py @@ -1,26 +1,26 @@ -import unittest - -from src.great_ai.large_file.helper import human_readable_to_byte +from great_ai.large_file.helper import human_readable_to_byte -class TestHumanReadableToByte(unittest.TestCase): - def test_simple_cases(self) -> None: - assert human_readable_to_byte("1KB") == 1024 - assert human_readable_to_byte("2KB") == 2048 +def test_simple_cases() -> None: + assert human_readable_to_byte("1KB") == 1024 + assert human_readable_to_byte("2KB") == 2048 - def test_fractions(self) -> None: - assert human_readable_to_byte("0.5KB") == 512 - assert human_readable_to_byte("20.5KB") == 1024 * 20 + 512 - def test_formating(self) -> None: - assert human_readable_to_byte(" 1MB") == 1024 * 1024 - assert human_readable_to_byte(" 2 MB") == 1024 * 1024 * 2 - assert human_readable_to_byte(" 4 MB ") == 1024 * 1024 * 4 - assert human_readable_to_byte("8MB ") == 1024 * 1024 * 8 - assert human_readable_to_byte(" 1.5 MB ") == 1024 * 1024 * 1.5 +def test_fractions() -> None: + assert human_readable_to_byte("0.5KB") == 512 + assert human_readable_to_byte("20.5KB") == 1024 * 20 + 512 - def test_casing(self) -> None: - assert human_readable_to_byte("0.5GB") == 0.5 * 1024 * 1024 * 1024 - assert human_readable_to_byte("0.5gB") == 0.5 * 1024 * 1024 * 1024 - assert human_readable_to_byte("0.5Gb") == 0.5 * 1024 * 1024 * 1024 - assert human_readable_to_byte("0.5gb") == 0.5 * 1024 * 1024 * 1024 + +def test_formatting() -> None: + assert human_readable_to_byte(" 1MB") == 1024 * 1024 + assert human_readable_to_byte(" 2 MB") == 1024 * 1024 * 2 + assert human_readable_to_byte(" 4 MB ") == 1024 * 1024 * 4 + assert human_readable_to_byte("8MB ") == 1024 * 1024 * 8 + assert human_readable_to_byte(" 1.5 MB ") == 1024 * 1024 * 1.5 + + +def test_casing() -> None: + assert human_readable_to_byte("0.5GB") == 0.5 * 1024 * 1024 * 1024 + assert human_readable_to_byte("0.5gB") == 0.5 * 1024 * 1024 * 1024 + assert human_readable_to_byte("0.5Gb") == 0.5 * 1024 * 1024 * 1024 + assert human_readable_to_byte("0.5gb") == 0.5 * 1024 * 1024 * 1024 diff --git a/tests/large_file/test_large_file.py b/tests/large_file/test_large_file.py index 929529d..9afc615 100644 --- a/tests/large_file/test_large_file.py +++ b/tests/large_file/test_large_file.py @@ -1,14 +1,14 @@ -import unittest from pathlib import Path from typing import Any from unittest.mock import Mock, patch import boto3 +import pytest PATH = Path(__file__).parent.resolve() -from src.great_ai import LargeFileS3 +from great_ai.large_file import LargeFileS3 credentials = { "aws_region_name": "your_region_like_eu-west-2", @@ -19,104 +19,126 @@ credentials = { } -class TestLargeFileS3(unittest.TestCase): - def test_uninitialized(self) -> None: - self.assertRaises(ValueError, LargeFileS3, "test-file") +def test_uninitialized() -> None: + with pytest.raises(ValueError): + LargeFileS3("test-file") - def test_bad_file_modes(self) -> None: - self.assertRaises(ValueError, LargeFileS3, "test-file", "w", version=3) - self.assertRaises(ValueError, LargeFileS3, "test-file", "wb", version=3) - self.assertRaises(ValueError, LargeFileS3, "test-file", "w+r") - self.assertRaises(ValueError, LargeFileS3, "test-file", "test") - @patch.object(boto3, "client") - def test_initialized_with_dict(self, client: Any) -> None: - s3 = Mock() - s3.list_objects_v2 = Mock( - return_value={ - "Contents": [ - { - "Key": "test-file/0", - "Size": 30, - }, - { - "Key": "test-file/1", - "Size": 300, - }, - { - "Key": "test-file/2", - "Size": 187, - }, - ] - } - ) - boto3.client = Mock(return_value=s3) +def test_bad_file_name() -> None: + with pytest.raises(ValueError): + LargeFileS3("../no-no", cache_only_mode=True) - LargeFileS3.configure_credentials( - aws_region_name=credentials["aws_region_name"], - aws_access_key_id=credentials["aws_access_key_id"], - aws_secret_access_key=credentials["aws_secret_access_key"], - large_files_bucket_name=credentials["large_files_bucket_name"], - aws_endpoint_url=credentials["aws_endpoint_url"], - ) - lf = LargeFileS3("test-file") + with pytest.raises(ValueError): + LargeFileS3("is this wrong?", cache_only_mode=True) - boto3.client.assert_called_once_with( - "s3", - aws_access_key_id=credentials["aws_access_key_id"], - aws_secret_access_key=credentials["aws_secret_access_key"], - region_name=credentials["aws_region_name"], - endpoint_url=credentials["aws_endpoint_url"], - ) + with pytest.raises(FileNotFoundError): + LargeFileS3("!378378_fer-ef", cache_only_mode=True) # this should work - s3.list_objects_v2.assert_called_once_with( - Bucket=credentials["large_files_bucket_name"], Prefix="test-file" - ) + with pytest.raises(FileNotFoundError): + LargeFileS3("3", cache_only_mode=True) # this should work - assert lf._version == 2 - assert lf._local_name == "test-file-2" - @patch.object(boto3, "client") - def test_initialized_with_file(self, client: Any) -> None: - s3 = Mock() - s3.list_objects_v2 = Mock( - return_value={ - "Contents": [ - { - "Key": "test-file/0", - "Size": 30, - }, - { - "Key": "test-file/1", - "Size": 300, - }, - { - "Key": "test-file/2", - "Size": 187, - }, - ] - } - ) +def test_bad_file_modes() -> None: + with pytest.raises(ValueError): + LargeFileS3("test-file", "w", version=3) - boto3.client = Mock(return_value=s3) + with pytest.raises(ValueError): + LargeFileS3("test-file", "wb", version=3) - LargeFileS3.configure_credentials_from_file( - PATH / "../../docs/example_secrets.ini" - ) - lf = LargeFileS3("test-file") + with pytest.raises(ValueError): + LargeFileS3("test-file", "w+r") - boto3.client.assert_called_once_with( - "s3", - aws_access_key_id=credentials["aws_access_key_id"], - aws_secret_access_key=credentials["aws_secret_access_key"], - region_name=credentials["aws_region_name"], - endpoint_url=credentials["aws_endpoint_url"], - ) + with pytest.raises(ValueError): + LargeFileS3("test-file", "test") - assert s3.list_objects_v2.called - s3.list_objects_v2.assert_called_once_with( - Bucket=credentials["large_files_bucket_name"], Prefix="test-file" - ) - assert lf._version == 2 - assert lf._local_name == "test-file-2" +@patch.object(boto3, "client") +def test_initialized_with_dict(client: Any) -> None: + s3 = Mock() + s3.list_objects_v2 = Mock( + return_value={ + "Contents": [ + { + "Key": "test-file/0", + "Size": 30, + }, + { + "Key": "test-file/1", + "Size": 300, + }, + { + "Key": "test-file/2", + "Size": 187, + }, + ] + } + ) + boto3.client = Mock(return_value=s3) + + LargeFileS3.configure_credentials( + aws_region_name=credentials["aws_region_name"], + aws_access_key_id=credentials["aws_access_key_id"], + aws_secret_access_key=credentials["aws_secret_access_key"], + large_files_bucket_name=credentials["large_files_bucket_name"], + aws_endpoint_url=credentials["aws_endpoint_url"], + ) + lf = LargeFileS3("test-file") + + boto3.client.assert_called_once_with( + "s3", + aws_access_key_id=credentials["aws_access_key_id"], + aws_secret_access_key=credentials["aws_secret_access_key"], + region_name=credentials["aws_region_name"], + endpoint_url=credentials["aws_endpoint_url"], + ) + + s3.list_objects_v2.assert_called_once_with( + Bucket=credentials["large_files_bucket_name"], Prefix="test-file" + ) + + assert lf._version == 2 + assert lf._local_name == "test-file-2" + + +@patch.object(boto3, "client") +def test_initialized_with_file(client: Any) -> None: + s3 = Mock() + s3.list_objects_v2 = Mock( + return_value={ + "Contents": [ + { + "Key": "test-file/0", + "Size": 30, + }, + { + "Key": "test-file/1", + "Size": 300, + }, + { + "Key": "test-file/2", + "Size": 187, + }, + ] + } + ) + + boto3.client = Mock(return_value=s3) + + LargeFileS3.configure_credentials_from_file(PATH / "data/example_secrets.ini") + lf = LargeFileS3("test-file") + + boto3.client.assert_called_once_with( + "s3", + aws_access_key_id=credentials["aws_access_key_id"], + aws_secret_access_key=credentials["aws_secret_access_key"], + region_name=credentials["aws_region_name"], + endpoint_url=credentials["aws_endpoint_url"], + ) + + assert s3.list_objects_v2.called + s3.list_objects_v2.assert_called_once_with( + Bucket=credentials["large_files_bucket_name"], Prefix="test-file" + ) + + assert lf._version == 2 + assert lf._local_name == "test-file-2" diff --git a/tests/test_async_starters.py b/tests/test_async_starters.py new file mode 100644 index 0000000..d25a3d0 --- /dev/null +++ b/tests/test_async_starters.py @@ -0,0 +1,51 @@ +from asyncio import sleep + +import pytest +from great_ai import GreatAI, WrongDecoratorOrderError, parameter + + +@pytest.mark.asyncio +async def test_create_trivial_cases() -> None: + @GreatAI.create + async def hello_world_1(name: str) -> str: + await sleep(0.5) + return f"Hello {name}!" + + assert (await hello_world_1("andras")).output == "Hello andras!" + + @GreatAI.create + async def hello_world_2(name: str) -> str: + await sleep(0.5) + return f"Hello {name}!" + + assert (await hello_world_2("andras")).output == "Hello andras!" + + +@pytest.mark.asyncio +async def test_with_parameter() -> None: + @GreatAI.create + @parameter("name", validate=lambda v: len(v) > 5) + async def hello_world(name: str) -> str: + await sleep(0.5) + return f"Hello {name}!" + + +@pytest.mark.asyncio +async def test_with_parameters() -> None: + @GreatAI.create + @parameter("name", validate=lambda v: len(v) > 5) + @parameter("unused", disable_logging=True) + async def hello_world(name: str, unused) -> str: # type: ignore + await sleep(0.5) + return f"Hello {name}!" + + assert (await hello_world("andras", "fr")).output == "Hello andras!" + + +def test_wrong_order() -> None: + with pytest.raises(WrongDecoratorOrderError): + + @parameter("name", validate=lambda v: len(v) > 5) + @GreatAI.create + async def hello_world(name: str) -> str: + return f"Hello {name}!" diff --git a/tests/test_basic_starters.py b/tests/test_basic_starters.py new file mode 100644 index 0000000..1303b22 --- /dev/null +++ b/tests/test_basic_starters.py @@ -0,0 +1,60 @@ +from functools import lru_cache + +import pytest +from great_ai import ( + ArgumentValidationError, + GreatAI, + WrongDecoratorOrderError, + parameter, +) + + +def test_create_trivial_cases() -> None: + @GreatAI.create + def hello_world_1(name: str) -> str: + return f"Hello {name}!" + + assert hello_world_1("andras").output == "Hello andras!" + + @GreatAI.create + def hello_world_2(name): # type: ignore + return f"Hello {name}!" + + assert hello_world_2("andras").output == "Hello andras!" + + +def test_create_with_other_decorator() -> None: + @GreatAI.create + @lru_cache() + def hello_world_1(name: str) -> str: + return f"Hello {name}!" + + assert hello_world_1("andras").output == "Hello andras!" + + @lru_cache() + @GreatAI.create + def hello_world_2(name: str) -> str: + return f"Hello {name}!" + + assert hello_world_2("andras").output == "Hello andras!" + + +def test_with_parameter() -> None: + @GreatAI.create + @parameter("name", validate=lambda v: len(v) > 5) + def hello_world(name: str) -> str: + return f"Hello {name}!" + + assert hello_world("andras").output == "Hello andras!" + + with pytest.raises(ArgumentValidationError): + hello_world("short") + + +def test_wrong_order() -> None: + with pytest.raises(WrongDecoratorOrderError): + + @parameter("name", validate=lambda v: len(v) > 5) + @GreatAI.create + def hello_world(name: str) -> str: + return f"Hello {name}!" diff --git a/tests/test_great_ai.py b/tests/test_great_ai.py new file mode 100644 index 0000000..60ee511 --- /dev/null +++ b/tests/test_great_ai.py @@ -0,0 +1,49 @@ +from asyncio import sleep + +import pytest +from great_ai import GreatAI + + +def test_process_batch() -> None: + @GreatAI.create + def f(x: int) -> int: + return x + 2 + + assert [v.output for v in f.process_batch([3, 9, 34])] == [5, 11, 36] + + +def test_process_batch_unpacked() -> None: + @GreatAI.create + def f(a: int, b: str) -> str: + return b * a + + assert [ + v.output + for v in f.process_batch( + [(2, "aa"), (1, "fa"), (3, "b")], unpack_arguments=True + ) + ] == ["aaaa", "fa", "bbb"] + + +@pytest.mark.asyncio +async def test_process_batch_async() -> None: + @GreatAI.create + async def f(x: int) -> int: + await sleep(0.2) + return x + 2 + + assert [v.output for v in f.process_batch([3, 9, 34])] == [5, 11, 36] + + +@pytest.mark.asyncio +async def test_process_batch_async_unpacked() -> None: + @GreatAI.create + async def f(a: int, b: str) -> str: + return b * a + + assert [ + v.output + for v in f.process_batch( + [(2, "aa"), (1, "fa"), (3, "b")], unpack_arguments=True + ) + ] == ["aaaa", "fa", "bbb"] diff --git a/tests/utilities/data/__init__.py b/tests/utilities/data/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/utilities/data/env-bad.conf b/tests/utilities/data/env-bad.conf new file mode 100644 index 0000000..60e2362 --- /dev/null +++ b/tests/utilities/data/env-bad.conf @@ -0,0 +1,2 @@ + +fourth_key = ENV:SOMETHING diff --git a/tests/utilities/data/env.conf b/tests/utilities/data/env.conf index ca78f66..b644a73 100644 --- a/tests/utilities/data/env.conf +++ b/tests/utilities/data/env.conf @@ -3,3 +3,6 @@ first_key=test second_key="ENV:alma" third_key = ENV:alma + +fourth_key="this is a default value" # will fall back to this if ENV is not defined +fourth_key = ENV:SOMETHING diff --git a/tests/utilities/data/good.conf b/tests/utilities/data/good.conf index 55336ab..3605c91 100644 --- a/tests/utilities/data/good.conf +++ b/tests/utilities/data/good.conf @@ -4,6 +4,8 @@ first_key= András second_key = test 2 # comment is ignored third_key= "test= 2==" +my_hashtag= "#great_ai" # ferf + fourth_key = " this# is diff --git a/tests/utilities/data/simple.conf b/tests/utilities/data/simple.conf new file mode 100644 index 0000000..924eef7 --- /dev/null +++ b/tests/utilities/data/simple.conf @@ -0,0 +1,3 @@ +# comment +zeroth_key="test" +first_key= András \ No newline at end of file diff --git a/tests/utilities/test_chunk.py b/tests/utilities/test_chunk.py new file mode 100644 index 0000000..7976fd0 --- /dev/null +++ b/tests/utilities/test_chunk.py @@ -0,0 +1,30 @@ +import pytest +from great_ai.utilities import chunk + + +def test_simple() -> None: + i = [1, 2, 3, 4] + + assert list(chunk(i, 1)) == [[1], [2], [3], [4]] + assert list(chunk(i, 2)) == [[1, 2], [3, 4]] + assert list(chunk(i, 3)) == [[1, 2, 3], [4]] + assert list(chunk(i, 4)) == [[1, 2, 3, 4]] + assert list(chunk(i, 5)) == [[1, 2, 3, 4]] + assert list(chunk(i, 125)) == [[1, 2, 3, 4]] + + +def test_bad_argument() -> None: + with pytest.raises(AssertionError): + list(chunk([], -10)) + + with pytest.raises(AssertionError): + list(chunk([], 0)) + + +def test_generator() -> None: + def my_generator(): # type: ignore + for i in range(1, 11): + yield i + + assert list(chunk(range(1, 11), 3)) == [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10]] + assert list(chunk(my_generator(), 3)) == [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10]] diff --git a/tests/utilities/test_clean.py b/tests/utilities/test_clean.py index 500cada..4403997 100644 --- a/tests/utilities/test_clean.py +++ b/tests/utilities/test_clean.py @@ -1,110 +1,112 @@ -import unittest - -from src.great_ai.utilities import clean +from great_ai.utilities import clean -class TestClean(unittest.TestCase): - def test_xml_handling(self) -> None: - xml = 'Hi, my name
is András! <3 <> < ><> <> <|' - clean_xml = "Hi, my name is András! <3 <> <|" - clean_xml_ascii = "Hi, my name is Andras! <3 <> <|" +def test_xml_handling() -> None: + xml = 'Hi, my name
is András! <3 <> < ><> <> <|' + clean_xml = "Hi, my name is András! <3 <> <|" + clean_xml_ascii = "Hi, my name is Andras! <3 <> <|" - assert clean(xml) == clean_xml - assert clean(xml, ignore_xml=True, ignore_latex=True) == xml - assert clean(xml, convert_to_ascii=True) == clean_xml_ascii - - def test_simple_latex_handling(self) -> None: - latex = 'Bj\\"{o}rn is \\textit{happy} 🙂' - clean_latex = "Björn is happy 🙂" - clean_latex_ascii = "Bjorn is happy" - - assert clean(latex) == clean_latex - assert clean(latex, ignore_latex=True) == latex - assert clean(latex, convert_to_ascii=True) == clean_latex_ascii - - def test_cursed(self) -> None: - cursed = """ - t̴̨̢̝̻͚͓͉̀̄̃́͜o̸͉̰̼͖͖̅̀̓̿̇̚͝ ̶̢͕̄͊̾͑̂̀̉͑ṱ̸̨̛͈̣̠̤͍̰̂̅͋̀́h̸̹̐͗̅̉͐͂͝e̶̜̳̞̍͘ ̴̟̗̻̤̤̮̒̂̋̓́͐͘͜m̵̺̫̥̙̣̥͐̌͜o̴̖͙̙̎̒͂o̷̬̤͑̆̂̉̊̂n̸̥͒̊ - """ - cleaned = "to the moon" - - assert clean(cursed) == cursed.strip() - assert clean(cursed, convert_to_ascii=True) == cleaned - - def test_whitespace(self) -> None: - text = """ - - word1 - - word2 \n\n\n\t - wo\t\f rd3 + assert clean(xml) == clean_xml + assert clean(xml, ignore_xml=True, ignore_latex=True) == xml + assert clean(xml, convert_to_ascii=True) == clean_xml_ascii - """ # noqa: W293 - cleaned = "word1 word2 wo rd3" +def test_simple_latex_handling() -> None: + latex = 'Bj\\"{o}rn is \\textit{happy} 🙂' + clean_latex = "Björn is happy 🙂" + clean_latex_ascii = "Bjorn is happy" - assert clean(text, convert_to_ascii=True) == cleaned - assert clean(text, ignore_xml=True, ignore_latex=True) == cleaned - assert clean(text) == cleaned + assert clean(latex) == clean_latex + assert clean(latex, ignore_latex=True) == latex + assert clean(latex, convert_to_ascii=True) == clean_latex_ascii - def test_hyphens(self) -> None: - text = """ - break - word - break- word - break -word - break -word - break-\tword - """ - cleaned = "break - word break-word break-word break-word break-word" - assert clean(text) == cleaned +def test_cursed() -> None: + cursed = """ + t̴̨̢̝̻͚͓͉̀̄̃́͜o̸͉̰̼͖͖̅̀̓̿̇̚͝ ̶̢͕̄͊̾͑̂̀̉͑ṱ̸̨̛͈̣̠̤͍̰̂̅͋̀́h̸̹̐͗̅̉͐͂͝e̶̜̳̞̍͘ ̴̟̗̻̤̤̮̒̂̋̓́͐͘͜m̵̺̫̥̙̣̥͐̌͜o̴̖͙̙̎̒͂o̷̬̤͑̆̂̉̊̂n̸̥͒̊ + """ + cleaned = "to the moon" - def test_T_I_T_L_E_case(self) -> None: - text = "an a r t i c l e is to F I N D the purpose of a tree" + assert clean(cursed) == cursed.strip() + assert clean(cursed, convert_to_ascii=True) == cleaned - cleaned = "an article is to FIND the purpose of a tree" - assert clean(text) == cleaned +def test_whitespace() -> None: + text = """ + + word1 - def test_bracket_removal(self) -> None: - text = "something [0], and [frefe, ferf]" - cleaned = "something, and" + word2 \n\n\n\t + wo\t\f rd3 - assert clean(text, remove_brackets=True) == cleaned - self.assertEqual( - clean(text, ignore_xml=True, ignore_latex=True, remove_brackets=True), - cleaned, - ) - self.assertEqual( - clean(text, convert_to_ascii=True, remove_brackets=True), cleaned - ) - assert clean(text) == text - def test_latex_math_handling(self) -> None: - latex = "An increase of 3% was achieved with $q_1 = \\frac{3}{5}$." - bad_latex = "An increase of 3% was achieved with $q_1 = \\frac{3}/5$." - clean_latex = "An increase of 3% was achieved with q_1 = 3/5." - clean_bad_latex = "An increase of 3% was achieved with q_1 = 3//5." + """ # noqa: W293 + cleaned = "word1 word2 wo rd3" - assert clean(latex) == clean_latex - assert clean(bad_latex) == clean_bad_latex - assert clean(latex, ignore_latex=True) == latex - assert clean(bad_latex, ignore_latex=True) == bad_latex + assert clean(text, convert_to_ascii=True) == cleaned + assert clean(text, ignore_xml=True, ignore_latex=True) == cleaned + assert clean(text) == cleaned - def test_everything(self) -> None: - text = """ - Hi % 3 >2

my paper

there! cost- effective cost - effective cost -effective \\frac{1/2} hi \\frac{1}{2} \\textit{italic} \\`acc\\^ented text 北亰 fi æ IJ ij ff András öô 2132 rgrv \n\\   fd [32] [Bei et al., 2003]\n 🤡 🙄 😶‍🌫️ 🇲🇲 - """ - cleaned = "Hi% 3 >2 my paper there! cost-effective cost - effective cost-effective 1/2/hi 1/2 italic accented text Bei Jing fi ae IJ ij ff Andras oo 2132 rgrv fd" - self.assertEqual( - clean(text, convert_to_ascii=True, remove_brackets=True), cleaned - ) +def test_hyphens() -> None: + text = """ + break - word + break- word + break -word + break -word + break-\tword + """ + cleaned = "break - word break-word break-word break-word break-word" - def test_empty(self) -> None: - assert clean("", convert_to_ascii=True) == "" + assert clean(text) == cleaned - def test_punctuation_fixing(self) -> None: - text = " Dear reader ( or listener ) , welcome ! " - fixed = "Dear reader (or listener), welcome!" - assert clean(text) == fixed + +def test_T_I_T_L_E_case() -> None: + text = "an a r t i c l e is to F I N D the purpose of a tree" + + cleaned = "an article is to FIND the purpose of a tree" + + assert clean(text) == cleaned + + +def test_bracket_removal() -> None: + text = "something [0], and [frefe, ferf]" + cleaned = "something, and" + + assert clean(text, remove_brackets=True) == cleaned + assert ( + clean(text, ignore_xml=True, ignore_latex=True, remove_brackets=True) == cleaned + ) + assert clean(text, convert_to_ascii=True, remove_brackets=True) == cleaned + assert clean(text) == text + + +def test_latex_math_handling() -> None: + latex = "An increase of 3% was achieved with $q_1 = \\frac{3}{5}$." + bad_latex = "An increase of 3% was achieved with $q_1 = \\frac{3}/5$." + clean_latex = "An increase of 3% was achieved with q_1 = 3/5." + clean_bad_latex = "An increase of 3% was achieved with q_1 = 3//5." + + assert clean(latex) == clean_latex + assert clean(bad_latex) == clean_bad_latex + assert clean(latex, ignore_latex=True) == latex + assert clean(bad_latex, ignore_latex=True) == bad_latex + + +def test_everything() -> None: + text = """ + Hi % 3 >2

my paper

there! cost- effective cost - effective cost -effective \\frac{1/2} hi \\frac{1}{2} \\textit{italic} \\`acc\\^ented text 北亰 fi æ IJ ij ff András öô 2132 rgrv \n\\   fd [32] [Bei et al., 2003]\n 🤡 🙄 😶‍🌫️ 🇲🇲 + """ + cleaned = "Hi% 3 >2 my paper there! cost-effective cost - effective cost-effective 1/2/hi 1/2 italic accented text Bei Jing fi ae IJ ij ff Andras oo 2132 rgrv fd" + + assert clean(text, convert_to_ascii=True, remove_brackets=True) == cleaned + + +def test_empty() -> None: + assert clean("", convert_to_ascii=True) == "" + + +def test_punctuation_fixing() -> None: + text = " Dear reader ( or listener ) , welcome ! " + fixed = "Dear reader (or listener), welcome!" + assert clean(text) == fixed diff --git a/tests/utilities/test_config_file.py b/tests/utilities/test_config_file.py index c7c6b29..df6a48b 100644 --- a/tests/utilities/test_config_file.py +++ b/tests/utilities/test_config_file.py @@ -1,85 +1,99 @@ -import unittest +import os from pathlib import Path import pytest - -from src.great_ai.utilities import ConfigFile +from great_ai.utilities import ConfigFile DATA_PATH = Path(__file__).parent.resolve() / "data" -class TestConfigFile(unittest.TestCase): - def test_simple(self) -> None: - c = ConfigFile(DATA_PATH / "good.conf") - assert c.zeroth_key == "test" - assert c.first_key == "András" - assert c.second_key == "test 2" - assert c.third_key == "test= 2==" - assert ( - c.fourth_key - == """ +def test_simple() -> None: + c = ConfigFile(DATA_PATH / "good.conf") + assert c.zeroth_key == "test" + assert c.my_hashtag == "#great_ai" + assert c.first_key == "András" + assert c.second_key == "test 2" + assert c.third_key == "test= 2==" + assert ( + c.fourth_key + == """ this# is multiline """ - ) - assert c.whitespace == "hardly matters" - with pytest.raises(KeyError): - c.this + ) + assert c.whitespace == "hardly matters" + with pytest.raises(KeyError): + c.this - def test_simple_dict(self) -> None: - c = ConfigFile(DATA_PATH / "good.conf") - assert c["zeroth_key"] == "test" - assert c["first_key"] == "András" - assert c["second_key"] == "test 2" - assert c["third_key"] == "test= 2==" - assert ( - c["fourth_key"] - == """ + +def test_simple_dict() -> None: + c = ConfigFile(DATA_PATH / "good.conf") + assert c["zeroth_key"] == "test" + assert c["first_key"] == "András" + assert c["my_hashtag"] == "#great_ai" + assert c["second_key"] == "test 2" + assert c["third_key"] == "test= 2==" + assert ( + c["fourth_key"] + == """ this# is multiline """ - ) - assert c["whitespace"] == "hardly matters" - with pytest.raises(KeyError): - c["#this"] + ) + assert c["whitespace"] == "hardly matters" + with pytest.raises(KeyError): + c["#this"] - def test_string_path(self) -> None: - c = ConfigFile(str(DATA_PATH / "good.conf")) - assert c.zeroth_key == "test" - assert c.first_key == "András" - assert c.second_key == "test 2" - assert c.third_key == "test= 2==" - assert ( - c.fourth_key - == """ + +def test_string_path() -> None: + c = ConfigFile(str(DATA_PATH / "good.conf")) + assert c.zeroth_key == "test" + assert c.first_key == "András" + assert c.my_hashtag == "#great_ai" + + assert c.second_key == "test 2" + assert c.third_key == "test= 2==" + assert ( + c.fourth_key + == """ this# is multiline """ - ) - assert c.whitespace == "hardly matters" + ) + assert c.whitespace == "hardly matters" - def test_env(self) -> None: - import os - os.environ["alma"] = "12" - c = ConfigFile(DATA_PATH / "env.conf") - del os.environ["alma"] - assert c.first_key == "test" - assert c.second_key == "12" +def test_env() -> None: + os.environ["alma"] = "12" + c = ConfigFile(DATA_PATH / "env.conf") + del os.environ["alma"] + assert c.first_key == "test" + assert c.second_key == "12" - def test_env_not_exists(self) -> None: - with pytest.raises(KeyError): - ConfigFile(DATA_PATH / "env.conf") - def test_env_not_exists_but_ignored(self) -> None: - with pytest.raises(KeyError): - ConfigFile( - DATA_PATH / "env.conf", ignore_missing_environment_variables=True - ) +def test_env_not_exists() -> None: + with pytest.raises(ValueError): + ConfigFile(DATA_PATH / "env-bad.conf") - def test_duplicate_key(self) -> None: - with pytest.raises(KeyError): - ConfigFile(DATA_PATH / "bad.conf") + +def test_env_not_exists_fallback() -> None: + os.environ["alma"] = "12" + c = ConfigFile(DATA_PATH / "env.conf") + assert c.fourth_key == "this is a default value" + + +def test_env_exists_ignore_fallback() -> None: + os.environ["alma"] = "12" + os.environ["SOMETHING"] = "hi" + c = ConfigFile(DATA_PATH / "env.conf") + del os.environ["SOMETHING"] + + assert c.fourth_key == "hi" + + +def test_duplicate_key() -> None: + with pytest.raises(KeyError): + ConfigFile(DATA_PATH / "bad.conf") diff --git a/tests/utilities/test_evaluate_ranking.py b/tests/utilities/test_evaluate_ranking.py index 60d8226..8111b6a 100644 --- a/tests/utilities/test_evaluate_ranking.py +++ b/tests/utilities/test_evaluate_ranking.py @@ -1,97 +1,94 @@ -import unittest from pathlib import Path import matplotlib +import pytest matplotlib.use("Agg") # don't show a window for each test -from src.great_ai.utilities import evaluate_ranking +from great_ai.utilities import evaluate_ranking -class TestEvaluateRanking(unittest.TestCase): - def test_default(self) -> None: - results = evaluate_ranking( - ["a", "a", "b", "b", "c", "d", "d", "d"], - [10, 7, 11, 6, 8, 2, 7, 1], - target_recall=0.6, - reverse_order=True, - ) +def test_default() -> None: + results = evaluate_ranking( + ["a", "a", "b", "b", "c", "d", "d", "d"], + [10, 7, 11, 6, 8, 2, 7, 1], + target_recall=0.6, + reverse_order=True, + ) - self.assertEqual( - results, - {"d": 1.0, "c": 0.6666666666666666, "b": 0.4}, - ) + assert results == {"d": 5 / 6, "c": 2 / 3, "b": 2 / 5} - results = evaluate_ranking( - ["a", "a", "b", "b", "c", "d", "d", "d"], - [10, 7, 11, 6, 8, 2, 7, 1], - target_recall=0.6, - reverse_order=False, - disable_interpolation=True, - ) + results = evaluate_ranking( + ["a", "a", "b", "b", "c", "d", "d", "d"], + [10, 7, 11, 6, 8, 2, 7, 1], + target_recall=0.6, + reverse_order=False, + disable_interpolation=True, + ) - self.assertEqual( - results, - {"a": 0.6666666666666666, "b": 0.3333333333333333, "c": 0.2857142857142857}, - ) + assert results == {"a": 0.6, "b": 0.4, "c": 0.2} - def test_mismatching_lengths(self) -> None: - self.assertRaises( - ValueError, - evaluate_ranking, + +def test_mismatching_lengths() -> None: + with pytest.raises(ValueError): + evaluate_ranking( ["a", "a", "b", "b", "c"], [10, 7, 11, 6, 8, 2, 7, 1], target_recall=0.6, ) - def test_invalid_recalls(self) -> None: - self.assertRaises( - AssertionError, - evaluate_ranking, + +def test_invalid_recalls() -> None: + with pytest.raises(AssertionError): + evaluate_ranking( ["a", "a", "b", "b"], [10, 7, 11, 6], target_recall=10.6, ) - self.assertRaises( - AssertionError, - evaluate_ranking, + with pytest.raises(AssertionError): + evaluate_ranking( ["a", "a", "b", "b"], [10, 7, 11, 6], target_recall=-0.0001, ) - self.assertRaises( - AssertionError, - evaluate_ranking, + with pytest.raises(AssertionError): + evaluate_ranking( ["a", "a", "b", "b"], [10, 7, 11, 6], target_recall=1.00001, ) - def test_empty(self) -> None: - evaluate_ranking( - [], - [], - target_recall=0.6, - ) - evaluate_ranking( - ["a"], - [1], - target_recall=0.6, - ) +def test_empty() -> None: + evaluate_ranking( + [], + [], + target_recall=0.6, + ) - def test_save(self) -> None: - path = Path("test.svg") - path.unlink(missing_ok=True) + evaluate_ranking( + ["a"], + [1], + target_recall=0.6, + ) - evaluate_ranking( - ["a", "a", "b", "b", "c", "d", "d", "d"], - [10, 7, 11, 6, 8, 2, 7, 1], - target_recall=0.1, - output_svg=path, - ) - self.assertTrue(path.exists()) +def test_save() -> None: + path = Path("test.svg") + try: path.unlink() + except FileNotFoundError: + # missing_ok only exists >= Python 3.8 + pass + + evaluate_ranking( + ["a", "a", "b", "b", "c", "d", "d", "d"], + [10, 7, 11, 6, 8, 2, 7, 1], + target_recall=0.1, + output_svg=path, + ) + + assert path.exists() + path.unlink() diff --git a/tests/utilities/test_get_sentences.py b/tests/utilities/test_get_sentences.py index 7d864f3..43810d1 100644 --- a/tests/utilities/test_get_sentences.py +++ b/tests/utilities/test_get_sentences.py @@ -1,58 +1,59 @@ -import unittest - -from src.great_ai.utilities import get_sentences +from great_ai.utilities import get_sentences -class TestGetSentences(unittest.TestCase): - def test_default(self) -> None: - text = "This is a complete sentence. So is this. However this is n" # ot. - expected = ["This is a complete sentence.", "So is this.", "However this is n"] +def test_default() -> None: + text = "This is a complete sentence. So is this. However this is n" # ot. + expected = ["This is a complete sentence.", "So is this.", "However this is n"] - assert get_sentences(text) == expected - assert get_sentences(text, ignore_partial=True) == expected[0:2] - - def test_complex(self) -> None: - text = """ - This is a complete sentence. So is this. - End of paragraph. + assert get_sentences(text) == expected + assert get_sentences(text, ignore_partial=True) == expected[0:2] - Negation contractions (like don't or ain't) are resolved. +def test_complex() -> None: + text = """ + This is a complete sentence. So is this. + End of paragraph. - However this is not a sent - """ - expected = [ - "This is a complete sentence.", - "So is this.", - "End of paragraph.", - "Negation contractions (like don't or ain't) are resolved.", - "However this is not a sent", - ] + Negation contractions (like don't or ain't) are resolved. - print(get_sentences(text, ignore_partial=True)) + However this is not a sent + """ - assert get_sentences(text) == expected - assert get_sentences(text, ignore_partial=True) == expected[:-1] + expected = [ + "This is a complete sentence.", + "So is this.", + "End of paragraph.", + "Negation contractions (like don't or ain't) are resolved.", + "However this is not a sent", + ] - def test_true_casing(self) -> None: - text = "This is also referred to as a Convolutional Neural Network (CNN)." - expected = ["this is also referred to as a Convolutional Neural Network (CNN)."] + print(get_sentences(text, ignore_partial=True)) - assert get_sentences(text, true_case=True) == expected + assert get_sentences(text) == expected + assert get_sentences(text, ignore_partial=True) == expected[:-1] - def test_remove_punctuation(self) -> None: - text = "Also, we --- the authors --- have to find less intrusive, and higher potential procedures. " - expected = [ - "Also we the authors have to find less intrusive and higher potential procedures" - ] - assert get_sentences(text, remove_punctuation=True) == expected +def test_true_casing() -> None: + text = "This is also referred to as a Convolutional Neural Network (CNN)." + expected = ["this is also referred to as a Convolutional Neural Network (CNN)."] - def test_empty(self) -> None: - assert get_sentences("") == [] - assert get_sentences(" ") == [] - assert get_sentences(" \n ") == [] - assert get_sentences("", ignore_partial=True) == [] - assert get_sentences("", true_case=True) == [] - assert get_sentences("", remove_punctuation=True) == [] + assert get_sentences(text, true_case=True) == expected + + +def test_remove_punctuation() -> None: + text = "Also, we --- the authors --- have to find less intrusive, and higher potential procedures. " + expected = [ + "Also we the authors have to find less intrusive and higher potential procedures" + ] + + assert get_sentences(text, remove_punctuation=True) == expected + + +def test_empty() -> None: + assert get_sentences("") == [] + assert get_sentences(" ") == [] + assert get_sentences(" \n ") == [] + assert get_sentences("", ignore_partial=True) == [] + assert get_sentences("", true_case=True) == [] + assert get_sentences("", remove_punctuation=True) == [] diff --git a/tests/utilities/test_language.py b/tests/utilities/test_language.py index 7aabac1..60df338 100644 --- a/tests/utilities/test_language.py +++ b/tests/utilities/test_language.py @@ -1,35 +1,30 @@ -import unittest - -from src.great_ai.utilities import ( - english_name_of_language, - is_english, - predict_language, -) +from great_ai.utilities import english_name_of_language, is_english, predict_language -class TestLanguage(unittest.TestCase): - def test_predict_language(self) -> None: - assert predict_language("This is an English text.") == "en" - assert predict_language("Ez egy magyar szöveg.") == "hu" - assert predict_language("32") == "und" - assert predict_language("") == "und" +def test_predict_language() -> None: + assert predict_language("This is an English text.") == "en" + assert predict_language("Ez egy magyar szöveg.") == "hu" + assert predict_language("32") == "und" + assert predict_language("") == "und" - def test_is_english(self) -> None: - self.assertTrue(is_english("en")) - self.assertTrue(is_english("en-US")) - self.assertFalse(is_english("hu")) - self.assertFalse(is_english("de")) - self.assertFalse(is_english("zh")) - self.assertFalse(is_english("zh-TW")) - self.assertFalse(is_english("und")) - self.assertFalse(is_english("")) - self.assertFalse(is_english(None)) - def english_name_of_language(self) -> None: - assert english_name_of_language("en") == "English" - assert english_name_of_language("hu") == "Hungarian" - assert english_name_of_language("zh") == "Chinese" - assert english_name_of_language("zh-TW") == "Chinese" - assert english_name_of_language("und") == "Unknown language" - assert english_name_of_language("") == "Unknown language" - assert english_name_of_language(None) == "Unknown language" +def test_is_english() -> None: + assert is_english("en") + assert is_english("en-US") + assert not is_english("hu") + assert not is_english("de") + assert not is_english("zh") + assert not is_english("zh-TW") + assert not is_english("und") + assert not is_english("") + assert not is_english(None) + + +def test_english_name_of_language() -> None: + assert english_name_of_language("en") == "English" + assert english_name_of_language("hu") == "Hungarian" + assert english_name_of_language("zh") == "Chinese" + assert english_name_of_language("zh-TW") == "Chinese (Taiwan)" + assert english_name_of_language("und") == "Unknown language" + assert english_name_of_language("") == "Unknown language" + assert english_name_of_language(None) == "Unknown language" diff --git a/tests/utilities/test_match_names.py b/tests/utilities/test_match_names.py deleted file mode 100644 index 5ee8d39..0000000 --- a/tests/utilities/test_match_names.py +++ /dev/null @@ -1,71 +0,0 @@ -import unittest - -from src.great_ai.utilities import match_names - - -class TestMatchNames(unittest.TestCase): - def test_grid(self) -> None: - names = [ - ["Al-Nasiry, S.", "Al-Nasiry S"], - ["De Leo, A. (Andreina)"], - [ - "DeBenedictis, J.N. (Julia)", - "DeBenedictis, N. (Julia)", - "DeBenedictis, J.", - "Julia DeBenedictis", - ], - ["Diesen, J.A.Y. van"], - ["Nio, C Yung"], - ["Uyen Chau Nguyen"], - ["Hagger M.S.", "Martin Hagger"], - ["Izabela-Cristina STANCU"], - ["Verborgh R.", "Ruben Verborgh"], - ["Droshout, D.T.G.G.M.L. (Dimitri)"], - ["El Demellawy"], - ["Sebastiaan van de Velde", "van de Velde, Sebastiaan"], - ["Sebastiaan Brand"], - ["Bertil FM Blok", "B.F.M. Blok"], - ["Bob Zadok Blok"], - ["Shannon Spruit"], - ["Shannon Kroes"], - [ - "MSc Jérémie Decouchant", - "PhD, Jérémie Decouchant", - "PhD Jérémie Decouchant", - "Jérémie Decouchant", - "MD, PhD Jérémie Decouchant", - ], - ["Jeremie Gobeil"], - ["Wouters, B.B.R.E.F.", "Wouters B.B. R. E.F."], - ["Elias Caldeira Dantas, A.M. (Aline)"], - ["Ed Harris"], - ["Ed Deprettere ", " Ed Deprettere "], - ["András Schmelczer"], - ["Enden, G. van den (Gitta)"], - ["Ruben van Dijk"], - ["Richard van Dijk"], - ["Xinping Guan", "X. Guan"], - ["Xiaohong Guan", "X. Guan"], - ["Pruimboom, Tim", "Pruimboom T."], - ["Sanchez-Faddeev H.", "Sanchez-Faddeev, Hernando"], - ["Duijnhoven - Jansen, E.M. van", "Emma M. van Jansen"], - ] - - all_names = [n for t in names for n in t] - - for n1 in all_names: - for n2 in all_names: - is_match = match_names(n1, n2) - groups = [t for t in names if n1 in t] - with self.subTest(n1=n1, n2=n2): - if any(n2 in g for g in groups): - self.assertTrue(is_match, "false negative") - elif all(n2 not in g for g in groups): - self.assertFalse(is_match, "false match") - - def test_empty(self) -> None: - self.assertFalse(match_names("", "")) - self.assertFalse(match_names(None, "")) - self.assertFalse(match_names(None, None)) - self.assertFalse(match_names("", None)) - self.assertFalse(match_names("Oliver", None)) diff --git a/tests/utilities/test_parallel_map.py b/tests/utilities/test_parallel_map.py index 0a363df..4774f7b 100644 --- a/tests/utilities/test_parallel_map.py +++ b/tests/utilities/test_parallel_map.py @@ -1,42 +1,97 @@ -import unittest +from typing import Any, Iterable -from src.great_ai.utilities import parallel_map +import pytest +from great_ai.utilities import WorkerException, parallel_map +from typing_extensions import Never COUNT = int(1e5) + 3 -class TestParallelMap(unittest.TestCase): - def test_simple_case_with_progress_bar(self) -> None: - inputs = range(COUNT) - expected = [v**2 for v in range(COUNT)] +def test_simple_case() -> None: + assert list(parallel_map(lambda v: v**2, range(COUNT), concurrency=4)) == [ + v**2 for v in range(COUNT) + ] - assert parallel_map(lambda v: v**2, inputs) == expected - def test_simple_case_without_progress_bar(self) -> None: - inputs = range(COUNT) - expected = [v**2 for v in range(COUNT)] +def test_with_iterable() -> None: + from time import sleep - self.assertEqual( - parallel_map(lambda v: v**2, inputs, disable_progress=True), expected + def my_generator() -> Iterable[int]: + for i in range(10): + yield i + sleep(0.1) + + expected = [v**3 for v in range(10)] + + assert list(parallel_map(lambda x: x**3, my_generator(), chunk_size=1)) == expected + + +def test_simple_case_invalid_values() -> None: + with pytest.raises(AssertionError): + list(parallel_map(lambda v: v**2, range(COUNT), concurrency=0)) + + with pytest.raises(AssertionError): + list(parallel_map(lambda v: v**2, range(COUNT), chunk_size=0)) + + +def test_this_process_exception() -> None: + def my_generator() -> Iterable[int]: + yield 1 + yield 2 + yield 3 + assert False + + with pytest.raises(AssertionError): + list(parallel_map(lambda v: v**2, my_generator(), concurrency=2, chunk_size=2)) + + with pytest.raises(AssertionError): + list(parallel_map(lambda v: v**2, my_generator(), concurrency=1, chunk_size=2)) + + +def test_ignore_this_process_exception() -> None: + def my_generator() -> Iterable[float]: + yield 1 + yield 2 + yield 3 + yield 1 / 0 + + assert list( + parallel_map( + lambda v: v**2, + my_generator(), + concurrency=2, + chunk_size=2, + ignore_exceptions=True, ) + ) == [1, 4] - def test_simple_case_invalid_values(self) -> None: - inputs = range(COUNT) - self.assertRaises( - AssertionError, parallel_map, lambda v: v**2, inputs, concurrency=0 - ) - self.assertRaises( - AssertionError, parallel_map, lambda v: v**2, inputs, chunk_size=0 - ) +def test_worker_process_exception() -> None: + def oh_no(_: Any) -> Never: + raise ValueError("hi") - def test_no_op(self) -> None: - assert parallel_map(lambda v: v**2, [], disable_progress=True) == [] - self.assertEqual( - parallel_map(lambda v: v**2, [], disable_progress=True, chunk_size=100), - [], - ) - self.assertEqual( - parallel_map(lambda v: v**2, [], disable_progress=True, concurrency=100), - [], - ) + with pytest.raises(WorkerException): + list(parallel_map(oh_no, range(COUNT), concurrency=2)) + + with pytest.raises(WorkerException): + list(parallel_map(oh_no, range(COUNT), concurrency=1)) + + +def test_ignore_worker_process_exception() -> None: + def oh_no(_: Any) -> Never: + raise ValueError("hi") + + assert ( + list(parallel_map(oh_no, range(3), concurrency=2, ignore_exceptions=True)) + == [None] * 3 + ) + assert ( + list(parallel_map(oh_no, range(3), concurrency=1, ignore_exceptions=True)) + == [None] * 3 + ) + + +def test_no_op() -> None: + assert list(parallel_map(lambda v: v**2, [])) == [] + assert list(parallel_map(lambda v: v**2, [], chunk_size=100)) == [] + assert list(parallel_map(lambda v: v**2, [], concurrency=100)) == [] diff --git a/tests/utilities/test_threaded_parallel_map.py b/tests/utilities/test_threaded_parallel_map.py new file mode 100644 index 0000000..e2efeb7 --- /dev/null +++ b/tests/utilities/test_threaded_parallel_map.py @@ -0,0 +1,119 @@ +from typing import Any, Iterable + +import pytest +from great_ai.utilities import WorkerException, threaded_parallel_map +from typing_extensions import Never + +COUNT = int(1e5) + 3 + + +def test_simple_case() -> None: + assert list( + threaded_parallel_map(lambda v: v**2, range(COUNT), concurrency=4) + ) == [v**2 for v in range(COUNT)] + + +def test_with_iterable() -> None: + from time import sleep + + def my_generator() -> Iterable[int]: + for i in range(10): + yield i + sleep(0.1) + + expected = [v**3 for v in range(10)] + + assert ( + list(threaded_parallel_map(lambda x: x**3, my_generator(), chunk_size=1)) + == expected + ) + + +def test_simple_case_invalid_values() -> None: + with pytest.raises(AssertionError): + list(threaded_parallel_map(lambda v: v**2, range(COUNT), concurrency=0)) + + with pytest.raises(AssertionError): + list(threaded_parallel_map(lambda v: v**2, range(COUNT), chunk_size=0)) + + +def test_this_worker_exception() -> None: + def my_generator() -> Iterable[int]: + yield 1 + yield 2 + yield 3 + assert False + + with pytest.raises(AssertionError): + list( + threaded_parallel_map( + lambda v: v**2, my_generator(), concurrency=2, chunk_size=2 + ) + ) + + with pytest.raises(AssertionError): + list( + threaded_parallel_map( + lambda v: v**2, my_generator(), concurrency=1, chunk_size=2 + ) + ) + + +def test_ignore_this_worker_exception() -> None: + def my_generator() -> Iterable[float]: + yield 1 + yield 2 + yield 3 + yield 1 / 0 + + assert list( + threaded_parallel_map( + lambda v: v**2, + my_generator(), + concurrency=2, + chunk_size=2, + ignore_exceptions=True, + ) + ) == [ + 1, + 4, + ] # the second chunk is ruined because of the error + + +def test_worker_worker_exception() -> None: + def oh_no(_: Any) -> Never: + raise ValueError("hi") + + with pytest.raises(WorkerException): + list(threaded_parallel_map(oh_no, range(COUNT), concurrency=2)) + + with pytest.raises(WorkerException): + list(threaded_parallel_map(oh_no, range(COUNT), concurrency=1)) + + +def test_ignore_worker_worker_exception() -> None: + def oh_no(_: Any) -> Never: + raise ValueError("hi") + + assert ( + list( + threaded_parallel_map( + oh_no, range(3), concurrency=2, ignore_exceptions=True + ) + ) + == [None] * 3 + ) + assert ( + list( + threaded_parallel_map( + oh_no, range(3), concurrency=1, ignore_exceptions=True + ) + ) + == [None] * 3 + ) + + +def test_no_op() -> None: + assert list(threaded_parallel_map(lambda v: v**2, [])) == [] + assert list(threaded_parallel_map(lambda v: v**2, [], chunk_size=100)) == [] + assert list(threaded_parallel_map(lambda v: v**2, [], concurrency=100)) == [] diff --git a/tests/utilities/test_unique.py b/tests/utilities/test_unique.py index e2204db..f85df13 100644 --- a/tests/utilities/test_unique.py +++ b/tests/utilities/test_unique.py @@ -1,6 +1,4 @@ -import unittest - -from src.great_ai.utilities import unique +from great_ai.utilities import unique original = [ ("a", 1), @@ -12,43 +10,44 @@ original = [ ] -class TestUnique(unittest.TestCase): - def test_default(self) -> None: - values = [ - *original, - ("a", 2), - ("a", 1), - ("a", -3), - ("b", 5), - ("c", 5), - ("d", 2), - ] +def test_default() -> None: + values = [ + *original, + ("a", 2), + ("a", 1), + ("a", -3), + ("b", 5), + ("c", 5), + ("d", 2), + ] - expected = original + expected = original - assert unique(values) == expected - assert unique(values, key=lambda v: v) == expected + assert unique(values) == expected + assert unique(values, key=lambda v: v) == expected - def test_with_key_0(self) -> None: - values = original - expected = [ - ("a", 1), - ("b", 5), - ("c", 5), - ("d", 2), - ] +def test_with_key_0() -> None: + values = original - assert unique(values, key=lambda v: v[0]) == expected + expected = [ + ("a", 1), + ("b", 5), + ("c", 5), + ("d", 2), + ] - def test_with_key_1(self) -> None: - values = original + assert unique(values, key=lambda v: v[0]) == expected - expected = [ - ("a", 1), - ("b", 5), - ("a", -3), - ("d", 2), - ] - assert unique(values, key=lambda v: v[1]) == expected +def test_with_key_1() -> None: + values = original + + expected = [ + ("a", 1), + ("b", 5), + ("a", -3), + ("d", 2), + ] + + assert unique(values, key=lambda v: v[1]) == expected diff --git a/tox.ini b/tox.ini new file mode 100644 index 0000000..f853c1f --- /dev/null +++ b/tox.ini @@ -0,0 +1,13 @@ +[tox] +envlist = py37,py38,py39,py310 +isolated_build = True + +[testenv] +alwayscopy = True +setenv = + PY_IGNORE_IMPORTMISMATCH = 1 +deps = + pytest + pytest-cov + pytest-asyncio +commands = pytest --doctest-modules --asyncio-mode=strict