diff --git a/.editorconfig b/.editorconfig index f499c879e..675923a2d 100644 --- a/.editorconfig +++ b/.editorconfig @@ -13,7 +13,7 @@ tab_width = 4 profile = black max_line_length = 100 -[{*.yml,*.yaml}] +[{*.yml,*.yaml,*.toml}] indent_size = 2 tab_width = 2 diff --git a/.github/dependabot.yml b/.github/dependabot.yml deleted file mode 100644 index 7c53f3204..000000000 --- a/.github/dependabot.yml +++ /dev/null @@ -1,12 +0,0 @@ -# Please see the documentation for all configuration options: -# https://docs.github.com/github/administering-a-repository/configuration-options-for-dependency-updates - -version: 2 -updates: - - package-ecosystem: "pip" - directory: "/" # Location of package manifests - schedule: - interval: "weekly" - # Add reviewers - reviewers: - - "benwandrew" diff --git a/.github/workflows/publish-documentation-gh-pages.yml b/.github/workflows/publish-documentation-gh-pages.yml index e2c0af17b..b80761da1 100644 --- a/.github/workflows/publish-documentation-gh-pages.yml +++ b/.github/workflows/publish-documentation-gh-pages.yml @@ -3,26 +3,21 @@ name: Publish Documentation to GitHub Pages on: workflow_dispatch: # this allows us to run it manually release: - types: [ released ] # only deploy when we make a new `latest` release + types: [released] # only deploy when we make a new `latest` release permissions: contents: write jobs: - - build-publish: + publish: runs-on: ubuntu-latest steps: - uses: actions/checkout@v3 - - - run: pipx install poetry - - - uses: actions/setup-python@v4 + - name: Set up Python + uses: actions/setup-python@v4 with: - python-version: 3.8 - cache: 'poetry' - + python-version: '3.x' + cache: 'pip' - name: Install dependencies - run: poetry install - - - run: poetry run mkdocs gh-deploy --force + run: pip install -U ".[docs]" + - run: mkdocs gh-deploy --force diff --git a/.github/workflows/publish-package-anaconda-org.yml b/.github/workflows/publish-package-anaconda-org.yml deleted file mode 100644 index 6ce42c3f6..000000000 --- a/.github/workflows/publish-package-anaconda-org.yml +++ /dev/null @@ -1,45 +0,0 @@ -name: Publish package to Anaconda.org - -on: - release: - types: [ published ] - -jobs: - build-conda: - runs-on: ubuntu-20.04 - # ubuntu-20.04 selected over ubuntu-latest because - # upload part of conda build command is broken in ubuntu-latest - # JGH: I think that the function conda_build.external.find_executable - # ... might be returning a list of executables for the "anaconda" - # ... rather than the expected single value. - # When updating to ubuntu 22.04: check that upload functions correctly. - # If it does, you're fine to update and get rid of this comment. - - steps: - - uses: actions/checkout@v3 - - - name: Replace version number in meta.yaml with release number - run: | - REF_NAME_WITHOUT_V=${GITHUB_REF_NAME#v} - sed -i.bak "s/^{% set version =.*$/{% set version = \"${REF_NAME_WITHOUT_V}\" %}/" conda/autora/meta.yaml - - - name: Set up Python - uses: actions/setup-python@v4 - with: - python-version: '3.9' - - - name: Add conda to system path - run: | - # $CONDA is an environment variable pointing to the root of the miniconda directory - echo $CONDA/bin >> $GITHUB_PATH - - - name: Install dependencies - run: | - conda install conda-build conda-verify anaconda-client - - - name: Build - run: | - cd ./conda - conda config --set anaconda_upload yes - conda build autora -c pytorch --token "${{ secrets.ANACONDA_TOKEN }}" - diff --git a/.github/workflows/publish-package-pypi.yml b/.github/workflows/publish-package-pypi.yml index 992e80d7d..c550e77c0 100644 --- a/.github/workflows/publish-package-pypi.yml +++ b/.github/workflows/publish-package-pypi.yml @@ -1,34 +1,38 @@ +# This workflow will upload a Python Package using Twine when a release is created +# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-python#publishing-to-package-registries + +# This workflow uses actions that are not certified by GitHub. +# They are provided by a third-party and are governed by +# separate terms of service, privacy policy, and support +# documentation. + name: Publish to PyPI on: release: - types: [ published ] + types: [published] + +permissions: + contents: read jobs: - - build-publish: + deploy: runs-on: ubuntu-latest steps: - - uses: actions/checkout@v3 - - - run: pipx install poetry - - - uses: actions/setup-python@v4 - with: - python-version: 3.8 - cache: 'poetry' - - - name: Install dependencies - run: poetry install - - - name: Bump version number - run: poetry version ${{ github.event.release.tag_name }} - - - name: Build package - run: poetry build - - - name: Setup PyPI Repository - run: poetry config pypi-token.pypi ${{ secrets.PYPI_TOKEN }} - - - name: Publish - run: poetry publish + - uses: actions/checkout@v3 + - name: Set up Python + uses: actions/setup-python@v4 + with: + python-version: '3.x' + cache: 'pip' + - name: Install dependencies + run: | + python -m pip install --upgrade pip + pip install build + - name: Build package + run: python -m build + - name: Publish package + uses: pypa/gh-action-pypi-publish@27b31702a0e7fc50959f5ad993c78deac1bdfc29 + with: + user: __token__ + password: ${{ secrets.PYPI_API_TOKEN }} diff --git a/.github/workflows/test-conda-build.yml b/.github/workflows/test-conda-build.yml deleted file mode 100644 index d38313784..000000000 --- a/.github/workflows/test-conda-build.yml +++ /dev/null @@ -1,25 +0,0 @@ -name: Test Conda Build - -on: - pull_request: - merge_group: - -jobs: - build-conda: - runs-on: ubuntu-latest - - steps: - - uses: actions/checkout@v3 - - - name: Add conda to system path - run: | - # $CONDA is an environment variable pointing to the root of the miniconda directory - echo $CONDA/bin >> $GITHUB_PATH - - - name: Install dependencies - run: conda install conda-build - - - name: Build conda package - run: | - cd conda - conda build autora -c pytorch diff --git a/.github/workflows/test-poetry-build.yml b/.github/workflows/test-poetry-build.yml deleted file mode 100644 index a401cb74f..000000000 --- a/.github/workflows/test-poetry-build.yml +++ /dev/null @@ -1,24 +0,0 @@ -name: Test Poetry Build - -on: - pull_request: - merge_group: - -jobs: - build-poetry: - runs-on: ubuntu-latest - steps: - - uses: actions/checkout@v3 - - - run: pipx install poetry - - - uses: actions/setup-python@v4 - with: - python-version: 3.8 - cache: 'poetry' - - - name: Install dependencies - run: poetry install - - - name: Build package - run: poetry build diff --git a/.github/workflows/test-pre-commit-hooks.yml b/.github/workflows/test-pre-commit-hooks.yml index 9a9d7eeaf..919ca494a 100644 --- a/.github/workflows/test-pre-commit-hooks.yml +++ b/.github/workflows/test-pre-commit-hooks.yml @@ -10,17 +10,16 @@ on: jobs: build: runs-on: ubuntu-latest - steps: - uses: actions/checkout@v3 - - run: pipx install poetry - - uses: actions/setup-python@v4 + - name: Set up Python + uses: actions/setup-python@v4 with: - python-version: 3.8 - cache: "poetry" - - run: poetry install --only pre-commit + python-version: '3.8' + cache: 'pip' + - run: pip install pre-commit - uses: actions/cache@v3 with: path: ~/.cache/pre-commit key: pre-commit-3|${{ env.pythonLocation }}|${{ runner.os }}|${{ hashFiles('.pre-commit-config.yaml') }} - - run: poetry run pre-commit run --all-files --show-diff-on-failure --color=always + - run: pre-commit run --all-files --show-diff-on-failure --color=always diff --git a/.github/workflows/test-pypi-build.yml b/.github/workflows/test-pypi-build.yml new file mode 100644 index 000000000..7fc744d37 --- /dev/null +++ b/.github/workflows/test-pypi-build.yml @@ -0,0 +1,25 @@ +name: Test PyPI Build + +on: + pull_request: + merge_group: + +permissions: + contents: read + +jobs: + build: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v3 + - name: Set up Python + uses: actions/setup-python@v4 + with: + python-version: '3.x' + cache: 'pip' + - name: Install dependencies + run: | + python -m pip install --upgrade pip + pip install build + - name: Build package + run: python -m build diff --git a/.github/workflows/test-pytest.yml b/.github/workflows/test-pytest.yml index 446e4a209..df47f2eb5 100644 --- a/.github/workflows/test-pytest.yml +++ b/.github/workflows/test-pytest.yml @@ -12,15 +12,15 @@ jobs: strategy: fail-fast: true matrix: - python-version: ["3.8", "3.9", "3.10"] + python-version: ["3.8", "3.9", "3.10", "3.11"] os: [ubuntu-latest, macos-latest, windows-latest] runs-on: ${{ matrix.os }} steps: - - uses: actions/checkout@v3 - - run: pipx install poetry - - uses: actions/setup-python@v4 - with: - python-version: ${{ matrix.python-version }} - cache: "poetry" - - run: poetry install --only main,test - - run: poetry run pytest + - uses: actions/checkout@v3 + - uses: actions/setup-python@v4 + with: + python-version: ${{ matrix.python-version }} + cache: 'pip' + - name: Install dependencies + run: pip install -U ".[test]" + - run: pytest diff --git a/.idea/autora.iml b/.idea/autora.iml index e163492a5..01e4256c7 100644 --- a/.idea/autora.iml +++ b/.idea/autora.iml @@ -2,14 +2,16 @@ + + - + @@ -23,4 +25,4 @@ - + \ No newline at end of file diff --git a/.idea/misc.xml b/.idea/misc.xml index 2f700f2b8..588d16260 100644 --- a/.idea/misc.xml +++ b/.idea/misc.xml @@ -1,6 +1,5 @@ - diff --git a/.idea/other.xml b/.idea/other.xml deleted file mode 100644 index a708ec781..000000000 --- a/.idea/other.xml +++ /dev/null @@ -1,6 +0,0 @@ - - - - - \ No newline at end of file diff --git a/.idea/runConfigurations/pytest_in_tests.xml b/.idea/runConfigurations/pytest_in_tests.xml deleted file mode 100644 index 351b1dff2..000000000 --- a/.idea/runConfigurations/pytest_in_tests.xml +++ /dev/null @@ -1,19 +0,0 @@ - - - - - \ No newline at end of file diff --git a/.idea/vcs.xml b/.idea/vcs.xml index 94a25f7f4..35eb1ddfb 100644 --- a/.idea/vcs.xml +++ b/.idea/vcs.xml @@ -1,6 +1,6 @@ - + \ No newline at end of file diff --git a/Brewfile b/Brewfile deleted file mode 100644 index 8c840000d..000000000 --- a/Brewfile +++ /dev/null @@ -1,7 +0,0 @@ -# Python environment -brew "pyenv" -brew "poetry" -brew "pre-commit" - -# External tools -brew "graphviz" diff --git a/MAINTAINING.md b/MAINTAINING.md new file mode 100644 index 000000000..2e6fee33d --- /dev/null +++ b/MAINTAINING.md @@ -0,0 +1,36 @@ +# Maintainer Guide + +## Release Process + +The release process is automated using GitHub Actions. + +- Before you start, ensure that the tokens are up-to-date. If in doubt, try to create and publish a new release + candidate version of the package first. The tokens are stored as "organization secrets" enabled for the autora + repository, and are called: + - PYPI_TOKEN: a token from pypi.org with upload permissions on the AutoResearch/AutoRA project. + - ANACONDA_TOKEN: a token from anaconda.org with the following scopes on the AutoResearch organization: `repos conda + api:read api:write`. Current token expires on 2023-03-01. + +- Update [conda recipe](./conda/autora/meta.yaml): + - dependencies, so that it matches [pyproject.toml](pyproject.toml). + - imports for testing – all modules should be listed. + +- Trigger a new release from GitHub. + - Navigate to the repository's code tab at https://github.com/autoresearch/autora, + - Click "Releases", + - Click "Draft a new release", + - In the "Choose a tag" field, type the new semantic release number using the [PEP440 syntax](https://peps.python. + org/pep-0440/). The version number should be prefixed with a "v". + e.g. "v1.2.3" for a standard release, "v1.2.3a4" for an alpha release, "v1.2.3b5" for a beta release, + "v1.2.3rc6" for a release candidate, and then click "Create new tag on publish". + - Leave "Release title" empty. + - Click on "Generate Release notes". Check that the release notes match with the version number you have chosen – + breaking changes require a new major version number, e.g. v2.0.0, new features a minor version number, e.g. + v1.3.0 and fixes a bugfix number v1.2.4. If necessary, modify the version number you've chosen to be consistent + with the content of the release. + - Select whether this is a pre-release or a new "latest" release. It's a "pre-release" if there's an alpha, + beta, or release candidate number in the tag name, otherwise it's a new "latest" release. + - Click on "Publish release" + +- GitHub actions will run to create and publish the PyPI and Anaconda packages, and publish the documentation. Check in + GitHub actions whether they run without errors and fix any errors which occur. diff --git a/README.md b/README.md index 56715d601..b3d280d09 100644 --- a/README.md +++ b/README.md @@ -1,424 +1,31 @@ # Automated Research Assistant -Automated Research Assistant (AutoRA) is an open source AI-based system for automating each aspect of empirical research in the behavioral sciences, from the construction of a scientific hypothesis to conducting novel experiments. The documentation is here: [https://autoresearch.github.io/autora/](https://autoresearch.github.io/autora/) -# Getting started +![PyPI](https://img.shields.io/pypi/v/autora) +![GitHub Workflow Status](https://img.shields.io/github/actions/workflow/status/autoresearch/autora/test-pytest.yml) +![PyPI - Downloads](https://img.shields.io/pypi/dm/autora) -You should be familiar with the command line for your operating system. The topics required are covered in: -- **macOS**: Joe Kissell. [*Take Control of the Mac Command Line with Terminal, 3rd Edition*](https://bruknow.library.brown.edu/permalink/01BU_INST/528fgv/cdi_safari_books_v2_9781947282513). Take Control Books, 2022. Chapters *Read Me First* through *Bring the Command Line Into The Real World*. -- **Linux**: William E. Shotts. [*The Linux Command Line: a Complete Introduction. 2nd edition.*](https://bruknow.library.brown.edu/permalink/01BU_INST/9mvq88/alma991043239704906966). No Starch Press, 2019. Parts *I: Learning the Shell* and *II: Configuration and the Environment*. +[AutoRA](https://pypi.org/project/autora/) (Automated Research Assistant) is an open-source framework for +automating multiple stages of the empirical research process, including model discovery, experimental design, data collection, and documentation for open science. -To use the AutoRA package you need: -- `python` and packages as specified in the `pyproject.toml` file, -- `graphviz` for some visualizations. +![Autonomous Empirical Research Paradigm](https://github.com/AutoResearch/autora/raw/restructure/autora/docs/img/overview.png) -To develop the AutoRA package, you also need: -- `git`, the source control tool, -- `pre-commit` which is used for handling git pre-commit hooks. +## Getting Started -We recommend setting up your development environment using: -- `pyenv` which is used for installing different versions of `python`, -- `poetry`, which handles resolving dependencies between `python` modules and ensures that you are using the same package versions as other members of the development team. +Check out the documentation at +[https://autoresearch.github.io/autora](https://autoresearch.github.io/autora). -You should also consider using an IDE. We recommend: -- PyCharm (academic licenses for PyCharm professional edition are available for free). This is a `python`-specific integrated development environment which comes with extremely powerful tools for changing the structure of `python` code, running tests, etc. -- Visual Studio Code (free). This is a powerful general text editor with plugins to support `python` development. +## About -The following sections describe how to install and configure the recommended setup for developing AutoRA. +This project is in active development by +the [Autonomous Empirical Research Group](http://empiricalresearch.ai), +led by [Sebastian Musslick](https://smusslick.com), +in collaboration with the [Center for Computation and Visualization at Brown University](https://ccv.brown.edu). -*Note: For end-users, it may be more appropriate to use an environment manager like `Anaconda` or `Miniconda` instead of `poetry`, but this is not currently supported.* +The development of this package is supported by Schmidt Science Fellows, in partnership with the Rhodes Trust, as well as the Carney BRAINSTORM program at Brown University. +## Read More -## Development Setup on macOS +- [Package Documentation](https://autoresearch.github.io/autora/) +- [AutoRA Pip Package](https://pypi.org/project/autora/) +- [Autonomous Empirical Research Group](http://www.empiricalresearch.ai) -### Prerequisites - -For macOS, we strongly recommend using `homebrew` to manage packages. - -Visit [https://brew.sh](https://brew.sh) and run the installation instructions. - -### Clone Repository - -We recommend using the GitHub CLI to clone the repository. Install it: - -```shell -brew install gh -``` - -Clone the repository. Run: -```shell -gh repo clone AutoResearch/AutoRA -``` - -... and following the prompts to authenticate to GitHub. It should clone the repository to a new directory. This is referred to as the `` in the rest of this readme. - -### Install Dependencies - -Open the repository directory in the terminal. - -Install the dependencies, which are listed in the [`Brewfile`](./Brewfile) by running: - -```shell -brew bundle -``` - -### Install `python` - -We recommend using `pyenv` to manage `python` versions. - -#### Initialize pyenv -Run the initialization script as follows: - -```shell -pyenv init -``` -... and follow the instructions to add `pyenv` to the `$PATH` by editing the interactive shell configuration -file, `.zshrc` or `.bashrc`. If it exists, this file is a hidden file ([dotfile](https://missing.csail.mit.edu/2019/dotfiles/)) in your home directory. You can create or edit this file using a -text editor or with CLI commands. Add the lines of script from the `pyenv init` response to the `.zshrc` file if they are -not already present. - -#### Restart shell session - -After making these changes, restart your shell session by executing: - -```shell -exec "$SHELL" -``` - -#### Install `python` - -Install a `python` version listed in the [`pyproject.toml`](./pyproject.toml) file. The entry looks like: - -```toml -python = "^3.8” -``` - -In this case, you could install version 3.8.13 as follows: - -```shell -pyenv install 3.8.13 -``` - -### Install Pre-Commit Hooks - -If you wish to commit to the repository, you should install the pre-commit hooks with the following command: -```shell -pre-commit install -``` - -For more information on pre-commit hooks, see [Pre-Commit-Hooks](#pre-commit-hooks) - -### Configure your development environment - -There are two suggested options for initializing an environment: -- _(Recommended)_ Using PyCharm, -- _(Advanced)_ Using `poetry` from the command line. - -#### PyCharm configuration - -Set up the Virtual environment – an isolated version of `python` and all the packages required to run AutoRA and develop it further – as follows: -- Open the `` in PyCharm. -- Navigate to PyCharm > Preferences > Project: AutoRA > Python Interpreter -- Next to the drop-down list of available interpreters, click the "Add Interpreter" and choose "Add Local Interpreter" to initialize a new interpreter. -- Select "Poetry environment" in the list on the left. Specify the following: - - Python executable: select the path to the installed `python` version you wish to use, e.g. - `~/.pyenv/versions/3.8.13/bin/python3` - - Select "install packages from pyproject.toml" - - Poetry executable: select the path to the poetry installation you have, e.g. - `/opt/homebrew/bin/poetry` - - Click "OK" and wait while the environment builds. - - Run the "Python tests in tests/" Run/Debug configuration in the PyCharm interface, and check that there are no errors. - -Additional setup steps for PyCharm: - -- You can (and should) completely hide the IDE-specific directory for Visual Studio Code in PyCharm by adding `.vscode` to the list of ignored folder names in Preferences > Editor > File Types > Ignored Files and Folders. This only needs to be done once. - -#### Command Line `poetry` Setup - -If you need more control over the `poetry` environment, then you can set up a new environment from the command line. - -*Note: Setting up a `poetry` environment on the command line is the only option for VSCode users.* - -From the ``, run the following commands. - -Activate the target version of `python` using `pyenv`: -```shell -pyenv shell 3.8.13 -``` - -Set up a new poetry environment with that `python` version: -```shell -poetry env use $(pyenv which python) -``` - -Update the installation utilities within the new environment: -```shell -poetry run python -m pip install --upgrade pip setuptools wheel -``` - -Use the `pyproject.toml` file to resolve and then install all the dependencies -```shell -poetry install -``` - -Once this step has been completed, skip to the section [Activating and using the environment](#activating-and-using-the-environment) to test it. - -#### Visual Studio Code Configuration - -After installing Visual Studio Code and the other prerequisites, carry out the following steps: - -- Open the `` in Visual Studio Code -- Install the Visual Studio Code plugin recommendations suggested with the project. These include: - - `python` - - `python-environment-manager` -- Run the [Command Line poetry Setup](#command-line-poetry-setup) specified above. This can be done in the built-in terminal if desired (Menu: Terminal > New Terminal). -- Select the `python` option in the vertical bar on the far left of the window (which appear after installing the plugins). Under the title "PYTHON: ENVIRONMENTS" should be a list of `python` environments. If these do not appear: - - Refresh the window pane - - Ensure the python-environment-manager is installed correctly. - - Ensure the python-environment-manager is activated. - -- Locate the correct `poetry` environment. Click the "thumbs up" symbol next to the poetry environment name to "set as active workspace interpreter". - -- Check that the `poetry` environment is correctly set-up. - - Open a new terminal within Visual Studio Code (Menu: Terminal > New Terminal). - - It should execute something like `source /Users/me/Library/Caches/pypoetry/virtualenvs/autora-2PgcgopX-py3.8/bin/activate` before offering you a prompt. - - If you execute `which python` it should return the path to your python executable in the `.../autora-2PgcgopX-py3.8/bin` directory. - - Ensure that there are no errors when you run: - ```shell - python -m unittest - ``` - in the built-in terminal. - -### Activating and using the environment - -#### Using `poetry` interactively - -To run interactive commands, you can activate the poetry virtual environment. From the `` directory, run: - -```shell -poetry shell -``` - -This spawns a new shell where you have access to the poetry `python` and all the packages installed using `poetry install`. You should see the prompt change: - -``` -% poetry shell -Spawning shell within /Users/me/Library/Caches/pypoetry/virtualenvs/autora-2PgcgopX-py3.8 -Restored session: Fri Jun 24 12:34:56 EDT 2022 -(autora-2PgcgopX-py3.8) % -``` - -If you execute `python` and then `import numpy`, you should be able to see that `numpy` has been imported from the `autora-2PgcgopX-py3.8` environment: - -``` -(autora-2PgcgopX-py3.8) % python -Python 3.8.13 (default, Jun 16 2022, 12:34:56) -[Clang 13.1.6 (clang-1316.0.21.2.5)] on darwin -Type "help", "copyright", "credits" or "license" for more information. ->>> import numpy ->>> numpy - -``` - -To deactivate the `poetry` environment, `exit` the session. This should return you to your original prompt, as follows: -``` -(autora-2PgcgopX-py3.8) % exit - -Saving session... -...saving history...truncating history files... -...completed. -% -``` - -To run a script, e.g. the `weber.py` script in the [`example/sklearn/darts`](./example/sklearn/darts) directory, execute: - -```shell -poetry run python example/sklearn/darts/weber.py -``` - -#### Using `poetry` non-interactively - -You can run python programs using poetry without activating the poetry environment, by using `poetry run {command}`. For example, to run the tests, execute: - -```shell -poetry run python -m unittest -``` - -It should return something like: - -``` -% poetry run python -m unittest -. --------------------------------- -Ran 1 test in 0.000s - -OK -``` - -## Development Setup on Windows - -Windows is not yet officially supported. You may be able to follow the same approach as for macOS to set up your development environment, with some modifications, e.g.: -- Using `chocolatey` in place of `homebrew`, -- Using the GitHub Desktop application in place of the GitHub CLI. - -If you successfully set up AutoRA on Windows, please update this readme. - -## Development Practices - -### Pre-Commit Hooks - -We use [`pre-commit`](https://pre-commit.com) to manage pre-commit hooks. - -Pre-commit hooks are programs which run before each git commit, and can read and potentially modify the files which are to be committed. - -We use pre-commit hooks to: -- enforce coding guidelines, including the `python` style-guide [PEP8](https://peps.python.org/pep-0008/) (`black` and `flake8`), -- to check the order of `import` statements (`isort`), -- to check the types of `python` objects (`mypy`). - -The hooks and their settings are specified in [`.pre-commit-config.yaml`](./.pre-commit-config.yaml). - -See the section [Install Pre-commit Hooks](#install-pre-commit-hooks) for installation instructions. - -#### Handling Pre-Commit Hook Errors - -If your `git commit` fails because of the pre-commit hook, then you should: - -1. Run the pre-commit hooks on the files which you have staged, by running the following command in your terminal: - ```zsh - $ pre-commit run - ``` - -2. Inspect the output. It might look like this: - ``` - $ pre-commit run - black....................Passed - isort....................Passed - flake8...................Passed - mypy.....................Failed - - hook id: mypy - - exit code: 1 - - example.py:33: error: Need type annotation for "data" (hint: "data: Dict[, ] = ...") - Found 1 errors in 1 files (checked 10 source files) - ``` -3. Fix any errors which are reported. - **Important: Once you've changed the code, re-stage the files it to Git. - This might mean un-staging changes and then adding them again.** -4. If you have trouble: - - Do a web-search to see if someone else had a similar error in the past. - - Check that the tests you've written work correctly. - - Check that there aren't any other obvious errors with the code. - - If you've done all of that, and you still can't fix the problem, get help from someone else on the team. -5. Repeat 1-4 until all hooks return "passed", e.g. - ``` - $ pre-commit run - black....................Passed - isort....................Passed - flake8...................Passed - mypy.....................Passed - ``` - -It's easiest to solve these kinds of problems if you make small commits, often. - -# Documentation - -## Commenting code - -To help users understand code better, and to make the documentation generation automatic, we have some standards for documenting code. The comments, docstrings, and the structure of the code itself are meant to make life easier for the reader. -- If something important isn't _obvious_ from the code, then it should be _made_ obvious with a comment. -- Conversely, if something _is_ obvious, then it doesn't need a comment. - -These standards are inspired by John Ousterhout. *A Philosophy of Software Design.* Yaknyam Press, 2021. Chapter 12 – 14. - -### Every public function, class and method has documentation - -We include docstrings for all public functions, classes, and methods. These docstrings are meant to give a concise, high-level overview of **why** the function exists, **what** it is trying to do, and what is **important** about the code. (Details about **how** the code works are often better placed in detailed comments within the code.) - -Every function, class or method has a one-line **high-level description** which clarifies its intent. - -The **meaning** and **type** of all the input and output parameters should be described. - -There should be **examples** of how to use the function, class or method, with expected outputs, formatted as ["doctests"](https://docs.python.org/3/library/doctest.html). These should include normal cases for the function, but also include cases where it behaves unexpectedly or fails. - -We follow the [Google Style Python Docstrings](https://sphinxcontrib-napoleon.readthedocs.io/en/latest/example_google.html), as these are supported by the online documentation tool we use (see [Online Documentation](#online-documentation)). - -A well documented function looks something like this: -```python -def first_order_linear( - x: Union[float, np.ndarray], c: float, m: float -) -> Union[float, np.ndarray]: - """ - Evaluate a first order linear model of the form y = m x + c. - - Arguments: - x: input location(s) on the x-axis - c: y-intercept of the linear model - m: gradient of the linear model - - Returns: - y: result y = m x + c, the same shape and type as x - - Examples: - >>> first_order_linear(0. , 1. , 0. ) - 1.0 - >>> first_order_linear(np.array([-1. , 0. , 1. ]), c=1.0, m=2.0) - array([-1., 1., 3.]) - """ - y = m * x + c - return y -``` - -*Pro-Tip: Write the docstring for your new high-level object before starting on the code. In particular, writing examples of how you expect it should be used can help clarify the right level of abstraction.* - -## Online Documentation - -Online Documentation is automatically generated using [Material for MkDocs](https://squidfunk.github.io/mkdocs-material/) based on docstrings in files in the `autora/` directory. - -### Commands - -Build and serve the documentation using the following commands: - -* `poetry run mkdocs serve` - Start the live-reloading docs server. -* `poetry run mkdocs build` - Build the documentation site. -* `poetry run mkdocs gh-deploy` - Build the documentation and serve at https://AutoResearch.github.io/AutoRA/ -* `poetry run mkdocs -h` - Print help message and exit. - -### Documentation layout -``` -mkdocs.yml # The configuration file for the documentation. -docs/ # Directory for static pages to be included in the documentation. - index.md # The documentation homepage. - ... # Other markdown pages, images and other files. -autora/ # The directory containing the source code. -``` -# Release Process - -The release process is automated using GitHub Actions. - -- Before you start, ensure that the tokens are up-to-date. If in doubt, try to create and publish a new release - candidate version of the package first. The tokens are stored as "organization secrets" enabled for the autora - repository, and are called: - - PYPI_TOKEN: a token from pypi.org with upload permissions on the AutoResearch/AutoRA project. - - ANACONDA_TOKEN: a token from anaconda.org with the following scopes on the AutoResearch organization: `repos conda - api:read api:write`. Current token expires on 2023-03-01. -- Update [conda recipe](./conda/autora/meta.yaml): - - dependencies, so that it matches [pyproject.toml](pyproject.toml). - - imports for testing – all modules should be listed. -- Trigger a new release from GitHub. - - Navigate to the repository's code tab at https://github.com/autoresearch/autora, - - Click "Releases", - - Click "Draft a new release", - - In the "Choose a tag" field, type the new semantic release number using the [PEP440 syntax](https://peps.python. - org/pep-0440/). The version number should be prefixed with a "v". - e.g. "v1.2.3" for a standard release, "v1.2.3a4" for an alpha release, "v1.2.3b5" for a beta release, - "v1.2.3rc6" for a release candidate, and then click "Create new tag on publish". - - Leave "Release title" empty. - - Click on "Generate Release notes". Check that the release notes match with the version number you have chosen – - breaking changes require a new major version number, e.g. v2.0.0, new features a minor version number, e.g. - v1.3.0 and fixes a bugfix number v1.2.4. If necessary, modify the version number you've chosen to be consistent - with the content of the release. - - Select whether this is a pre-release or a new "latest" release. It's a "pre-release" if there's an alpha, - beta, or release candidate number in the tag name, otherwise it's a new "latest" release. - - Click on "Publish release" -- GitHub actions will run to create and publish the PyPI and Anaconda packages, and publish the documentation. Check in - GitHub actions whether they run without errors and fix any errors which occur. diff --git a/autora/__init__.py b/autora/__init__.py deleted file mode 100644 index 0adc79c15..000000000 --- a/autora/__init__.py +++ /dev/null @@ -1,6 +0,0 @@ -import importlib.metadata - -try: - __version__ = importlib.metadata.version("autora") -except importlib.metadata.PackageNotFoundError: - __version__ = "source_repository" diff --git a/autora/cycle/__init__.py b/autora/cycle/__init__.py deleted file mode 100644 index f7682c7e4..000000000 --- a/autora/cycle/__init__.py +++ /dev/null @@ -1,8 +0,0 @@ -from .plot_utils import ( - cycle_default_score, - cycle_specified_score, - plot_cycle_score, - plot_results_panel_2d, - plot_results_panel_3d, -) -from .simple import SimpleCycle as Cycle diff --git a/autora/cycle/plot_utils.py b/autora/cycle/plot_utils.py deleted file mode 100644 index 0c6b88a9a..000000000 --- a/autora/cycle/plot_utils.py +++ /dev/null @@ -1,616 +0,0 @@ -import inspect -from itertools import product -from typing import Callable, List, Optional, Sequence, Tuple, Union - -import matplotlib.pyplot as plt -import numpy as np -import pandas as pd -from matplotlib import rcParams -from matplotlib.patches import Patch -from matplotlib.ticker import MaxNLocator - -from .simple import SimpleCycle as Cycle - -# Change default plot styles -controller_plotting_rc_context = { - "axes.spines.top": False, - "axes.spines.right": False, - "legend.frameon": False, -} - - -def _get_variable_index( - cycle: Cycle, -) -> Tuple[List[Tuple[int, str, str]], List[Tuple[int, str, str]]]: - """ - Extracts information about independent and dependent variables from the cycle object. - Returns a list of tuples of (index, name, units). The index is in reference to the column number - in the observed value arrays. - Args: - cycle: AER Cycle object that has been run - - Returns: Tuple of 2 lists of tuples - - """ - l_iv = [ - (i, s.name, s.units) - for i, s in enumerate(cycle.data.metadata.independent_variables) - ] - n_iv = len(l_iv) - l_dv = [ - (i + n_iv, s.name, s.units) - for i, s in enumerate(cycle.data.metadata.dependent_variables) - ] - return l_iv, l_dv - - -def _observed_to_df(cycle: Cycle) -> pd.DataFrame: - """ - Concatenates observation data of cycles into a single dataframe with a field "cycle" with the - cycle index. - Args: - cycle: AER Cycle object that has been run - - Returns: Dataframe - - """ - l_observations = cycle.data.observations - l_agg = [] - - for i, data in enumerate(l_observations): - l_agg.append(pd.DataFrame(data).assign(cycle=i)) - - df_return = pd.concat(l_agg) - - return df_return - - -def _min_max_observations(cycle: Cycle) -> List[Tuple[float, float]]: - """ - Returns minimum and maximum of observed values for each independent variable. - Args: - cycle: AER Cycle object that has been run - - Returns: List of tuples - - """ - l_return = [] - iv_index = range(len(cycle.data.metadata.independent_variables)) - l_observations = cycle.data.observations - # Get min and max of observation data - # Min and max by cycle - All IVs - l_mins = [np.min(s, axis=0) for s in l_observations] # Arrays by columns - l_maxs = [np.max(s, axis=0) for s in l_observations] - # Min and max for all cycles by IVs - for idx in iv_index: - glob_min = np.min([s[idx] for s in l_mins]) - glob_max = np.max([s[idx] for s in l_maxs]) - l_return.append((glob_min, glob_max)) - - return l_return - - -def _generate_condition_space(cycle: Cycle, steps: int = 50) -> np.array: - """ - Generates condition space based on the minimum and maximum of all observed data in AER Cycle. - Args: - cycle: AER Cycle object that has been run - steps: Number of steps to define the condition space - - Returns: np.array - - """ - l_min_max = _min_max_observations(cycle) - l_space = [] - - for min_max in l_min_max: - l_space.append(np.linspace(min_max[0], min_max[1], steps)) - - if len(l_space) > 1: - return np.array(list(product(*l_space))) - else: - return l_space[0].reshape(-1, 1) - - -def _generate_mesh_grid(cycle: Cycle, steps: int = 50) -> np.ndarray: - """ - Generates a mesh grid based on the minimum and maximum of all observed data in AER Cycle. - Args: - cycle: AER Cycle object that has been run - steps: Number of steps to define the condition space - - Returns: np.ndarray - - """ - l_min_max = _min_max_observations(cycle) - l_space = [] - - for min_max in l_min_max: - l_space.append(np.linspace(min_max[0], min_max[1], steps)) - - return np.meshgrid(*l_space) - - -def _theory_predict( - cycle: Cycle, conditions: Sequence, predict_proba: bool = False -) -> list: - """ - Gets theory predictions over conditions space and saves results of each cycle to a list. - Args: - cycle: AER Cycle object that has been run - conditions: Condition space. Should be an array of grouped conditions. - predict_proba: Use estimator.predict_proba method instead of estimator.predict. - - Returns: list - - """ - l_predictions = [] - for i, theory in enumerate(cycle.data.theories): - if not predict_proba: - l_predictions.append(theory.predict(conditions)) - else: - l_predictions.append(theory.predict_proba(conditions)) - - return l_predictions - - -def _check_replace_default_kw(default: dict, user: dict) -> dict: - """ - Combines the key/value pairs of two dictionaries, a default and user dictionary. Unique pairs - are selected and user pairs take precedent over default pairs if matching keywords. Also works - with nested dictionaries. - - Returns: dict - """ - # Copy dict 1 to return dict - d_return = default.copy() - # Loop by keys in dict 2 - for key in user.keys(): - # If not in dict 1 add to the return dict - if key not in default.keys(): - d_return.update({key: user[key]}) - else: - # If value is a dict, recurse to check nested dict - if isinstance(user[key], dict): - d_return.update( - {key: _check_replace_default_kw(default[key], user[key])} - ) - # If not a dict update the default value with the value from dict 2 - else: - d_return.update({key: user[key]}) - - return d_return - - -def plot_results_panel_2d( - cycle: Cycle, - iv_name: Optional[str] = None, - dv_name: Optional[str] = None, - steps: int = 50, - wrap: int = 4, - query: Optional[Union[List, slice]] = None, - subplot_kw: dict = {}, - scatter_previous_kw: dict = {}, - scatter_current_kw: dict = {}, - plot_theory_kw: dict = {}, -) -> plt.figure: - """ - Generates a multi-panel figure with 2D plots showing results of one AER cycle. - - Observed data is plotted as a scatter plot with the current cycle colored differently than - observed data from previous cycles. The current cycle's theory is plotted as a line over the - range of the observed data. - - Args: - cycle: AER Cycle object that has been run - iv_name: Independent variable name. Name should match the name instantiated in the cycle - object. Default will select the first. - dv_name: Single dependent variable name. Name should match the names instantiated in the - cycle object. Default will select the first DV. - steps: Number of steps to define the condition space to plot the theory. - wrap: Number of panels to appear in a row. Example: 9 panels with wrap=3 results in a - 3x3 grid. - query: Query which cycles to plot with either a List of indexes or a slice. The slice must - be constructed with the `slice()` function or `np.s_[]` index expression. - subplot_kw: Dictionary of keywords to pass to matplotlib 'subplot' function - scatter_previous_kw: Dictionary of keywords to pass to matplotlib 'scatter' function that - plots the data points from previous cycles. - scatter_current_kw: Dictionary of keywords to pass to matplotlib 'scatter' function that - plots the data points from the current cycle. - plot_theory_kw: Dictionary of keywords to pass to matplotlib 'plot' function that plots the - theory line. - - Returns: matplotlib figure - - """ - - # ---Figure and plot params--- - # Set defaults, check and add user supplied keywords - # Default keywords - subplot_kw_defaults = { - "gridspec_kw": {"bottom": 0.16}, - "sharex": True, - "sharey": True, - } - scatter_previous_defaults = { - "color": "black", - "s": 2, - "alpha": 0.6, - "label": "Previous Data", - } - scatter_current_defaults = { - "color": "tab:orange", - "s": 2, - "alpha": 0.6, - "label": "New Data", - } - line_kw_defaults = {"label": "Theory"} - # Combine default and user supplied keywords - d_kw = {} - for d1, d2, key in zip( - [ - subplot_kw_defaults, - scatter_previous_defaults, - scatter_current_defaults, - line_kw_defaults, - ], - [subplot_kw, scatter_previous_kw, scatter_current_kw, plot_theory_kw], - ["subplot_kw", "scatter_previous_kw", "scatter_current_kw", "plot_theory_kw"], - ): - assert isinstance(d1, dict) - assert isinstance(d2, dict) - d_kw[key] = _check_replace_default_kw(d1, d2) - - # ---Extract IVs and DV metadata and indexes--- - ivs, dvs = _get_variable_index(cycle) - if iv_name: - iv = [s for s in ivs if s[1] == iv_name][0] - else: - iv = [ivs[0]][0] - if dv_name: - dv = [s for s in dvs if s[1] == dv_name][0] - else: - dv = [dvs[0]][0] - iv_label = f"{iv[1]} {iv[2]}" - dv_label = f"{dv[1]} {dv[2]}" - - # Create a dataframe of observed data from cycle - df_observed = _observed_to_df(cycle) - - # Generate IV space - condition_space = _generate_condition_space(cycle, steps=steps) - - # Get theory predictions over space - l_predictions = _theory_predict(cycle, condition_space) - - # Cycle Indexing - cycle_idx = list(range(len(cycle.data.theories))) - if query: - if isinstance(query, list): - cycle_idx = [cycle_idx[s] for s in query] - elif isinstance(query, slice): - cycle_idx = cycle_idx[query] - - # Subplot configurations - n_cycles_to_plot = len(cycle_idx) - if n_cycles_to_plot < wrap: - shape = (1, n_cycles_to_plot) - else: - shape = (int(np.ceil(n_cycles_to_plot / wrap)), wrap) - - with plt.rc_context(controller_plotting_rc_context): - fig, axs = plt.subplots(*shape, **d_kw["subplot_kw"]) - # Place axis object in an array if plotting single panel - if shape == (1, 1): - axs = np.array([axs]) - - # Loop by panel - for i, ax in enumerate(axs.flat): - if i + 1 <= n_cycles_to_plot: - # Get index of cycle to plot - i_cycle = cycle_idx[i] - - # ---Plot observed data--- - # Independent variable values - x_vals = df_observed.loc[:, iv[0]] - # Dependent values masked by current cycle vs previous data - dv_previous = np.ma.masked_where( - df_observed["cycle"] >= i_cycle, df_observed[dv[0]] - ) - dv_current = np.ma.masked_where( - df_observed["cycle"] != i_cycle, df_observed[dv[0]] - ) - # Plotting scatter - ax.scatter(x_vals, dv_previous, **d_kw["scatter_previous_kw"]) - ax.scatter(x_vals, dv_current, **d_kw["scatter_current_kw"]) - - # ---Plot Theory--- - conditions = condition_space[:, iv[0]] - ax.plot(conditions, l_predictions[i_cycle], **d_kw["plot_theory_kw"]) - - # Label Panels - ax.text( - 0.05, - 1, - f"Cycle {i_cycle}", - ha="left", - va="top", - transform=ax.transAxes, - ) - - else: - ax.axis("off") - - # Super Labels - fig.supxlabel(iv_label, y=0.07) - fig.supylabel(dv_label) - - # Legend - fig.legend( - ["Previous Data", "New Data", "Theory"], - ncols=3, - bbox_to_anchor=(0.5, 0), - loc="lower center", - ) - - return fig - - -def plot_results_panel_3d( - cycle: Cycle, - iv_names: Optional[List[str]] = None, - dv_name: Optional[str] = None, - steps: int = 50, - wrap: int = 4, - view: Optional[Tuple[float, float]] = None, - subplot_kw: dict = {}, - scatter_previous_kw: dict = {}, - scatter_current_kw: dict = {}, - surface_kw: dict = {}, -) -> plt.figure: - """ - Generates a multi-panel figure with 3D plots showing results of one AER cycle. - - Observed data is plotted as a scatter plot with the current cycle colored differently than - observed data from previous cycles. The current cycle's theory is plotted as a line over the - range of the observed data. - - Args: - - cycle: AER Cycle object that has been run - iv_names: List of up to 2 independent variable names. Names should match the names - instantiated in the cycle object. Default will select up to the first two. - dv_name: Single DV name. Name should match the names instantiated in the cycle object. - Default will select the first DV - steps: Number of steps to define the condition space to plot the theory. - wrap: Number of panels to appear in a row. Example: 9 panels with wrap=3 results in a - 3x3 grid. - view: Tuple of elevation angle and azimuth to change the viewing angle of the plot. - subplot_kw: Dictionary of keywords to pass to matplotlib 'subplot' function - scatter_previous_kw: Dictionary of keywords to pass to matplotlib 'scatter' function that - plots the data points from previous cycles. - scatter_current_kw: Dictionary of keywords to pass to matplotlib 'scatter' function that - plots the data points from the current cycle. - surface_kw: Dictionary of keywords to pass to matplotlib 'plot_surface' function that plots - the theory plane. - - Returns: matplotlib figure - - """ - n_cycles = len(cycle.data.theories) - - # ---Figure and plot params--- - # Set defaults, check and add user supplied keywords - # Default keywords - subplot_kw_defaults = { - "subplot_kw": {"projection": "3d"}, - } - scatter_previous_defaults = {"color": "black", "s": 2, "label": "Previous Data"} - scatter_current_defaults = {"color": "tab:orange", "s": 2, "label": "New Data"} - surface_kw_defaults = {"alpha": 0.5, "label": "Theory"} - # Combine default and user supplied keywords - d_kw = {} - for d1, d2, key in zip( - [ - subplot_kw_defaults, - scatter_previous_defaults, - scatter_current_defaults, - surface_kw_defaults, - ], - [subplot_kw, scatter_previous_kw, scatter_current_kw, surface_kw], - ["subplot_kw", "scatter_previous_kw", "scatter_current_kw", "surface_kw"], - ): - assert isinstance(d1, dict) - assert isinstance(d2, dict) - d_kw[key] = _check_replace_default_kw(d1, d2) - - # ---Extract IVs and DV metadata and indexes--- - ivs, dvs = _get_variable_index(cycle) - if iv_names: - iv = [s for s in ivs if s[1] == iv_names] - else: - iv = ivs[:2] - if dv_name: - dv = [s for s in dvs if s[1] == dv_name][0] - else: - dv = [dvs[0]][0] - iv_labels = [f"{s[1]} {s[2]}" for s in iv] - dv_label = f"{dv[1]} {dv[2]}" - - # Create a dataframe of observed data from cycle - df_observed = _observed_to_df(cycle) - - # Generate IV Mesh Grid - x1, x2 = _generate_mesh_grid(cycle, steps=steps) - - # Get theory predictions over space - l_predictions = _theory_predict(cycle, np.column_stack((x1.ravel(), x2.ravel()))) - - # Subplot configurations - if n_cycles < wrap: - shape = (1, n_cycles) - else: - shape = (int(np.ceil(n_cycles / wrap)), wrap) - with plt.rc_context(controller_plotting_rc_context): - fig, axs = plt.subplots(*shape, **d_kw["subplot_kw"]) - - # Loop by panel - for i, ax in enumerate(axs.flat): - if i + 1 <= n_cycles: - - # ---Plot observed data--- - # Independent variable values - l_x = [df_observed.loc[:, s[0]] for s in iv] - # Dependent values masked by current cycle vs previous data - dv_previous = np.ma.masked_where( - df_observed["cycle"] >= i, df_observed[dv[0]] - ) - dv_current = np.ma.masked_where( - df_observed["cycle"] != i, df_observed[dv[0]] - ) - # Plotting scatter - ax.scatter(*l_x, dv_previous, **d_kw["scatter_previous_kw"]) - ax.scatter(*l_x, dv_current, **d_kw["scatter_current_kw"]) - - # ---Plot Theory--- - ax.plot_surface( - x1, x2, l_predictions[i].reshape(x1.shape), **d_kw["surface_kw"] - ) - # ---Labels--- - # Title - ax.set_title(f"Cycle {i}") - - # Axis - ax.set_xlabel(iv_labels[0]) - ax.set_ylabel(iv_labels[1]) - ax.set_zlabel(dv_label) - - # Viewing angle - if view: - ax.view_init(*view) - - else: - ax.axis("off") - - # Legend - handles, labels = axs.flatten()[0].get_legend_handles_labels() - legend_elements = [ - handles[0], - handles[1], - Patch(facecolor=handles[2].get_facecolors()[0]), - ] - fig.legend( - handles=legend_elements, - labels=labels, - ncols=3, - bbox_to_anchor=(0.5, 0), - loc="lower center", - ) - - return fig - - -def cycle_default_score(cycle: Cycle, x_vals: np.ndarray, y_true: np.ndarray): - """ - Calculates score for each cycle using the estimator's default scorer. - Args: - cycle: AER Cycle object that has been run - x_vals: Test dataset independent values - y_true: Test dataset dependent values - - Returns: - List of scores by cycle - """ - l_scores = [s.score(x_vals, y_true) for s in cycle.data.theories] - return l_scores - - -def cycle_specified_score( - scorer: Callable, cycle: Cycle, x_vals: np.ndarray, y_true: np.ndarray, **kwargs -): - """ - Calculates score for each cycle using specified sklearn scoring function. - Args: - scorer: sklearn scoring function - cycle: AER Cycle object that has been run - x_vals: Test dataset independent values - y_true: Test dataset dependent values - **kwargs: Keyword arguments to send to scoring function - - Returns: - - """ - # Get predictions - if "y_pred" in inspect.signature(scorer).parameters.keys(): - l_y_pred = _theory_predict(cycle, x_vals, predict_proba=False) - elif "y_score" in inspect.signature(scorer).parameters.keys(): - l_y_pred = _theory_predict(cycle, x_vals, predict_proba=True) - - # Score each cycle - l_scores = [] - for y_pred in l_y_pred: - l_scores.append(scorer(y_true, y_pred, **kwargs)) - - return l_scores - - -def plot_cycle_score( - cycle: Cycle, - X: np.ndarray, - y_true: np.ndarray, - scorer: Optional[Callable] = None, - x_label: str = "Cycle", - y_label: Optional[str] = None, - figsize: Tuple[float, float] = rcParams["figure.figsize"], - ylim: Optional[Tuple[float, float]] = None, - xlim: Optional[Tuple[float, float]] = None, - scorer_kw: dict = {}, - plot_kw: dict = {}, -) -> plt.Figure: - """ - Plots scoring metrics of cycle's theories given test data. - Args: - cycle: AER Cycle object that has been run - X: Test dataset independent values - y_true: Test dataset dependent values - scorer: sklearn scoring function (optional) - x_label: Label for x-axis - y_label: Label for y-axis - figsize: Optional figure size tuple in inches - ylim: Optional limits for the y-axis as a tuple (lower, upper) - xlim: Optional limits for the x-axis as a tuple (lower, upper) - scorer_kw: Dictionary of keywords for scoring function if scorer is supplied. - plot_kw: Dictionary of keywords to pass to matplotlib 'plot' function. - - Returns: - matplotlib.figure.Figure - """ - - # Use estimator's default scoring method if specific scorer is not supplied - if scorer is None: - l_scores = cycle_default_score(cycle, X, y_true) - else: - l_scores = cycle_specified_score(scorer, cycle, X, y_true, **scorer_kw) - - with plt.rc_context(controller_plotting_rc_context): - # Plotting - fig, ax = plt.subplots(figsize=figsize) - ax.plot(np.arange(len(cycle.data.theories)), l_scores, **plot_kw) - - # Adjusting axis limits - if ylim: - ax.set_ylim(*ylim) - if xlim: - ax.set_xlim(*xlim) - - # Labeling - ax.set_xlabel(x_label) - if y_label is None: - if scorer is not None: - y_label = scorer.__name__ - else: - y_label = "Score" - ax.set_ylabel(y_label) - ax.xaxis.set_major_locator(MaxNLocator(integer=True)) - - return fig diff --git a/autora/cycle/simple.py b/autora/cycle/simple.py deleted file mode 100644 index fb311b2e8..000000000 --- a/autora/cycle/simple.py +++ /dev/null @@ -1,527 +0,0 @@ -import copy -from collections.abc import Mapping -from dataclasses import dataclass, replace -from typing import Callable, Dict, Iterable, List, Optional - -import numpy as np -from sklearn.base import BaseEstimator - -from autora.experimentalist.pipeline import Pipeline -from autora.utils.dictionary import LazyDict -from autora.variable import VariableCollection - - -@dataclass(frozen=True) -class SimpleCycleData: - """An object passed between and updated by processing steps in the SimpleCycle.""" - - # Static - metadata: VariableCollection - - # Aggregates each cycle from the: - # ... Experimentalist - conditions: List[np.ndarray] - # ... Experiment Runner - observations: List[np.ndarray] - # ... Theorist - theories: List[BaseEstimator] - - -def _get_cycle_properties(data: SimpleCycleData): - """ - Examples: - Even with an empty data object, we can initialize the dictionary, - >>> cycle_properties = _get_cycle_properties(SimpleCycleData(metadata=VariableCollection(), - ... conditions=[], observations=[], theories=[])) - - ... but it will raise an exception if a value isn't yet available when we try to use it - >>> cycle_properties["%theories[-1]%"] # doctest: +ELLIPSIS - Traceback (most recent call last): - ... - IndexError: list index out of range - - Nevertheless, we can iterate through its keys no problem: - >>> [key for key in cycle_properties.keys()] # doctest: +NORMALIZE_WHITESPACE - ['%observations.ivs[-1]%', '%observations.dvs[-1]%', '%observations.ivs%', - '%observations.dvs%', '%theories[-1]%', '%theories%'] - - """ - - n_ivs = len(data.metadata.independent_variables) - n_dvs = len(data.metadata.dependent_variables) - cycle_property_dict = LazyDict( - { - "%observations.ivs[-1]%": lambda: data.observations[-1][:, 0:n_ivs], - "%observations.dvs[-1]%": lambda: data.observations[-1][:, n_ivs:], - "%observations.ivs%": lambda: np.row_stack( - [np.empty([0, n_ivs + n_dvs])] + data.observations - )[:, 0:n_ivs], - "%observations.dvs%": lambda: np.row_stack(data.observations)[:, n_ivs:], - "%theories[-1]%": lambda: data.theories[-1], - "%theories%": lambda: data.theories, - } - ) - return cycle_property_dict - - -class SimpleCycle: - """ - Runs an experimentalist, theorist and experiment runner in a loop. - - Once initialized, the `cycle` can be started using the `cycle.run` method - or by calling `next(cycle)`. - - The `.data` attribute is updated with the results. - - Attributes: - data (dataclass): an object which is updated during the cycle and has the following - properties: - - - `metadata` - - `conditions`: a list of np.ndarrays representing all of the IVs proposed by the - experimentalist - - `observations`: a list of np.ndarrays representing all of the IVs and DVs returned by - the experiment runner - - `theories`: a list of all the fitted theories (scikit-learn compatible estimators) - - params (dict): a nested dictionary with parameters for the cycle parts. - - `{ - "experimentalist": {}, - "theorist": {}, - "experiment_runner": {} - }` - - - Examples: - - ### Basic Usage - - Aim: Use the SimpleCycle to recover a simple ground truth theory from noisy data. - - >>> def ground_truth(x): - ... return x + 1 - - The space of allowed x values is the integers between 0 and 10 inclusive, - and we record the allowed output values as well. - >>> from autora.variable import VariableCollection, Variable - >>> metadata_0 = VariableCollection( - ... independent_variables=[Variable(name="x1", allowed_values=range(11))], - ... dependent_variables=[Variable(name="y", value_range=(-20, 20))], - ... ) - - The experimentalist is used to propose experiments. - Since the space of values is so restricted, we can just sample them all each time. - >>> from autora.experimentalist.pipeline import make_pipeline - >>> example_experimentalist = make_pipeline( - ... [metadata_0.independent_variables[0].allowed_values]) - - When we run a synthetic experiment, we get a reproducible noisy result: - >>> import numpy as np - >>> def get_example_synthetic_experiment_runner(): - ... rng = np.random.default_rng(seed=180) - ... def runner(x): - ... return ground_truth(x) + rng.normal(0, 0.1, x.shape) - ... return runner - >>> example_synthetic_experiment_runner = get_example_synthetic_experiment_runner() - >>> example_synthetic_experiment_runner(np.ndarray([1])) - array([2.04339546]) - - The theorist "tries" to work out the best theory. - We use a trivial scikit-learn regressor. - >>> from sklearn.linear_model import LinearRegression - >>> example_theorist = LinearRegression() - - We initialize the SimpleCycle with the metadata describing the domain of the theory, - the theorist, experimentalist and experiment runner, - as well as a monitor which will let us know which cycle we're currently on. - >>> cycle = SimpleCycle( - ... metadata=metadata_0, - ... theorist=example_theorist, - ... experimentalist=example_experimentalist, - ... experiment_runner=example_synthetic_experiment_runner, - ... monitor=lambda data: print(f"Generated {len(data.theories)} theories"), - ... ) - >>> cycle # doctest: +ELLIPSIS - - - We can run the cycle by calling the run method: - >>> cycle.run(num_cycles=3) # doctest: +ELLIPSIS - Generated 1 theories - Generated 2 theories - Generated 3 theories - - - We can now interrogate the results. The first set of conditions which went into the - experiment runner were: - >>> cycle.data.conditions[0] - array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) - - The observations include the conditions and the results: - >>> cycle.data.observations[0] - array([[ 0. , 0.92675345], - [ 1. , 1.89519928], - [ 2. , 3.08746571], - [ 3. , 3.93023943], - [ 4. , 4.95429102], - [ 5. , 6.04763988], - [ 6. , 7.20770574], - [ 7. , 7.85681519], - [ 8. , 9.05735823], - [ 9. , 10.18713406], - [10. , 10.88517906]]) - - In the third cycle (index = 2) the first and last values are different again: - >>> cycle.data.observations[2][[0,-1]] - array([[ 0. , 1.08559827], - [10. , 11.08179553]]) - - The best fit theory after the first cycle is: - >>> cycle.data.theories[0] - LinearRegression() - - >>> def report_linear_fit(m: LinearRegression, precision=4): - ... s = f"y = {np.round(m.coef_[0].item(), precision)} x " \\ - ... f"+ {np.round(m.intercept_.item(), 4)}" - ... return s - >>> report_linear_fit(cycle.data.theories[0]) - 'y = 1.0089 x + 0.9589' - - The best fit theory after all the cycles, including all the data, is: - >>> report_linear_fit(cycle.data.theories[-1]) - 'y = 0.9989 x + 1.0292' - - This is close to the ground truth theory of x -> (x + 1) - - We can also run the cycle with more control over the execution flow: - >>> next(cycle) # doctest: +ELLIPSIS - Generated 4 theories - - - >>> next(cycle) # doctest: +ELLIPSIS - Generated 5 theories - - - >>> next(cycle) # doctest: +ELLIPSIS - Generated 6 theories - - - We can continue to run the cycle as long as we like, - with a simple arbitrary stopping condition like the number of theories generated: - >>> from itertools import takewhile - >>> _ = list(takewhile(lambda c: len(c.data.theories) < 9, cycle)) - Generated 7 theories - Generated 8 theories - Generated 9 theories - - ... or the precision (here we keep iterating while the difference between the gradients - of the second-last and last cycle is larger than 1x10^-3). - >>> _ = list( - ... takewhile( - ... lambda c: np.abs(c.data.theories[-1].coef_.item() - - ... c.data.theories[-2].coef_.item()) > 1e-3, - ... cycle - ... ) - ... ) - Generated 10 theories - Generated 11 theories - - ... or continue to run as long as we like: - >>> _ = cycle.run(num_cycles=100) # doctest: +ELLIPSIS - Generated 12 theories - ... - Generated 111 theories - - ### Passing Static Parameters - - It's easy to pass parameters to the cycle components, if there are any needed. - Here we have an experimentalist which takes a parameter: - >>> uniform_random_rng = np.random.default_rng(180) - >>> def uniform_random_sampler(n): - ... return uniform_random_rng.uniform(low=0, high=11, size=n) - >>> example_experimentalist_with_parameters = make_pipeline([uniform_random_sampler]) - - The cycle can handle that using the `params` keyword: - >>> cycle_with_parameters = SimpleCycle( - ... metadata=metadata_0, - ... theorist=example_theorist, - ... experimentalist=example_experimentalist_with_parameters, - ... experiment_runner=example_synthetic_experiment_runner, - ... params={"experimentalist": {"uniform_random_sampler": {"n": 7}}} - ... ) - >>> _ = cycle_with_parameters.run() - >>> cycle_with_parameters.data.conditions[-1].flatten() - array([6.33661987, 7.34916618, 6.08596494, 2.28566582, 1.9553974 , - 5.80023149, 3.27007909]) - - For the next cycle, if we wish, we can change the parameter value: - >>> cycle_with_parameters.params["experimentalist"]["uniform_random_sampler"]\\ - ... ["n"] = 2 - >>> _ = cycle_with_parameters.run() - >>> cycle_with_parameters.data.conditions[-1].flatten() - array([10.5838232 , 9.45666031]) - - ### Accessing "Cycle Properties" - - Some experimentalists, experiment runners and theorists require access to the values - created during the cycle execution, e.g. experimentalists which require access - to the current best theory or the observed data. These data update each cycle, and - so cannot easily be set using simple `params`. - - For this case, it is possible to use "cycle properties" in the `params` dictionary. These - are the following strings, which will be replaced during execution by their respective - current values: - - - `"%observations.ivs[-1]%"`: the last observed independent variables - - `"%observations.dvs[-1]%"`: the last observed dependent variables - - `"%observations.ivs%"`: all the observed independent variables, - concatenated into a single array - - `"%observations.dvs%"`: all the observed dependent variables, - concatenated into a single array - - `"%theories[-1]%"`: the last fitted theorist - - `"%theories%"`: all the fitted theorists - - In the following example, we use the `"observations.ivs"` cycle property for an - experimentalist which excludes those conditions which have - already been seen. - - >>> metadata_1 = VariableCollection( - ... independent_variables=[Variable(name="x1", allowed_values=range(10))], - ... dependent_variables=[Variable(name="y")], - ... ) - >>> random_sampler_rng = np.random.default_rng(seed=180) - >>> def custom_random_sampler(conditions, n): - ... sampled_conditions = random_sampler_rng.choice(conditions, size=n, replace=False) - ... return sampled_conditions - >>> def exclude_conditions(conditions, excluded_conditions): - ... remaining_conditions = list(set(conditions) - set(excluded_conditions.flatten())) - ... return remaining_conditions - >>> unobserved_data_experimentalist = make_pipeline([ - ... metadata_1.independent_variables[0].allowed_values, - ... exclude_conditions, - ... custom_random_sampler - ... ] - ... ) - >>> cycle_with_cycle_properties = SimpleCycle( - ... metadata=metadata_1, - ... theorist=example_theorist, - ... experimentalist=unobserved_data_experimentalist, - ... experiment_runner=example_synthetic_experiment_runner, - ... params={ - ... "experimentalist": { - ... "exclude_conditions": {"excluded_conditions": "%observations.ivs%"}, - ... "custom_random_sampler": {"n": 1} - ... } - ... } - ... ) - - Now we can run the cycler to generate conditions and run experiments. The first time round, - we have the full set of 10 possible conditions to select from, and we select "2" at random: - >>> _ = cycle_with_cycle_properties.run() - >>> cycle_with_cycle_properties.data.conditions[-1] - array([2]) - - We can continue to run the cycler, each time we add more to the list of "excluded" options: - >>> _ = cycle_with_cycle_properties.run(num_cycles=5) - >>> cycle_with_cycle_properties.data.conditions - [array([2]), array([6]), array([5]), array([7]), array([3]), array([4])] - - By using the monitor callback, we can investigate what's going on with the cycle properties: - >>> cycle_with_cycle_properties.monitor = lambda data: print( - ... _get_cycle_properties(data)["%observations.ivs%"].flatten() - ... ) - - The monitor evaluates at the end of each cycle - and shows that we've added a new observed IV each step - >>> _ = cycle_with_cycle_properties.run() - [2. 6. 5. 7. 3. 4. 9.] - >>> _ = cycle_with_cycle_properties.run() - [2. 6. 5. 7. 3. 4. 9. 0.] - - We deactivate the monitor by making it "None" again. - >>> cycle_with_cycle_properties.monitor = None - - We can continue until we've sampled all of the options: - >>> _ = cycle_with_cycle_properties.run(num_cycles=2) - >>> cycle_with_cycle_properties.data.conditions # doctest: +NORMALIZE_WHITESPACE - [array([2]), array([6]), array([5]), array([7]), array([3]), \ - array([4]), array([9]), array([0]), array([8]), array([1])] - - If we try to evaluate it again, the experimentalist fails, as there aren't any more - conditions which are available: - >>> cycle_with_cycle_properties.run() # doctest: +ELLIPSIS - Traceback (most recent call last): - ... - ValueError: a cannot be empty unless no samples are taken - - """ - - def __init__( - self, - metadata: VariableCollection, - theorist, - experimentalist, - experiment_runner, - monitor: Optional[Callable[[SimpleCycleData], None]] = None, - params: Optional[Dict] = None, - ): - """ - Args: - metadata: a description of the dependent and independent variables - theorist: a scikit-learn-compatible estimator - experimentalist: an autora.experimentalist.Pipeline - experiment_runner: a function to map independent variables onto observed dependent - variables - monitor: a function which gets read-only access to the `data` attribute at the end of - each cycle. - params: a nested dictionary with parameters to be passed to the parts of the cycle. - E.g. if the experimentalist had a step named "pool" which took an argument "n", - which you wanted to set to the value 30, then params would be set to this: - `{"experimentalist": {"pool": {"n": 30}}}` - """ - - self.theorist = theorist - self.experimentalist = experimentalist - self.experiment_runner = experiment_runner - self.monitor = monitor - if params is None: - params = dict() - self.params = params - - self.data = SimpleCycleData( - metadata=metadata, - conditions=[], - observations=[], - theories=[], - ) - - def run(self, num_cycles: int = 1): - for i in range(num_cycles): - next(self) - return self - - def __next__(self): - assert ( - "experiment_runner" not in self.params - ), "experiment_runner cannot yet accept cycle properties" - assert ( - "theorist" not in self.params - ), "theorist cannot yet accept cycle properties" - - data = self.data - params_with_cycle_properties = _resolve_cycle_properties( - self.params, _get_cycle_properties(self.data) - ) - - data = self._experimentalist_callback( - self.experimentalist, - data, - params_with_cycle_properties.get("experimentalist", dict()), - ) - data = self._experiment_runner_callback(self.experiment_runner, data) - data = self._theorist_callback(self.theorist, data) - self._monitor_callback(data) - self.data = data - - return self - - def __iter__(self): - return self - - @staticmethod - def _experimentalist_callback( - experimentalist: Pipeline, data_in: SimpleCycleData, params: dict - ): - new_conditions = experimentalist(**params) - if isinstance(new_conditions, Iterable): - # If the pipeline gives us an iterable, we need to make it into a concrete array. - # We can't move this logic to the Pipeline, because the pipeline doesn't know whether - # it's within another pipeline and whether it should convert the iterable to a - # concrete array. - new_conditions_values = list(new_conditions) - new_conditions_array = np.array(new_conditions_values) - else: - raise NotImplementedError(f"Object {new_conditions} can't be handled yet.") - - assert isinstance( - new_conditions_array, np.ndarray - ) # Check the object is bounded - data_out = replace( - data_in, - conditions=data_in.conditions + [new_conditions_array], - ) - return data_out - - @staticmethod - def _experiment_runner_callback( - experiment_runner: Callable, data_in: SimpleCycleData - ): - x = data_in.conditions[-1] - y = experiment_runner(x) - new_observations = np.column_stack([x, y]) - data_out = replace( - data_in, observations=data_in.observations + [new_observations] - ) - return data_out - - @staticmethod - def _theorist_callback(theorist, data_in: SimpleCycleData): - all_observations = np.row_stack(data_in.observations) - n_xs = len( - data_in.metadata.independent_variables - ) # The number of independent variables - x, y = all_observations[:, :n_xs], all_observations[:, n_xs:] - if y.shape[1] == 1: - y = y.ravel() - new_theorist = copy.deepcopy(theorist) - new_theorist.fit(x, y) - data_out = replace( - data_in, - theories=data_in.theories + [new_theorist], - ) - return data_out - - def _monitor_callback(self, data: SimpleCycleData): - if self.monitor is not None: - self.monitor(data) - - -def _resolve_cycle_properties(params: Dict, cycle_properties: Mapping): - """ - Resolve "cycle properties" inside a nested dictionary. - - In this context, a "cycle property" is a string which is meant to be replaced by a - different value before the dictionary is used. - - Args: - params: a (nested) dictionary of keys and values, where some values might be - "cycle property names" - cycle_properties: a dictionary of "cycle property names" and their "real values" - - Returns: a (nested) dictionary where "cycle property names" are replaced by the "real values" - - Examples: - - >>> params_0 = {"key": "%foo%"} - >>> cycle_properties_0 = {"%foo%": 180} - >>> _resolve_cycle_properties(params_0, cycle_properties_0) - {'key': 180} - - >>> params_1 = {"key": "%bar%", "nested_dict": {"inner_key": "%foobar%"}} - >>> cycle_properties_1 = {"%bar%": 1, "%foobar%": 2} - >>> _resolve_cycle_properties(params_1, cycle_properties_1) - {'key': 1, 'nested_dict': {'inner_key': 2}} - - """ - params_ = copy.copy(params) - for key, value in params_.items(): - if isinstance(value, dict): - params_[key] = _resolve_cycle_properties(value, cycle_properties) - elif ( - isinstance(value, str) and value in cycle_properties - ): # value is a key in the cycle_properties dictionary - params_[key] = cycle_properties[value] - else: - pass # no change needed - - return params_ diff --git a/autora/experimentalist/__init__.py b/autora/experimentalist/__init__.py deleted file mode 100644 index e69de29bb..000000000 diff --git a/autora/experimentalist/filter.py b/autora/experimentalist/filter.py deleted file mode 100644 index 58a9139cd..000000000 --- a/autora/experimentalist/filter.py +++ /dev/null @@ -1,128 +0,0 @@ -from enum import Enum -from typing import Callable, Iterable, Tuple - -import numpy as np - - -def weber_filter(values): - return filter(lambda s: s[0] <= s[1], values) - - -def train_test_filter( - seed: int = 180, train_p: float = 0.5 -) -> Tuple[Callable[[Iterable], Iterable], Callable[[Iterable], Iterable]]: - """ - A pipeline filter which pseudorandomly assigns values from the input into "train" or "test" - groups. This is particularly useful when working with streams of data of potentially - unbounded length. - - This isn't a great method for small datasets, as it doesn't guarantee producing training - and test sets which are as close as possible to the specified desired proportions. - Consider using the scikit-learn `train_test_split` for cases where it's practical to - enumerate the full dataset in advance. - - Args: - seed: random number generator seeding value - train_p: proportion of data which go into the training set. A float between 0 and 1. - - Returns: - a tuple of callables `(train_filter, test_filter)` which split the input data - into two complementary streams. - - - Examples: - We can create complementary train and test filters using the function: - >>> train_filter, test_filter = train_test_filter(train_p=0.6, seed=180) - - The `train_filter` generates a sequence of ~60% of the input list – - in this case, 15 of 20 datapoints. - Note that the correct split would be 12 of 20 data points. - Again, for data with bounded length it is advisable - to use scikit-learn `train_test_split` instead. - >>> list(train_filter(range(20))) - [0, 2, 3, 4, 5, 6, 9, 10, 11, 12, 15, 16, 17, 18, 19] - - When we run the `test_filter`, it fills in the gaps, giving us the remaining 5 values: - >>> list(test_filter(range(20))) - [1, 7, 8, 13, 14] - - We can continue to generate new values for as long as we like using the same filter and the - continuation of the input range: - >>> list(train_filter(range(20, 40))) - [20, 22, 23, 27, 28, 29, 30, 31, 32, 33, 34, 36, 37, 38, 39] - - ... and some more. - >>> list(train_filter(range(40, 50))) - [41, 42, 44, 45, 46, 49] - - As the number of samples grows, the fraction in the train and test sets - will approach `train_p` and `1 - train_p`. - - The test_filter fills in the gaps again. - >>> list(test_filter(range(20, 30))) - [21, 24, 25, 26] - - If you rerun the *same* test_filter on a fresh range, then the results will be different - to the first time around: - >>> list(test_filter(range(20))) - [5, 10, 13, 17, 18] - - ... but if you regenerate the test_filter, it'll reproduce the original sequence - >>> _, test_filter_regenerated = train_test_filter(train_p=0.6, seed=180) - >>> list(test_filter_regenerated(range(20))) - [1, 7, 8, 13, 14] - - It also works on tuple-valued lists: - >>> from itertools import product - >>> train_filter_tuple, test_filter_tuple = train_test_filter(train_p=0.3, seed=42) - >>> list(test_filter_tuple(product(["a", "b"], [1, 2, 3]))) - [('a', 1), ('a', 2), ('a', 3), ('b', 1), ('b', 3)] - - >>> list(train_filter_tuple(product(["a","b"], [1,2,3]))) - [('b', 2)] - - >>> from itertools import count, takewhile - >>> train_filter_unbounded, test_filter_unbounded = train_test_filter(train_p=0.5, seed=21) - - >>> list(takewhile(lambda s: s < 90, count(79))) - [79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89] - - >>> train_pool = train_filter_unbounded(count(79)) - >>> list(takewhile(lambda s: s < 90, train_pool)) - [82, 85, 86, 89] - - >>> test_pool = test_filter_unbounded(count(79)) - >>> list(takewhile(lambda s: s < 90, test_pool)) - [79, 80, 81, 83, 84, 87, 88] - - >>> list(takewhile(lambda s: s < 110, test_pool)) - [91, 93, 94, 97, 100, 105, 106, 109] - - """ - - test_p = 1 - train_p - - _TrainTest = Enum("_TrainTest", ["train", "test"]) - - def train_test_stream(): - """Generates a pseudorandom stream of _TrainTest.train and _TrainTest.test.""" - rng = np.random.default_rng(seed) - while True: - yield rng.choice([_TrainTest.train, _TrainTest.test], p=(train_p, test_p)) - - def _factory(allow): - """Factory to make complementary generators which split their input - corresponding to the values of the pseudorandom train_test_stream.""" - _stream = train_test_stream() - - def _generator(values): - """Generator which yields items from the `values` depending on - whether the corresponding item from the `_stream` - matches the `allow` parameter.""" - for v, train_test in zip(values, _stream): - if train_test == allow: - yield v - - return _generator - - return _factory(_TrainTest.train), _factory(_TrainTest.test) diff --git a/autora/experimentalist/pipeline.py b/autora/experimentalist/pipeline.py deleted file mode 100644 index de76c450e..000000000 --- a/autora/experimentalist/pipeline.py +++ /dev/null @@ -1,495 +0,0 @@ -""" -Provides tools to chain functions used to create experiment sequences. -""" -from __future__ import annotations - -import copy -from itertools import chain -from typing import ( - Any, - Dict, - Iterable, - List, - Literal, - Optional, - Protocol, - Sequence, - Tuple, - Union, - get_args, - runtime_checkable, -) - - -@runtime_checkable -class Pool(Protocol): - """Creates an experimental sequence from scratch.""" - - def __call__(self) -> _ExperimentalSequence: - ... - - -@runtime_checkable -class Pipe(Protocol): - """Takes in an _ExperimentalSequence and modifies it before returning it.""" - - def __call__(self, ex: _ExperimentalSequence) -> _ExperimentalSequence: - ... - - -_StepType = Tuple[str, Union[Pool, Pipe, Iterable]] -_StepType.__doc__ = ( - "A Pipeline step's name and generating object, as tuple(name, pipeline_piece)." -) - -PARAM_DIVIDER = "__" - - -class Pipeline: - """ - Processes ("pipelines") a series of ExperimentalSequences through a pipeline. - - Examples: - A pipeline which filters even values 0 to 9: - >>> p = Pipeline( - ... [("is_even", lambda values: filter(lambda i: i % 2 == 0, values))] # a "pipe" function - ... ) - >>> list(p(range(10))) - [0, 2, 4, 6, 8] - - A pipeline which filters for square, odd numbers: - >>> from math import sqrt - >>> p = Pipeline([ - ... ("is_odd", lambda values: filter(lambda i: i % 2 != 0, values)), - ... ("is_sqrt", lambda values: filter(lambda i: sqrt(i) % 1 == 0., values)) - ... ]) - >>> list(p(range(100))) - [1, 9, 25, 49, 81] - - - >>> from itertools import product - >>> Pipeline([("pool", lambda: product(range(5), ["a", "b"]))]) # doctest: +ELLIPSIS - Pipeline(steps=[('pool', at 0x...>)], params={}) - - >>> Pipeline([ - ... ("pool", lambda: product(range(5), ["a", "b"])), - ... ("filter", lambda values: filter(lambda i: i[0] % 2 == 0, values)) - ... ]) # doctest: +ELLIPSIS +NORMALIZE_WHITESPACE - Pipeline(steps=[('pool', at 0x...>), \ - ('filter', at 0x...>)], \ - params={}) - - >>> pipeline = Pipeline([ - ... ("pool", lambda maximum: product(range(maximum), ["a", "b"])), - ... ("filter", lambda values, divisor: filter(lambda i: i[0] % divisor == 0, values)) - ... ] , - ... params = {"pool": {"maximum":5}, "filter": {"divisor": 2}}) - >>> pipeline # doctest: +ELLIPSIS +NORMALIZE_WHITESPACE - Pipeline(steps=[('pool', at 0x...>), \ - ('filter', at 0x...>)], \ - params={'pool': {'maximum': 5}, 'filter': {'divisor': 2}}) - >>> list(pipeline.run()) - [(0, 'a'), (0, 'b'), (2, 'a'), (2, 'b'), (4, 'a'), (4, 'b')] - - >>> pipeline.params = {"pool": {"maximum":7}, "filter": {"divisor": 3}} - >>> list(pipeline()) - [(0, 'a'), (0, 'b'), (3, 'a'), (3, 'b'), (6, 'a'), (6, 'b')] - - >>> pipeline.params = {"pool": {"maximum":7}} - >>> list(pipeline()) # doctest: +ELLIPSIS - Traceback (most recent call last): - ... - TypeError: () missing 1 required positional argument: 'divisor' - - - """ - - def __init__( - self, - steps: Optional[Sequence[_StepType]] = None, - params: Optional[Dict[str, Any]] = None, - ): - """Initialize the pipeline with a series of Pipe objects.""" - if steps is None: - steps = list() - self.steps = steps - - if params is None: - params = dict() - self.params = params - - def __repr__(self): - return f"{self.__class__.__name__}(steps={self.steps}, params={self.params})" - - def __call__( - self, - ex: Optional[_ExperimentalSequence] = None, - **params, - ) -> _ExperimentalSequence: - """Successively pass the input values through the Pipe.""" - - # Initialize the parameters objects. - merged_params = self._merge_params_with_self_params(params) - - try: - # Check we have steps to use - assert len(self.steps) > 0 - except AssertionError: - # If the pipeline doesn't have any steps... - if ex is not None: - # ...the output is the input - return ex - elif ex is None: - # ... unless the input was None, in which case it's an emtpy list - return [] - - # Make an iterator from the steps, so that we can be sure to only go through them once - # (Otherwise if we handle the "pool" as a special case, we have to track our starting point) - pipes_iterator = iter(self.steps) - - # Initialize our results object - if ex is None: - # ... there's no input, so presumably the first element in the steps is a pool - # which should generate our initial values. - name, pool = next(pipes_iterator) - if isinstance(pool, Pool): - # Here, the pool is a Pool callable, which we can pass parameters. - all_params_for_pool = merged_params.get(name, dict()) - results = [pool(**all_params_for_pool)] - elif isinstance(pool, Iterable): - # Otherwise, the pool should be an iterable which we can just use as is. - results = [pool] - - else: - # ... there's some input, so we can use that as the initial value - results = [ex] - - # Run the successive steps over the last result - for name, pipe in pipes_iterator: - assert isinstance(pipe, Pipe) - all_params_for_pipe = merged_params.get(name, dict()) - results.append(pipe(results[-1], **all_params_for_pipe)) - - return results[-1] - - def _merge_params_with_self_params(self, params): - pipeline_params = _parse_params_to_nested_dict( - self.params, divider=PARAM_DIVIDER - ) - call_params = _parse_params_to_nested_dict(params, divider=PARAM_DIVIDER) - merged_params = _merge_dicts(pipeline_params, call_params) - return merged_params - - run = __call__ - - -def _merge_dicts(a: dict, b: dict): - """ - merges b into a. - - Args: - a: the "base" dictionary - b: the "update" dictionary which takes precendence - - Returns: - - Originally from https://stackoverflow.com/a/7205107, modified for AER to allow overwriting. - - Examples: - Non-conflicting dictionaries are merged "side-by-side" - >>> _merge_dicts({1:{"a":"A"},2:{"b":"B"}}, {2:{"c":"C"},3:{"d":"D"}}) - {1: {'a': 'A'}, 2: {'b': 'B', 'c': 'C'}, 3: {'d': 'D'}} - - With conflicting dictionaries, the second dictionary takes precedence - >>> _merge_dicts( - ... {"l1_a": {"l2_1": {"l3_alpha": "from_first"}}}, - ... {"l1_a": {"l2_1": {"l3_alpha": "from_second"}}}) - {'l1_a': {'l2_1': {'l3_alpha': 'from_second'}}} - - Again, with non-conflicting dictionaries at the lower level - >>> _merge_dicts( - ... {"l1_a": {"l2_1": {"l3_alpha": "from_first"}}}, - ... {"l1_a": {"l2_1": {"l3_beta": "from_second"}}}) - {'l1_a': {'l2_1': {'l3_alpha': 'from_first', 'l3_beta': 'from_second'}}} - - >>> _merge_dicts( - ... {"l1_a": {"l2_1": {"l3_alpha": "from_first", "l3_beta": "from_first"}}}, - ... {"l1_a": {"l2_1": { "l3_beta": "from_second"}}}) - {'l1_a': {'l2_1': {'l3_alpha': 'from_first', 'l3_beta': 'from_second'}}} - - """ - a_, b_ = dict(a), dict(b) - - for key in b_: - if key in a_: - if isinstance(a_[key], dict) and isinstance(b_[key], dict): - a_[key] = _merge_dicts(a_[key], b_[key]) - elif a_[key] != b_[key]: - a_[key] = b_[key] - else: - pass - else: - a_[key] = b_[key] - return a_ - - -class PipelineUnion(Pipeline): - """ - Run several Pipes in parallel and concatenate all their results. - - Examples: - You can use the ParallelPipeline to parallelize a group of poolers: - >>> union_pipeline_0 = PipelineUnion([ - ... ("pool_1", make_pipeline([range(5)])), - ... ("pool_2", make_pipeline([range(25, 30)])), - ... ] - ... ) - >>> list(union_pipeline_0.run()) - [0, 1, 2, 3, 4, 25, 26, 27, 28, 29] - - >>> union_pipeline_1 = PipelineUnion([ - ... ("pool_1", range(5)), - ... ("pool_2", range(25, 30)), - ... ] - ... ) - >>> list(union_pipeline_1.run()) - [0, 1, 2, 3, 4, 25, 26, 27, 28, 29] - - You can use the ParallelPipeline to parallelize a group of pipes – each of which gets - the same input. - >>> pipeline_with_embedded_union = Pipeline([ - ... ("pool", range(22)), - ... ("filters", PipelineUnion([ - ... ("div_5_filter", lambda x: filter(lambda i: i % 5 == 0, x)), - ... ("div_7_filter", lambda x: filter(lambda i: i % 7 == 0, x)) - ... ])) - ... ]) - >>> list(pipeline_with_embedded_union.run()) - [0, 5, 10, 15, 20, 0, 7, 14, 21] - - """ - - def __call__( - self, - ex: Optional[_ExperimentalSequence] = None, - **params, - ) -> _ExperimentalSequence: - """Pass the input values in parallel through the steps.""" - - # Initialize the parameters objects. - merged_params = self._merge_params_with_self_params(params) - - results = [] - - # Run the parallel steps over the input - for name, pipe in self.steps: - all_params_for_step = merged_params.get(name, dict()) - if ex is None: - if isinstance(pipe, Pool): - results.append(pipe(**all_params_for_step)) - elif isinstance(pipe, Iterable): - results.append(pipe) - else: - raise NotImplementedError( - f"{pipe=} cannot be used in the PipelineUnion" - ) - else: - assert isinstance( - pipe, Pipe - ), f"{pipe=} is incompatible with the Pipe interface" - results.append(pipe(ex, **all_params_for_step)) - - union_results = chain.from_iterable(results) - - return union_results - - run = __call__ - - -def _parse_params_to_nested_dict(params_dict: Dict, divider: str): - """ - Converts a dictionary with a single level to a multi-level nested dictionary. - - Examples: - >>> _parse_params_to_nested_dict({"a": 1}, divider="__") - {'a': 1} - >>> _parse_params_to_nested_dict({"a__b": 1, "a__c": 2}, divider="__") - {'a': {'b': 1, 'c': 2}} - >>> _parse_params_to_nested_dict( - ... {"a__b__alpha": 1, "a__b__beta": 2, "a__c__gamma": 3}, - ... divider="__") - {'a': {'b': {'alpha': 1, 'beta': 2}, 'c': {'gamma': 3}}} - - >>> _parse_params_to_nested_dict( - ... {"a:b:alpha": 1, "a:b:beta": 2, "a:c:gamma": 3}, - ... divider=":") - {'a': {'b': {'alpha': 1, 'beta': 2}, 'c': {'gamma': 3}}} - """ - nested_dictionary: dict = copy.copy(params_dict) - for key in params_dict.keys(): - if divider in key: - value = nested_dictionary.pop(key) - new_key, new_subkey = key.split(divider, 1) - subdictionary = nested_dictionary.get(new_key, {}) - subdictionary.update({new_subkey: value}) - nested_dictionary[new_key] = subdictionary - - for key, value in nested_dictionary.items(): - if isinstance(value, dict): - nested_dictionary[key] = _parse_params_to_nested_dict( - value, divider=divider - ) - - return nested_dictionary - - -def make_pipeline( - steps: Optional[Sequence[Union[Pool, Pipe]]] = None, - params: Optional[Dict[str, Any]] = None, - kind: Literal["serial", "union"] = "serial", -) -> Pipeline: - """ - A factory function to make pipeline objects. - - The pipe objects' names will be set to the lowercase of their types, plus an index - starting from 0 for non-unique names. - - Args: - steps: a sequence of Pipe-compatible objects - params: a dictionary of parameters passed to each Pipe by its inferred name - kind: whether the steps should run in "serial", passing data from one to the next, - or in "union", where all the steps get the same data and the output is the union - of all the results. - - Returns: - A pipeline object - - Examples: - - You can create pipelines using purely anonymous functions: - >>> from itertools import product - >>> make_pipeline([lambda: product(range(5), ["a", "b"])]) # doctest: +ELLIPSIS - Pipeline(steps=[('', at 0x...>)], params={}) - - You can create pipelines with normal functions. - >>> def ab_pool(maximum=5): return product(range(maximum), ["a", "b"]) - >>> def even_filter(values): return filter(lambda i: i[0] % 2 == 0, values) - >>> make_pipeline([ab_pool, even_filter]) # doctest: +ELLIPSIS +NORMALIZE_WHITESPACE - Pipeline(steps=[('ab_pool', ), \ - ('even_filter', )], params={}) - - You can create pipelines with generators as their first elements functions. - >>> ab_pool_gen = product(range(3), ["a", "b"]) - >>> pl = make_pipeline([ab_pool_gen, even_filter]) - >>> pl # doctest: +ELLIPSIS +NORMALIZE_WHITESPACE - Pipeline(steps=[('step', ), - ('even_filter', )], params={}) - >>> list(pl.run()) - [(0, 'a'), (0, 'b'), (2, 'a'), (2, 'b')] - - You can pass parameters into the different steps of the pl using the "params" - argument: - >>> def divisor_filter(x, divisor): return filter(lambda i: i[0] % divisor == 0, x) - >>> pl = make_pipeline([ab_pool, divisor_filter], - ... params = {"ab_pool": {"maximum":5}, "divisor_filter": {"divisor": 2}}) - >>> pl # doctest: +ELLIPSIS +NORMALIZE_WHITESPACE - Pipeline(steps=[('ab_pool', ), \ - ('divisor_filter', )], \ - params={'ab_pool': {'maximum': 5}, 'divisor_filter': {'divisor': 2}}) - - You can evaluate the pipeline means calling its `run` method: - >>> list(pl.run()) - [(0, 'a'), (0, 'b'), (2, 'a'), (2, 'b'), (4, 'a'), (4, 'b')] - - ... or calling it directly: - >>> list(pl()) - [(0, 'a'), (0, 'b'), (2, 'a'), (2, 'b'), (4, 'a'), (4, 'b')] - - You can update the parameters and evaluate again, giving different results: - >>> pl.params = {"ab_pool": {"maximum": 7}, "divisor_filter": {"divisor": 3}} - >>> list(pl()) - [(0, 'a'), (0, 'b'), (3, 'a'), (3, 'b'), (6, 'a'), (6, 'b')] - - If the pipeline needs parameters, then removing them will break the pipeline: - >>> pl.params = {} - >>> list(pl()) # doctest: +ELLIPSIS - Traceback (most recent call last): - ... - TypeError: divisor_filter() missing 1 required positional argument: 'divisor' - - If multiple steps have the same inferred name, then they are given a suffix automatically, - which has to be reflected in the params if used: - >>> pl = make_pipeline([ab_pool, divisor_filter, divisor_filter]) - >>> pl.params = { - ... "ab_pool": {"maximum": 22}, - ... "divisor_filter_0": {"divisor": 3}, - ... "divisor_filter_1": {"divisor": 7} - ... } - >>> list(pl()) - [(0, 'a'), (0, 'b'), (21, 'a'), (21, 'b')] - - You can also use "partial" functions to include Pipes with defaults in the pipeline. - Because the `partial` function doesn't inherit the __name__ of the original function, - these steps are renamed to "step". - >>> from functools import partial - >>> pl = make_pipeline([partial(ab_pool, maximum=100)]) - >>> pl # doctest: +ELLIPSIS +NORMALIZE_WHITESPACE - Pipeline(steps=[('step', functools.partial(, maximum=100))], \ - params={}) - - If there are multiple steps with the same name, they get suffixes as usual: - >>> pl = make_pipeline([partial(range, stop=10), partial(divisor_filter, divisor=3)]) - >>> pl # doctest: +ELLIPSIS +NORMALIZE_WHITESPACE - Pipeline(steps=[('step_0', functools.partial(, stop=10)), \ - ('step_1', functools.partial(, divisor=3))], \ - params={}) - - It is possible to create parallel pipelines too: - >>> pl = make_pipeline([range(5), range(10,15)], kind="union") - >>> pl - PipelineUnion(steps=[('step_0', range(0, 5)), ('step_1', range(10, 15))], params={}) - - >>> list(pl.run()) - [0, 1, 2, 3, 4, 10, 11, 12, 13, 14] - - """ - - if steps is None: - steps = [] - steps_: List[_StepType] = [] - raw_names_ = [getattr(pipe, "__name__", "step").lower() for pipe in steps] - names_tally_ = dict([(name, raw_names_.count(name)) for name in set(raw_names_)]) - names_index_ = dict([(name, 0) for name in set(raw_names_)]) - - for name, pipe in zip(raw_names_, steps): - assert isinstance(pipe, get_args(Union[Pipe, Pool, Iterable])) - - if names_tally_[name] > 1: - current_index_for_this_name = names_index_.get(name, 0) - name_in_pipeline = f"{name}_{current_index_for_this_name}" - names_index_[name] += 1 - else: - name_in_pipeline = name - - steps_.append((name_in_pipeline, pipe)) - - if kind == "serial": - pipeline = Pipeline(steps_, params=params) - elif kind == "union": - pipeline = PipelineUnion(steps_, params=params) - else: - raise NotImplementedError(f"{kind=} is not implemented") - - return pipeline - - -class _ExperimentalCondition: - """An _ExperimentalCondition represents a trial.""" - - pass - - -_ExperimentalSequence = Iterable[_ExperimentalCondition] -_ExperimentalSequence.__doc__ = """ -An _ExperimentalSequence represents a series of trials. -""" diff --git a/autora/experimentalist/pooler/__init__.py b/autora/experimentalist/pooler/__init__.py deleted file mode 100644 index 54d836a1d..000000000 --- a/autora/experimentalist/pooler/__init__.py +++ /dev/null @@ -1,2 +0,0 @@ -from .general_pool import grid_pool, random_pool -from .poppernet import poppernet_pool diff --git a/autora/experimentalist/pooler/general_pool.py b/autora/experimentalist/pooler/general_pool.py deleted file mode 100644 index e0c85068c..000000000 --- a/autora/experimentalist/pooler/general_pool.py +++ /dev/null @@ -1,56 +0,0 @@ -import random -from itertools import product -from typing import List - -import numpy as np - -from autora.variable import IV - - -def grid_pool(ivs: List[IV]): - """Creates exhaustive pool from discrete values using a Cartesian product of sets""" - # Get allowed values for each IV - l_iv_values = [] - for iv in ivs: - assert iv.allowed_values is not None, ( - f"gridsearch_pool only supports independent variables with discrete allowed values, " - f"but allowed_values is None on {iv=} " - ) - l_iv_values.append(iv.allowed_values) - - # Return Cartesian product of all IV values - return product(*l_iv_values) - - -def random_pool(*args, n=1, duplicates=True): - """ - Creates combinations from lists of discrete values using random selection. - Args: - *args: m lists of discrete values. One value will be sampled from each list. - n: Number of samples to sample - duplicates: Boolean if duplicate value are allowed. - - """ - l_samples = [] - # Create list of pools of values sample from - pools = [tuple(pool) for pool in args] - - # Check to ensure infinite search won't occur if duplicates not allowed - if not duplicates: - l_pool_len = [len(set(s)) for s in pools] - n_combinations = np.product(l_pool_len) - try: - assert n <= n_combinations - except AssertionError: - raise AssertionError( - f"Number to sample n({n}) is larger than the number " - f"of unique combinations({n_combinations})." - ) - - # Random sample from the pools until n is met - while len(l_samples) < n: - l_samples.append(tuple(map(random.choice, pools))) - if not duplicates: - l_samples = [*set(l_samples)] - - return iter(l_samples) diff --git a/autora/experimentalist/pooler/poppernet.py b/autora/experimentalist/pooler/poppernet.py deleted file mode 100644 index 2995405ce..000000000 --- a/autora/experimentalist/pooler/poppernet.py +++ /dev/null @@ -1,369 +0,0 @@ -from typing import Optional, Tuple, cast - -import numpy as np -import torch -from sklearn.preprocessing import StandardScaler -from torch import nn -from torch.autograd import Variable - -from autora.variable import ValueType, VariableCollection - - -def poppernet_pool( - model, - x_train: np.ndarray, - y_train: np.ndarray, - metadata: VariableCollection, - n: int = 100, - training_epochs: int = 1000, - optimization_epochs: int = 1000, - training_lr: float = 1e-3, - optimization_lr: float = 1e-3, - mse_scale: float = 1, - limit_offset: float = 0, # 10**-10, - limit_repulsion: float = 0, - plot: bool = False, -): - """ - A pooler that generates samples for independent variables with the objective of maximizing the - (approximated) loss of the model. The samples are generated by first training a neural network - to approximate the loss of a model for all patterns in the training data. Once trained, the - network is then inverted to generate samples that maximize the approximated loss of the model. - - Note: If the pooler returns samples that are close to the boundaries of the variable space, - then it is advisable to increase the limit_repulsion parameter (e.g., to 0.000001). - - Args: - model: Scikit-learn model, could be either a classification or regression model - x_train: data that the model was trained on - y_train: labels that the model was trained on - metadata: Meta-data about the dependent and independent variables - n: number of samples to return - training_epochs: number of epochs to train the popper network for approximating the - error fo the model - optimization_epochs: number of epochs to optimize the samples based on the trained - popper network - training_lr: learning rate for training the popper network - optimization_lr: learning rate for optimizing the samples - mse_scale: scale factor for the MSE loss - limit_offset: a limited offset to prevent the samples from being too close to the value - boundaries - limit_repulsion: a limited repulsion to prevent the samples from being too close to the - allowed value boundaries - plot: print out the prediction of the popper network as well as its training loss - - Returns: Sampled pool - - """ - - # format input - - x_train = np.array(x_train) - if len(x_train.shape) == 1: - x_train = x_train.reshape(-1, 1) - - x = np.empty([n, x_train.shape[1]]) - - y_train = np.array(y_train) - if len(y_train.shape) == 1: - y_train = y_train.reshape(-1, 1) - - if metadata.dependent_variables[0].type == ValueType.CLASS: - # find all unique values in y_train - num_classes = len(np.unique(y_train)) - y_train = class_to_onehot(y_train, n_classes=num_classes) - - x_train_tensor = torch.from_numpy(x_train).float() - - # create list of IV limits - ivs = metadata.independent_variables - iv_limit_list = list() - for iv in ivs: - if hasattr(iv, "value_range"): - value_range = cast(Tuple, iv.value_range) - lower_bound = value_range[0] - upper_bound = value_range[1] - iv_limit_list.append(([lower_bound, upper_bound])) - - # get dimensions of input and output - n_input = len(metadata.independent_variables) - n_output = len(metadata.dependent_variables) - - # get input pattern for popper net - popper_input = Variable(torch.from_numpy(x_train), requires_grad=False).float() - - # get target pattern for popper net - model_predict = getattr(model, "predict_proba", None) - if callable(model_predict) is False: - model_predict = getattr(model, "predict", None) - - if callable(model_predict) is False or model_predict is None: - raise Exception("Model must have `predict` or `predict_proba` method.") - - model_prediction = model_predict(x_train) - if isinstance(model_prediction, np.ndarray) is False: - try: - model_prediction = np.array(model_prediction) - except Exception: - raise Exception("Model prediction must be convertable to numpy array.") - if model_prediction.ndim == 1: - model_prediction = model_prediction.reshape(-1, 1) - - criterion = nn.MSELoss() - model_loss = (model_prediction - y_train) ** 2 * mse_scale - model_loss = np.mean(model_loss, axis=1) - - # standardize the loss - scaler = StandardScaler() - model_loss = scaler.fit_transform(model_loss.reshape(-1, 1)).flatten() - - model_loss = torch.from_numpy(model_loss).float() - popper_target = Variable(model_loss, requires_grad=False) - - # create the network - popper_net = PopperNet(n_input, n_output) - - # reformat input in case it is 1D - if len(popper_input.shape) == 1: - popper_input = popper_input.flatten() - popper_input = popper_input.reshape(-1, 1) - - # define the optimizer - popper_optimizer = torch.optim.Adam(popper_net.parameters(), lr=training_lr) - - # train the network - losses = [] - for epoch in range(training_epochs): - popper_prediction = popper_net(popper_input) - loss = criterion(popper_prediction, popper_target.reshape(-1, 1)) - popper_optimizer.zero_grad() - loss.backward() - popper_optimizer.step() - losses.append(loss.item()) - - if plot: - popper_input_full = np.linspace( - iv_limit_list[0][0], iv_limit_list[0][1], 1000 - ).reshape(-1, 1) - popper_input_full = Variable( - torch.from_numpy(popper_input_full), requires_grad=False - ).float() - popper_prediction = popper_net(popper_input_full) - plot_popper_diagnostics( - losses, - popper_input, - popper_input_full, - popper_prediction, - popper_target, - model_prediction, - y_train, - ) - - # now that the popper network is trained we can sample new data points - # to sample data points we need to provide the popper network with an initial condition - # we will sample those initial conditions proportional to the loss of the current model - - # feed average model losses through softmax - # model_loss_avg= torch.from_numpy(np.mean(model_loss.detach().numpy(), axis=1)).float() - softmax_func = torch.nn.Softmax(dim=0) - probabilities = softmax_func(model_loss) - # sample data point in proportion to model loss - transform_category = torch.distributions.categorical.Categorical(probabilities) - - popper_net.freeze_weights() - - for condition in range(n): - - index = transform_category.sample() - input_sample = torch.flatten(x_train_tensor[index, :]) - popper_input = Variable(input_sample, requires_grad=True) - - # invert the popper network to determine optimal experiment conditions - for optimization_epoch in range(optimization_epochs): - # feedforward pass on popper network - popper_prediction = popper_net(popper_input) - # compute gradient that maximizes output of popper network - # (i.e. predicted loss of original model) - popper_loss_optim = -popper_prediction - popper_loss_optim.backward() - # compute new input - # with torch.no_grad(): - # delta = -optimization_lr * popper_input.grad - # popper_input += -optimization_lr * popper_input.grad - # print(delta) - # popper_input.grad.zero_() - - with torch.no_grad(): - - # first add repulsion from variable limits - for idx in range(len(input_sample)): - iv_value = popper_input[idx] - iv_limits = iv_limit_list[idx] - dist_to_min = np.abs(iv_value - np.min(iv_limits)) - dist_to_max = np.abs(iv_value - np.max(iv_limits)) - # deal with boundary case where distance is 0 or very small - dist_to_min = np.max([dist_to_min, 0.00000001]) - dist_to_max = np.max([dist_to_max, 0.00000001]) - repulsion_from_min = limit_repulsion / (dist_to_min**2) - repulsion_from_max = limit_repulsion / (dist_to_max**2) - iv_value_repulsed = ( - iv_value + repulsion_from_min - repulsion_from_max - ) - popper_input[idx] = iv_value_repulsed - - # now add gradient for theory loss maximization - delta = -optimization_lr * popper_input.grad - popper_input += delta - - # finally, clip input variable from its limits - for idx in range(len(input_sample)): - iv_raw_value = input_sample[idx] - iv_limits = iv_limit_list[idx] - iv_clipped_value = np.min( - [iv_raw_value, np.max(iv_limits) - limit_offset] - ) - iv_clipped_value = np.max( - [ - iv_clipped_value, - np.min(iv_limits) + limit_offset, - ] - ) - popper_input[idx] = iv_clipped_value - popper_input.grad.zero_() - - # add condition to new experiment sequence - for idx in range(len(input_sample)): - iv_limits = iv_limit_list[idx] - - # first clip value - iv_clipped_value = np.min([iv_raw_value, np.max(iv_limits) - limit_offset]) - iv_clipped_value = np.max( - [iv_clipped_value, np.min(iv_limits) + limit_offset] - ) - # make sure to convert variable to original scale - iv_clipped_scaled_value = iv_clipped_value - - x[condition, idx] = iv_clipped_scaled_value - - return iter(x) - - -def plot_popper_diagnostics( - losses, - popper_input, - popper_input_full, - popper_prediction, - popper_target, - model_prediction, - target, -): - print("Finished training Popper Network...") - import matplotlib.pyplot as plt - - if popper_input.shape[1] > 1: - plot_input = popper_input[:, 0] - else: - plot_input = popper_input - - if model_prediction.ndim > 1: - if model_prediction.shape[1] > 1: - model_prediction = model_prediction[:, 0] - target = target[:, 0] - - # PREDICTED MODEL ERROR PLOT - plot_input_order = np.argsort(np.array(plot_input).flatten()) - plot_input = plot_input[plot_input_order] - popper_target = popper_target[plot_input_order] - # popper_prediction = popper_prediction[plot_input_order] - plt.plot(popper_input_full, popper_prediction.detach().numpy(), label="prediction") - plt.scatter( - plot_input, popper_target.detach().numpy(), s=20, c="red", label="target" - ) - plt.xlabel("x") - plt.ylabel("model MSE") - plt.title("popper network prediction") - plt.legend() - plt.show() - - # CONVERGENCE PLOT - plt.plot(losses) - plt.xlabel("epoch") - plt.ylabel("loss") - plt.title("loss for popper network") - plt.show() - - # MODEL PREDICTION PLOT - model_prediction = model_prediction[plot_input_order] - target = target[plot_input_order] - plt.plot(plot_input, model_prediction, label="model prediction") - plt.scatter(plot_input, target, s=20, c="red", label="target") - plt.xlabel("x") - plt.ylabel("y") - plt.title("model prediction vs. target") - plt.legend() - plt.show() - - -# define the network -class PopperNet(nn.Module): - def __init__(self, n_input: torch.Tensor, n_output: torch.Tensor): - # Perform initialization of the pytorch superclass - super(PopperNet, self).__init__() - - # Define network layer dimensions - D_in, H1, H2, H3, D_out = [n_input, 64, 64, 64, n_output] - - # Define layer types - self.linear1 = nn.Linear(D_in, H1) - self.linear2 = nn.Linear(H1, H2) - self.linear3 = nn.Linear(H2, H3) - self.linear4 = nn.Linear(H3, D_out) - - def forward(self, x: torch.Tensor): - """ - This method defines the network layering and activation functions - """ - x = self.linear1(x) # hidden layer - x = torch.tanh(x) # activation function - - x = self.linear2(x) # hidden layer - x = torch.tanh(x) # activation function - - x = self.linear3(x) # hidden layer - x = torch.tanh(x) # activation function - - x = self.linear4(x) # output layer - - return x - - def freeze_weights(self): - for param in self.parameters(): - param.requires_grad = False - - -def class_to_onehot(y: np.array, n_classes: Optional[int] = None): - """Converts a class vector (integers) to binary class matrix. - - E.g. for use with categorical_crossentropy. - - # Arguments - y: class vector to be converted into a matrix - (integers from 0 to num_classes). - n_classes: total number of classes. - - # Returns - A binary matrix representation of the input. - """ - y = np.array(y, dtype="int") - input_shape = y.shape - if input_shape and input_shape[-1] == 1 and len(input_shape) > 1: - input_shape = tuple(input_shape[:-1]) - y = y.ravel() - if not n_classes: - n_classes = np.max(y) + 1 - n = y.shape[0] - categorical = np.zeros((n, n_classes)) - categorical[np.arange(n), y] = 1 - output_shape = input_shape + (n_classes,) - categorical = np.reshape(categorical, output_shape) - return categorical diff --git a/autora/experimentalist/sampler/__init__.py b/autora/experimentalist/sampler/__init__.py deleted file mode 100644 index 215afeb19..000000000 --- a/autora/experimentalist/sampler/__init__.py +++ /dev/null @@ -1,5 +0,0 @@ -from .assumption import assumption_sampler -from .model_disagreement import model_disagreement_sampler -from .nearest_value import nearest_values_sampler -from .random import random_sampler -from .uncertainty import uncertainty_sampler diff --git a/autora/experimentalist/sampler/assumption.py b/autora/experimentalist/sampler/assumption.py deleted file mode 100644 index b46a9220a..000000000 --- a/autora/experimentalist/sampler/assumption.py +++ /dev/null @@ -1,67 +0,0 @@ -from typing import Iterable - -import numpy as np -from sklearn.metrics import mean_absolute_error as mae -from sklearn.metrics import mean_squared_error as mse - - -def assumption_sampler( - X, y, model, n, loss=True, theorist=None, confirmation_bias=False -): - """ - Assumption Sampler challenges assumptions made by the Theorist. - It identifies points whose error are most dependent on the assumption made. - Assumptions take the form of hard-coding, which may be hyperparameters or arbitrarily chosen - sub-algorithms e.g. loss function - Because it samples with respect to a Theorist, this sampler cannot be used on the first cycle - - Args: - X: pool of IV conditions to sample from - y: experimental results from most recent iteration - model: Scikit-learn model, must have `predict` method. - n: number of samples to select - loss: assumption to test: identify points that are most affected by choice of loss function - theorist: the Theorist, which employs the theory it has been hard-coded to demonstrate - confirmation_bias: whether to find evidence to support or oppose the theory - - Returns: Sampled pool - - """ - - if isinstance(X, Iterable): - X = np.array(list(X)) - current = None - if theorist: - pass # add code to extract loss function from theorist object - idx = range(len(X)) - - if y is not None: - if loss: - if current is None: - current = mse - print( - Warning( - "Knowledge of Theorist Loss Function needed. MSE has been assumed." - ) - ) - y_pred = model.predict(X) - current_loss = current( - y_true=y.reshape(1, -1), - y_pred=y_pred.reshape(1, -1), - multioutput="raw_values", - ) - print(current_loss) - alternative = mae - alternative_loss = alternative( - y_true=y.reshape(1, -1), - y_pred=y_pred.reshape(1, -1), - multioutput="raw_values", - ) - loss_delta = alternative_loss - current_loss - idx = np.flip(loss_delta.argsort()[:n]) - else: - raise TypeError( - "Experiment results are required to run the assumption experimentalist" - ) - - return X[idx] diff --git a/autora/experimentalist/sampler/dissimilarity.py b/autora/experimentalist/sampler/dissimilarity.py deleted file mode 100644 index 8b8b112ac..000000000 --- a/autora/experimentalist/sampler/dissimilarity.py +++ /dev/null @@ -1,96 +0,0 @@ -from typing import Iterable, Literal - -import numpy as np -from sklearn.metrics import DistanceMetric - -AllowedMetrics = Literal[ - "euclidean", - "manhattan", - "chebyshev", - "minkowski", - "wminkowski", - "seuclidean", - "mahalanobis", - "haversine", - "hamming", - "canberra", - "braycurtis", - "matching", - "jaccard", - "dice", - "kulsinski", - "rogerstanimoto", - "russellrao", - "sokalmichener", - "sokalsneath", - "yule", -] - - -def summed_dissimilarity_sampler( - X: np.ndarray, X_ref: np.ndarray, n: int = 1, metric: AllowedMetrics = "euclidean" -) -> np.ndarray: - """ - This dissimilarity samples re-arranges the pool of IV conditions according to their - dissimilarity with respect to a reference pool X_ref. The default dissimilarity is calculated - as the average of the pairwise distances between the conditions in X and X_ref. - - Args: - X: pool of IV conditions to evaluate dissimilarity - X_ref: reference pool of IV conditions - n: number of samples to select - metric (str): dissimilarity measure. Options: 'euclidean', 'manhattan', 'chebyshev', - 'minkowski', 'wminkowski', 'seuclidean', 'mahalanobis', 'haversine', - 'hamming', 'canberra', 'braycurtis', 'matching', 'jaccard', 'dice', - 'kulsinski', 'rogerstanimoto', 'russellrao', 'sokalmichener', - 'sokalsneath', 'yule'. See [sklearn.metrics.DistanceMetric][] for more details. - - Returns: - Sampled pool - """ - - if isinstance(X, Iterable): - X = np.array(list(X)) - - if isinstance(X_ref, Iterable): - X_ref = np.array(list(X_ref)) - - if X.ndim == 1: - X = X.reshape(-1, 1) - - if X_ref.ndim == 1: - X_ref = X_ref.reshape(-1, 1) - - if X.shape[1] != X_ref.shape[1]: - raise ValueError( - f"X and X_ref must have the same number of columns.\n" - f"X has {X.shape[1]} columns, while X_ref has {X_ref.shape[1]} columns." - ) - - if X.shape[0] < n: - raise ValueError( - f"X must have at least {n} rows matching the number of requested samples." - ) - - dist = DistanceMetric.get_metric(metric) - - # create a list to store the summed distances for each row in matrix1 - summed_distances = [] - - # loop over each row in first matrix - for row in X: - # calculate the distances between the current row in matrix1 and all other rows in matrix2 - summed_distance = 0 - - for X_ref_row in X_ref: - - distance = dist.pairwise([row, X_ref_row])[0, 1] - summed_distance += distance - - # store the summed distance for the current row - summed_distances.append(summed_distance) - - # sort the rows in matrix1 by their summed distances - sorted_X = X[np.argsort(summed_distances)[::-1]] - - return sorted_X[:n] diff --git a/autora/experimentalist/sampler/model_disagreement.py b/autora/experimentalist/sampler/model_disagreement.py deleted file mode 100644 index 20a9b805f..000000000 --- a/autora/experimentalist/sampler/model_disagreement.py +++ /dev/null @@ -1,66 +0,0 @@ -import itertools -from typing import Iterable, List - -import numpy as np - - -def model_disagreement_sampler(X: np.array, models: List, num_samples: int = 1): - """ - A sampler that returns selected samples for independent variables - for which the models disagree the most in terms of their predictions. - - Args: - X: pool of IV conditions to evaluate in terms of model disagreement - models: List of Scikit-learn (regression or classification) models to compare - num_samples: number of samples to select - - Returns: Sampled pool - """ - - if isinstance(X, Iterable): - X = np.array(list(X)) - - X_predict = np.array(X) - if len(X_predict.shape) == 1: - X_predict = X_predict.reshape(-1, 1) - - model_disagreement = list() - - # collect diagreements for each model pair - for model_a, model_b in itertools.combinations(models, 2): - - # determine the prediction method - if hasattr(model_a, "predict_proba") and hasattr(model_b, "predict_proba"): - model_a_predict = model_a.predict_proba - model_b_predict = model_b.predict_proba - elif hasattr(model_a, "predict") and hasattr(model_b, "predict"): - model_a_predict = model_a.predict - model_b_predict = model_b.predict - else: - raise AttributeError( - "Models must both have `predict_proba` or `predict` method." - ) - - # get predictions from both models - y_a = model_a_predict(X_predict) - y_b = model_b_predict(X_predict) - - assert y_a.shape == y_b.shape, "Models must have same output shape." - - # determine the disagreement between the two models in terms of mean-squared error - if len(y_a.shape) == 1: - disagreement = (y_a - y_b) ** 2 - else: - disagreement = np.mean((y_a - y_b) ** 2, axis=1) - - model_disagreement.append(disagreement) - - assert len(model_disagreement) >= 1, "No disagreements to compare." - - # sum up all model disagreements - summed_disagreement = np.sum(model_disagreement, axis=0) - - # sort the summed disagreements and select the top n - idx = (-summed_disagreement).argsort()[:num_samples] - - return X[idx] diff --git a/autora/experimentalist/sampler/nearest_value.py b/autora/experimentalist/sampler/nearest_value.py deleted file mode 100644 index 61f2713d7..000000000 --- a/autora/experimentalist/sampler/nearest_value.py +++ /dev/null @@ -1,60 +0,0 @@ -from typing import Iterable, Sequence, Union - -import numpy as np - - -def nearest_values_sampler( - samples: Union[Iterable, Sequence], - allowed_values: np.ndarray, - n: int, -): - """ - A sampler which returns the nearest values between the input samples and the allowed values, - without replacement. - - Args: - samples: input conditions - allowed_samples: allowed conditions to sample from - - Returns: - the nearest values from `allowed_samples` to the `samples` - - """ - - if isinstance(allowed_values, Iterable): - allowed_values = np.array(list(allowed_values)) - - if len(allowed_values.shape) == 1: - allowed_values = allowed_values.reshape(-1, 1) - - if isinstance(samples, Iterable): - samples = np.array(list(samples)) - - if allowed_values.shape[0] < n: - raise Exception( - "More samples requested than samples available in the set allowed of values." - ) - - if isinstance(samples, Iterable) or isinstance(samples, Sequence): - samples = np.array(list(samples)) - - if hasattr(samples, "shape"): - if samples.shape[0] < n: - raise Exception( - "More samples requested than samples available in the pool." - ) - - x_new = np.empty((n, allowed_values.shape[1])) - - # get index of row in x that is closest to each sample - for row, sample in enumerate(samples): - - if row >= n: - break - - dist = np.linalg.norm(allowed_values - sample, axis=1) - idx = np.argmin(dist) - x_new[row, :] = allowed_values[idx, :] - allowed_values = np.delete(allowed_values, idx, axis=0) - - return x_new diff --git a/autora/experimentalist/sampler/random.py b/autora/experimentalist/sampler/random.py deleted file mode 100644 index 03246032a..000000000 --- a/autora/experimentalist/sampler/random.py +++ /dev/null @@ -1,21 +0,0 @@ -import random -from typing import Iterable, Sequence, Union - - -def random_sampler(conditions: Union[Iterable, Sequence], n: int): - """ - Uniform random sampling without replacement from a pool of conditions. - Args: - conditions: Pool of conditions - n: number of samples to collect - - Returns: Sampled pool - - """ - - if isinstance(conditions, Iterable): - conditions = list(conditions) - random.shuffle(conditions) - samples = conditions[0:n] - - return samples diff --git a/autora/experimentalist/sampler/uncertainty.py b/autora/experimentalist/sampler/uncertainty.py deleted file mode 100644 index 5cf3da0b7..000000000 --- a/autora/experimentalist/sampler/uncertainty.py +++ /dev/null @@ -1,61 +0,0 @@ -from typing import Iterable - -import numpy as np -from scipy.stats import entropy - - -def uncertainty_sampler(X, model, n, measure="least_confident"): - """ - - Args: - X: pool of IV conditions to evaluate uncertainty - model: Scikit-learn model, must have `predict_proba` method. - n: number of samples to select - measure: method to evaluate uncertainty. Options: - - - `'least_confident'`: $x* = \\operatorname{argmax} \\left( 1-P(\\hat{y}|x) \\right)$, - where $\\hat{y} = \\operatorname{argmax} P(y_i|x)$ - - `'margin'`: - $x* = \\operatorname{argmax} \\left( P(\\hat{y}_1|x) - P(\\hat{y}_2|x) \\right)$, - where $\\hat{y}_1$ and $\\hat{y}_2$ are the first and second most probable - class labels under the model, respectively. - - `'entropy'`: - $x* = \\operatorname{argmax} \\left( - \\sum P(y_i|x) - \\operatorname{log} P(y_i|x) \\right)$ - - Returns: Sampled pool - - """ - - if isinstance(X, Iterable): - X = np.array(list(X)) - - a_prob = model.predict_proba(X) - - if measure == "least_confident": - # Calculate uncertainty of max probability class - a_uncertainty = 1 - a_prob.max(axis=1) - # Get index of largest uncertainties - idx = np.flip(a_uncertainty.argsort()[-n:]) - - elif measure == "margin": - # Sort values by row descending - a_part = np.partition(-a_prob, 1, axis=1) - # Calculate difference between 2 largest probabilities - a_margin = -a_part[:, 0] + a_part[:, 1] - # Determine index of smallest margins - idx = a_margin.argsort()[:n] - - elif measure == "entropy": - # Calculate entropy - a_entropy = entropy(a_prob.T) - # Get index of largest entropies - idx = np.flip(a_entropy.argsort()[-n:]) - - else: - raise ValueError( - f"Unsupported uncertainty measure: '{measure}'\n" - f"Only 'least_confident', 'margin', or 'entropy' is supported." - ) - - return X[idx] diff --git a/autora/experimentalist/utils/__init__.py b/autora/experimentalist/utils/__init__.py deleted file mode 100644 index d4e204653..000000000 --- a/autora/experimentalist/utils/__init__.py +++ /dev/null @@ -1,133 +0,0 @@ -from __future__ import annotations - -import collections -from typing import Union - -import numpy as np - - -def sequence_to_array(iterable): - """ - Converts a finite sequence of experimental conditions into a 2D numpy.array. - - See also: [array_to_sequence][autora.experimentalist.utils.array_to_sequence] - - Examples: - - A simple range object can be converted into an array of dimension 2: - >>> _sequence_to_array(range(5)) # doctest: +NORMALIZE_WHITESPACE - array([[0], [1], [2], [3], [4]]) - - For mixed datatypes, the highest-level type common to all the inputs will be used, so - consider using [_sequence_to_recarray][autora.experimentalist.utils._sequence_to_recarray] - instead. - >>> _sequence_to_array(zip(range(5), "abcde")) # doctest: +NORMALIZE_WHITESPACE - array([['0', 'a'], ['1', 'b'], ['2', 'c'], ['3', 'd'], ['4', 'e']], dtype='>> sequence_to_array("abcde",array_type="numpy.array") # doctest: +NORMALIZE_WHITESPACE - array([['a'], ['b'], ['c'], ['d'], ['e']], dtype='>> sequence_to_array(["abc", "de"],array_type="numpy.array" - ... ) # doctest: +NORMALIZE_WHITESPACE - array([['abc'], ['de']], dtype='>> _sequence_to_recarray(range(5)) # doctest: +NORMALIZE_WHITESPACE - rec.array([(0,), (1,), (2,), (3,), (4,)], dtype=[('f0', '>> _sequence_to_recarray(zip(range(5), "abcde")) # doctest: +NORMALIZE_WHITESPACE - rec.array([(0, 'a'), (1, 'b'), (2, 'c'), (3, 'd'), (4, 'e')], - dtype=[('f0', '>> _sequence_to_recarray("abcde") # doctest: +NORMALIZE_WHITESPACE - rec.array([('a',), ('b',), ('c',), ('d',), ('e',)], dtype=[('f0', '>> _sequence_to_recarray(["abc", "de"]) # doctest: +NORMALIZE_WHITESPACE - rec.array([('abc',), ('de',)], dtype=[('f0', '>> a0 = np.arange(10).reshape(-1,2) - >>> a0 - array([[0, 1], - [2, 3], - [4, 5], - [6, 7], - [8, 9]]) - - The sequence is created as a generator object - >>> array_to_sequence(a0) # doctest: +ELLIPSIS - - - To see the sequence, we can convert it into a list: - >>> l0 = list(array_to_sequence(a0)) - >>> l0 - [array([0, 1]), array([2, 3]), array([4, 5]), array([6, 7]), array([8, 9])] - - The individual rows are themselves 1-dimensional arrays: - >>> l0[0] - array([0, 1]) - - The rows can be subscripted as usual: - >>> l0[2][1] - 5 - - We can also use a record array: - >>> a1 = np.rec.fromarrays([range(5), list("abcde")]) - >>> a1 - rec.array([(0, 'a'), (1, 'b'), (2, 'c'), (3, 'd'), (4, 'e')], - dtype=[('f0', '>> l1 = list(array_to_sequence(a1)) - >>> l1 - [(0, 'a'), (1, 'b'), (2, 'c'), (3, 'd'), (4, 'e')] - - The elements of the list are numpy.records - >>> type(l1[0]) - - - """ - assert isinstance(input, (np.ndarray, np.recarray)) - - for a in input: - yield a diff --git a/autora/skl/__init__.py b/autora/skl/__init__.py deleted file mode 100644 index e69de29bb..000000000 diff --git a/autora/skl/bms.py b/autora/skl/bms.py deleted file mode 100644 index b7ca02d67..000000000 --- a/autora/skl/bms.py +++ /dev/null @@ -1,180 +0,0 @@ -from __future__ import annotations - -import logging -from inspect import signature -from typing import Callable, Dict, List, Optional - -import numpy as np -import pandas as pd -from sklearn.base import BaseEstimator, RegressorMixin -from sklearn.utils.validation import check_array, check_is_fitted, check_X_y - -from autora.theorist.bms import Parallel, Tree, get_priors, utils - -_logger = logging.getLogger(__name__) - -# hyperparameters for BMS -# 1) Priors for MCMC -PRIORS, _ = get_priors() - -# 2) Temperatures for parallel tempering -TEMPERATURES = [1.0] + [1.04**k for k in range(1, 20)] - - -class BMSRegressor(BaseEstimator, RegressorMixin): - """ - Bayesian Machine Scientist. - - BMS finds an optimal function to explain a dataset, given a set of variables, - and a pre-defined number of parameters - - This class is intended to be compatible with the - [Scikit-Learn Estimator API](https://scikit-learn.org/stable/developers/develop.html). - - Examples: - - >>> from autora.theorist.bms import Parallel, utils - >>> import numpy as np - >>> num_samples = 1000 - >>> X = np.linspace(start=0, stop=1, num=num_samples).reshape(-1, 1) - >>> y = 15. * np.ones(num_samples) - >>> estimator = BMSRegressor() - >>> estimator = estimator.fit(X, y) - >>> estimator.predict([[15.]]) - array([[15.]]) - - - Attributes: - pms: the bayesian (parallel) machine scientist model - model_: represents the best-fit model - loss_: represents loss associated with best-fit model - cache_: record of loss_ over model fitting epochs - """ - - def __init__( - self, - prior_par: dict = PRIORS, - ts: List[float] = TEMPERATURES, - epochs: int = 1500, - ): - """ - Arguments: - prior_par: a dictionary of the prior probabilities of different functions based on - wikipedia data scraping - ts: contains a list of the temperatures that the parallel ms works at - """ - self.ts = ts - self.prior_par = prior_par - self.epochs = epochs - self.pms: Parallel = Parallel(Ts=ts) - self.ops = get_priors()[1] - self.custom_ops: Dict[str, Callable] = dict() - self.X_: Optional[np.ndarray] = None - self.y_: Optional[np.ndarray] = None - self.model_: Tree = Tree() - self.models_: List[Tree] = [Tree()] - self.loss_: float = np.inf - self.cache_: List = [] - self.variables: List = [] - - def fit( - self, - X: np.ndarray, - y: np.ndarray, - num_param: int = 1, - root=None, - custom_ops=None, - seed=None, - ) -> BMSRegressor: - """ - Runs the optimization for a given set of `X`s and `y`s. - - Arguments: - X: independent variables in an n-dimensional array - y: dependent variables in an n-dimensional array - num_param: number of parameters - root: fixed root of the tree - custom_ops: user-defined functions to additionally treated as primitives - - Returns: - self (BMS): the fitted estimator - """ - # firstly, store the column names of X since checking will - # cast the type of X to np.ndarray - if hasattr(X, "columns"): - self.variables = list(X.columns) - else: - # create variables X_1 to X_n where n is the number of columns in X - self.variables = ["X%d" % i for i in range(X.shape[1])] - - X, y = check_X_y(X, y) - - # cast X into pd.Pandas again to fit the need in mcmc.py - X = pd.DataFrame(X, columns=self.variables) - y = pd.Series(y) - _logger.info("BMS fitting started") - if custom_ops is not None: - for op in custom_ops: - self.add_primitive(op) - if (root is not None) and (root not in self.ops.keys()): - self.add_primitive(root) - self.pms = Parallel( - Ts=self.ts, - variables=self.variables, - parameters=["a%d" % i for i in range(num_param)], - x=X, - y=y, - prior_par=self.prior_par, - ops=self.ops, - custom_ops=self.custom_ops, - root=root, - seed=seed, - ) - self.model_, self.loss_, self.cache_ = utils.run(self.pms, self.epochs) - self.models_ = list(self.pms.trees.values()) - - _logger.info("BMS fitting finished") - self.X_, self.y_ = X, y - return self - - def predict(self, X: np.ndarray) -> np.ndarray: - """ - Applies the fitted model to a set of independent variables `X`, - to give predictions for the dependent variable `y`. - - Arguments: - X: independent variables in an n-dimensional array - - Returns: - y: predicted dependent variable values - """ - # this validation step will cast X into np.ndarray format - X = check_array(X) - - check_is_fitted(self, attributes=["model_"]) - - assert self.model_ is not None - # we need to cast it back into pd.DataFrame with the original - # column names (generated in `fit`). - # in the future, we might need to look into mcmc.py to remove - # these redundant type castings. - X = pd.DataFrame(X, columns=self.variables) - - return np.expand_dims(self.model_.predict(X).to_numpy(), axis=1) - - def present_results(self): - """ - Prints out the best equation, its description length, - along with a plot of how this has progressed over the course of the search tasks. - """ - check_is_fitted(self, attributes=["model_", "loss_", "cache_"]) - assert self.model_ is not None - assert self.loss_ is not None - assert self.cache_ is not None - - utils.present_results(self.model_, self.loss_, self.cache_) - - def add_primitive(self, op: Callable): - self.custom_ops.update({op.__name__: op}) - self.ops.update({op.__name__: len(signature(op).parameters)}) - self.prior_par.update({"Nopi_" + op.__name__: 1}) diff --git a/autora/skl/bsr.py b/autora/skl/bsr.py deleted file mode 100644 index 2abda3161..000000000 --- a/autora/skl/bsr.py +++ /dev/null @@ -1,357 +0,0 @@ -import copy -import logging -import time -from typing import List, Optional, Union - -import numpy as np -import pandas as pd -from scipy.stats import invgamma -from sklearn.base import BaseEstimator, RegressorMixin -from sklearn.utils.validation import check_is_fitted - -from autora.theorist.bsr.funcs import get_all_nodes, grow, prop_new -from autora.theorist.bsr.node import Node -from autora.theorist.bsr.prior import get_prior_dict - -_logger = logging.getLogger(__name__) - - -class BSRRegressor(BaseEstimator, RegressorMixin): - """ - Bayesian Symbolic Regression (BSR) - - A MCMC-sampling-based Bayesian approach to symbolic regression -- a machine learning method - that bridges `X` and `y` by automatically building up mathematical expressions of basic - functions. Performance and speed of `BSR` depends on pre-defined parameters. - - This class is intended to be compatible with the - [Scikit-Learn Estimator API](https://scikit-learn.org/stable/developers/develop.html). - - Examples: - - >>> import numpy as np - >>> num_samples = 1000 - >>> X = np.linspace(start=0, stop=1, num=num_samples).reshape(-1, 1) - >>> y = np.sqrt(X) - >>> estimator = BSRRegressor() - >>> estimator = estimator.fit(X, y) - >>> estimator.predict([[1.5]]) - - Attributes: - roots_: the root(s) of the best-fit symbolic regression (SR) tree(s) - betas_: the beta parameters of the best-fit model - train_errs_: the training losses associated with the best-fit model - """ - - def __init__( - self, - tree_num: int = 3, - itr_num: int = 5000, - alpha1: float = 0.4, - alpha2: float = 0.4, - beta: float = -1, - show_log: bool = False, - val: int = 100, - last_idx: int = -1, - prior_name: str = "Uniform", - ): - """ - Arguments: - tree_num: pre-specified number of SR trees to fit in the model - itr_num: number of iterations steps to run for the model fitting process - alpha1, alpha2, beta: the hyper-parameters of priors - show_log: whether to output certain logging info - val: number of validation steps to run for each iteration step - last_idx: the index of which latest (most best-fit) model to use - (-1 means the latest one) - """ - self.tree_num = tree_num - self.itr_num = itr_num - self.alpha1 = alpha1 - self.alpha2 = alpha2 - self.beta = beta - self.show_log = show_log - self.val = val - self.last_idx = last_idx - self.prior_name = prior_name - - # attributes that are not set until `fit` - self.roots_: Optional[List[List[Node]]] = None - self.betas_: Optional[List[List[float]]] = None - self.train_errs_: Optional[List[List[float]]] = None - - self.X_: Optional[Union[np.ndarray, pd.DataFrame]] = None - self.y_: Optional[Union[np.ndarray, pd.DataFrame]] = None - - def predict(self, X: Union[np.ndarray, pd.DataFrame]) -> np.ndarray: - """ - Applies the fitted model to a set of independent variables `X`, - to give predictions for the dependent variable `y`. - - Arguments: - X: independent variables in an n-dimensional array - Returns: - y: predicted dependent variable values - """ - if isinstance(X, np.ndarray): - X = pd.DataFrame(X) - - check_is_fitted(self, attributes=["roots_"]) - - k = self.tree_num - n_test = X.shape[0] - tree_outs = np.zeros((n_test, k)) - - assert self.roots_ and self.betas_ - for i in np.arange(k): - tree_out = self.roots_[-self.last_idx][i].evaluate(X) - tree_out.shape = tree_out.shape[0] - tree_outs[:, i] = tree_out - - ones = np.ones((n_test, 1)) - tree_outs = np.concatenate((ones, tree_outs), axis=1) - _beta = self.betas_[-self.last_idx] - output = np.matmul(tree_outs, _beta) - - return output - - def fit( - self, X: Union[np.ndarray, pd.DataFrame], y: Union[np.ndarray, pd.DataFrame] - ): - """ - Runs the optimization for a given set of `X`s and `y`s. - - Arguments: - X: independent variables in an n-dimensional array - y: dependent variables in an n-dimensional array - Returns: - self (BSR): the fitted estimator - """ - # train_data must be a dataframe - if isinstance(X, np.ndarray): - X = pd.DataFrame(X) - train_errs: List[List[float]] = [] - roots: List[List[Node]] = [] - betas: List[List[float]] = [] - itr_num = self.itr_num - k = self.tree_num - beta = self.beta - - if self.show_log: - _logger.info("Starting training") - while len(train_errs) < itr_num: - n_feature = X.shape[1] - n_train = X.shape[0] - - ops_name_lst, ops_weight_lst, ops_priors = get_prior_dict( - prior_name=self.prior_name - ) - - # List of tree samples - root_lists: List[List[Node]] = [[] for _ in range(k)] - - sigma_a_list = [] # List of sigma_a, for each component tree - sigma_b_list = [] # List of sigma_b, for each component tree - - sigma_y = invgamma.rvs(1) # for output y - - # Initialization - for count in np.arange(k): - # create a new root node - root = Node(0) - sigma_a = invgamma.rvs(1) - sigma_b = invgamma.rvs(1) - - # grow a tree from the root node - if self.show_log: - _logger.info("Grow a tree from the root node") - - grow( - root, - ops_name_lst, - ops_weight_lst, - ops_priors, - n_feature, - sigma_a=sigma_a, - sigma_b=sigma_b, - ) - - # put the root into list - root_lists[count].append(root) - sigma_a_list.append(sigma_a) - sigma_b_list.append(sigma_b) - - # calculate beta - if self.show_log: - _logger.info("Calculate beta") - # added a constant in the regression by fwl - tree_outputs = np.zeros((n_train, k)) - - for count in np.arange(k): - temp = root_lists[count][-1].evaluate(X) - temp.shape = temp.shape[0] - tree_outputs[:, count] = temp - - constant = np.ones((n_train, 1)) # added a constant - tree_outputs = np.concatenate((constant, tree_outputs), axis=1) - scale = np.max(np.abs(tree_outputs)) - tree_outputs = tree_outputs / scale - epsilon = ( - np.eye(tree_outputs.shape[1]) * 1e-6 - ) # add to the matrix to prevent singular matrrix - yy = np.array(y) - yy.shape = (yy.shape[0], 1) - _beta = np.linalg.inv( - np.matmul(tree_outputs.transpose(), tree_outputs) + epsilon - ) - _beta = np.matmul(_beta, np.matmul(tree_outputs.transpose(), yy)) - output = np.matmul(tree_outputs, _beta) - # rescale the beta, above we scale tree_outputs for calculation by fwl - _beta /= scale - - total = 0 - accepted = 0 - errs = [] - total_list = [] - - tic = time.time() - - if self.show_log: - _logger.info("While total < ", self.val) - while total < self.val: - switch_label = False - for count in range(k): - curr_roots = [] # list of current components - for i in np.arange(k): - curr_roots.append(root_lists[i][-1]) - # pick the root to be changed - sigma_a = sigma_a_list[count] - sigma_b = sigma_b_list[count] - - # the returned root is a new copy - if self.show_log: - _logger.info("new_prop...") - res, root, sigma_y, sigma_a, sigma_b = prop_new( - curr_roots, - count, - sigma_y, - beta, - sigma_a, - sigma_b, - X, - y, - ops_name_lst, - ops_weight_lst, - ops_priors, - ) - if self.show_log: - _logger.info("res:", res) - print(root) - - total += 1 - # update sigma_a and sigma_b - sigma_a_list[count] = sigma_a - sigma_b_list[count] = sigma_b - - if res: - # flag = False - accepted += 1 - # record newly accepted root - root_lists[count].append(copy.deepcopy(root)) - - tree_outputs = np.zeros((n_train, k)) - - for i in np.arange(k): - temp = root_lists[count][-1].evaluate(X) - temp.shape = temp.shape[0] - tree_outputs[:, i] = temp - - constant = np.ones((n_train, 1)) - tree_outputs = np.concatenate((constant, tree_outputs), axis=1) - scale = np.max(np.abs(tree_outputs)) - tree_outputs = tree_outputs / scale - epsilon = ( - np.eye(tree_outputs.shape[1]) * 1e-6 - ) # add to prevent singular matrix - yy = np.array(y) - yy.shape = (yy.shape[0], 1) - _beta = np.linalg.inv( - np.matmul(tree_outputs.transpose(), tree_outputs) + epsilon - ) - _beta = np.matmul( - _beta, np.matmul(tree_outputs.transpose(), yy) - ) - - output = np.matmul(tree_outputs, _beta) - # rescale the beta, above we scale tree_outputs for calculation - _beta /= scale - - error = 0 - for i in np.arange(n_train): - error += (output[i, 0] - y[i]) * (output[i, 0] - y[i]) - - rmse = np.sqrt(error / n_train) - errs.append(rmse) - - total_list.append(total) - total = 0 - - if len(errs) > 100: - lapses = min(10, len(errs)) - converge_ratio = 1 - np.min(errs[-lapses:]) / np.mean( - errs[-lapses:] - ) - if converge_ratio < 0.05: - # converged - switch_label = True - break - if switch_label: - break - - if self.show_log: - for i in np.arange(0, len(y)): - _logger.info(output[i, 0], y[i]) - - toc = time.time() - tictoc = toc - tic - if self.show_log: - _logger.info("Run time: {:.2f}s".format(tictoc)) - - _logger.info("------") - _logger.info( - "Mean rmse of last 5 accepts: {}".format(np.mean(errs[-6:-1])) - ) - - train_errs.append(errs) - roots.append(curr_roots) - betas.append(_beta) - - self.roots_ = roots - self.train_errs_ = train_errs - self.betas_ = betas - self.X_, self.y_ = X, y - return self - - def _model(self, last_ind: int = 1) -> List[str]: - """ - Return the models in the last-i-th iteration, default `last_ind = 1` refers to the - last (final) iteration. - """ - models = [] - assert self.roots_ - for i in range(self.tree_num): - models.append(self.roots_[-last_ind][i].get_expression()) - return models - - def _complexity(self) -> int: - """ - Return the complexity of the final models, which equals to the sum of nodes in all - expression trees. - """ - cp = 0 - assert self.roots_ - for i in range(self.tree_num): - root_node = self.roots_[-1][i] - num = len(get_all_nodes(root_node)) - cp = cp + num - return cp diff --git a/autora/skl/darts.py b/autora/skl/darts.py deleted file mode 100644 index c22f1c60f..000000000 --- a/autora/skl/darts.py +++ /dev/null @@ -1,871 +0,0 @@ -import copy -import logging -from dataclasses import dataclass -from itertools import cycle -from types import SimpleNamespace -from typing import Any, Callable, Iterator, Literal, Optional, Sequence, Tuple - -import numpy as np -import torch -import torch.nn -import torch.nn.utils -import torch.utils.data -from matplotlib import pyplot as plt -from sklearn.base import BaseEstimator, RegressorMixin -from sklearn.utils.validation import check_array, check_is_fitted, check_X_y -from tqdm.auto import tqdm - -from autora.theorist.darts import ( - PRIMITIVES, - Architect, - AvgrageMeter, - DARTSType, - Network, - darts_dataset_from_ndarray, - darts_model_plot, - format_input_target, - get_loss_function, - get_output_format, - get_output_str, -) -from autora.variable import ValueType - -_logger = logging.getLogger(__name__) - -_progress_indicator = tqdm - -SAMPLING_STRATEGIES = Literal["max", "sample"] -IMPLEMENTED_DARTS_TYPES = Literal["original", "fair"] -IMPLEMENTED_OUTPUT_TYPES = Literal[ - "real", - "sigmoid", - "probability", - "probability_sample", - "probability_distribution", -] - - -@dataclass(frozen=True) -class _DARTSResult: - """A container for passing fitted DARTS results around.""" - - network: Network - model: torch.nn.Module - - -def _general_darts( - X: np.ndarray, - y: np.ndarray, - network: Optional[Network] = None, - batch_size: int = 20, - num_graph_nodes: int = 2, - output_type: IMPLEMENTED_OUTPUT_TYPES = "real", - classifier_weight_decay: float = 1e-2, - darts_type: IMPLEMENTED_DARTS_TYPES = "original", - init_weights_function: Optional[Callable] = None, - param_updates_per_epoch: int = 20, - param_updates_for_sampled_model: int = 100, - param_learning_rate_max: float = 2.5e-2, - param_learning_rate_min: float = 0.01, - param_momentum: float = 9e-1, - param_weight_decay: float = 3e-4, - arch_learning_rate_max: float = 3e-3, - arch_updates_per_epoch: int = 20, - arch_weight_decay: float = 1e-4, - arch_weight_decay_df: float = 3e-4, - arch_weight_decay_base: float = 0.0, - arch_momentum: float = 9e-1, - fair_darts_loss_weight: int = 1, - max_epochs: int = 100, - grad_clip: float = 5, - primitives: Sequence[str] = PRIMITIVES, - train_classifier_coefficients: bool = False, - train_classifier_bias: bool = False, - execution_monitor: Callable = (lambda *args, **kwargs: None), - sampling_strategy: SAMPLING_STRATEGIES = "max", -) -> _DARTSResult: - """ - Function to implement the DARTS optimization, given a fixed architecture and input data. - - Arguments: - X: Input data. - y: Target data. - batch_size: Batch size for the data loader. - num_graph_nodes: Number of nodes in the desired computation graph. - output_type: Type of output function to use. This function is applied to transform - the output of the mixture architecture. - classifier_weight_decay: Weight decay for the classifier. - darts_type: Type of DARTS to use ('original' or 'fair'). - init_weights_function: Function to initialize the parameters of each operation. - param_learning_rate_max: Initial (maximum) learning rate for the operation parameters. - param_learning_rate_min: Final (minimum) learning rate for the operation parameters. - param_momentum: Momentum for the operation parameters. - param_weight_decay: Weight decay for the operation parameters. - param_updates_per_epoch: Number of updates to perform per epoch. - for the operation parameters. - arch_learning_rate_max: Initial (maximum) learning rate for the architecture. - arch_updates_per_epoch: Number of architecture weight updates to perform per epoch. - arch_weight_decay: Weight decay for the architecture weights. - arch_weight_decay_df: An additional weight decay that scales with the number of parameters - (degrees of freedom) in the operation. The higher this weight decay, the more DARTS will - prefer simple operations. - arch_weight_decay_base: A base weight decay that is added to the scaled weight decay. - arch_momentum: Momentum for the architecture weights. - fair_darts_loss_weight: Weight of the loss in fair darts which forces architecture weights - to become either 0 or 1. - max_epochs: Maximum number of epochs to train for. - grad_clip: Gradient clipping value for updating the parameters of the operations. - primitives: List of primitives (operations) to use. - train_classifier_coefficients: Whether to train the coefficients of the classifier. - train_classifier_bias: Whether to train the bias of the classifier. - execution_monitor: Function to monitor the execution of the model. - - Returns: - A _DARTSResult object containing the fitted model and the network architecture. - """ - - _logger.info("Starting fit initialization") - - data_loader, input_dimensions, output_dimensions = _get_data_loader( - X=X, - y=y, - batch_size=batch_size, - ) - - criterion = get_loss_function(ValueType(output_type)) - output_function = get_output_format(ValueType(output_type)) - - if network is None: - network = Network( - num_classes=output_dimensions, - criterion=criterion, - steps=num_graph_nodes, - n_input_states=input_dimensions, - classifier_weight_decay=classifier_weight_decay, - darts_type=DARTSType(darts_type), - primitives=primitives, - train_classifier_coefficients=train_classifier_coefficients, - train_classifier_bias=train_classifier_bias, - ) - - if init_weights_function is not None: - network.apply(init_weights_function) - - # Generate the architecture of the model - architect = Architect( - network, - arch_momentum=arch_momentum, - arch_weight_decay=arch_weight_decay, - arch_weight_decay_df=arch_weight_decay_df, - arch_weight_decay_base=arch_weight_decay_base, - fair_darts_loss_weight=fair_darts_loss_weight, - arch_learning_rate_max=arch_learning_rate_max, - ) - - _logger.info("Starting fit.") - network.train() - - for epoch in _progress_indicator(range(max_epochs)): - - _logger.debug(f"Running fit, epoch {epoch}") - - data_iterator = _get_data_iterator(data_loader) - - # Do the Architecture update - for arch_step in range(arch_updates_per_epoch): - _logger.debug( - f"Running architecture update, " - f"epoch: {epoch}, architecture: {arch_step}" - ) - - X_batch, y_batch = _get_next_input_target( - data_iterator, criterion=criterion - ) - - architect.step( - input_valid=X_batch, - target_valid=y_batch, - network_optimizer=architect.optimizer, - unrolled=False, - ) - - # Then run the param optimization - _optimize_coefficients( - network=network, - criterion=criterion, - data_loader=data_loader, - grad_clip=grad_clip, - param_learning_rate_max=param_learning_rate_max, - param_learning_rate_min=param_learning_rate_min, - param_momentum=param_momentum, - param_update_steps=param_updates_per_epoch, - param_weight_decay=param_weight_decay, - ) - - execution_monitor(**locals()) - - model = _generate_model( - network_=network, - output_type=output_type, - sampling_strategy=sampling_strategy, - data_loader=data_loader, - param_update_steps=param_updates_for_sampled_model, - param_learning_rate_max=param_learning_rate_max, - param_learning_rate_min=param_learning_rate_min, - param_momentum=param_momentum, - param_weight_decay=param_weight_decay, - grad_clip=grad_clip, - ) - - results = _DARTSResult(model=model, network=network) - - return results - - -def _optimize_coefficients( - network: Network, - criterion: torch.nn.Module, - data_loader: torch.utils.data.DataLoader, - grad_clip: float, - param_learning_rate_max: float, - param_learning_rate_min: float, - param_momentum: float, - param_update_steps: int, - param_weight_decay: float, -): - """ - Function to optimize the coefficients of a DARTS Network. - - Warning: This modifies the coefficients of the Network in place. - - Arguments: - network: The DARTS Network to optimize the coefficients of. - criterion: The loss function to use. - data_loader: The data loader to use for the optimization. - grad_clip: Whether to clip the gradients. - param_update_steps: The number of parameter update steps to perform. - param_learning_rate_max: Initial (maximum) learning rate for the operation parameters. - param_learning_rate_min: Final (minimum) learning rate for the operation parameters. - param_momentum: Momentum for the operation parameters. - param_weight_decay: Weight decay for the operation parameters. - """ - optimizer = torch.optim.SGD( - params=network.parameters(), - lr=param_learning_rate_max, - momentum=param_momentum, - weight_decay=param_weight_decay, - ) - scheduler = torch.optim.lr_scheduler.CosineAnnealingLR( - optimizer=optimizer, - T_max=param_update_steps, - eta_min=param_learning_rate_min, - ) - - data_iterator = _get_data_iterator(data_loader) - - objs = AvgrageMeter() - - if network.count_parameters()[0] == 0: - return - - for param_step in range(param_update_steps): - _logger.debug(f"Running parameter update, " f"param: {param_step}") - - lr = scheduler.get_last_lr()[0] - X_batch, y_batch = _get_next_input_target(data_iterator, criterion=criterion) - optimizer.zero_grad() - - # compute loss for the model - logits = network(X_batch) - loss = criterion(logits, y_batch) - - # update gradients for model - loss.backward() - - # clips the gradient norm - torch.nn.utils.clip_grad_norm_(network.parameters(), grad_clip) - - # moves optimizer one step (applies gradients to weights) - optimizer.step() - - # applies weight decay to classifier weights - network.apply_weight_decay_to_classifier(lr) - - # moves the annealing scheduler forward to determine new learning rate - scheduler.step() - - # compute accuracy metrics - n = X_batch.size(0) - objs.update(loss.data, n) - - -def _get_data_loader( - X: np.ndarray, - y: np.ndarray, - batch_size: int, -) -> torch.utils.data.DataLoader: - """Construct a minimal torch.utils.data.DataLoader for the input data. - - Arguments: - X: The input data. - y: The target data. - batch_size: The batch size to use. - - Returns: - A torch.utils.data.DataLoader for the input data. - """ - - X_, y_ = check_X_y(X, y, ensure_2d=True, multi_output=True) - - if y_.ndim == 1: - y_ = y_.reshape((y_.size, 1)) - - input_dimensions = X_.shape[1] - output_dimensions = y_.shape[1] - - experimental_data = darts_dataset_from_ndarray(X_, y_) - - data_loader = torch.utils.data.DataLoader( - experimental_data, - batch_size=batch_size, - shuffle=True, - pin_memory=True, - num_workers=0, - ) - return data_loader, input_dimensions, output_dimensions - - -def _get_data_iterator(data_loader: torch.utils.data.DataLoader) -> Iterator: - """Get an iterator for the data loader. - - Arguments: - data_loader: The data loader to get the iterator for. - - Returns: - An iterator for the data loader. - """ - data_iterator = cycle(iter(data_loader)) - return data_iterator - - -def _get_next_input_target( - data_iterator: Iterator, criterion: torch.nn.Module -) -> Tuple[torch.Tensor, torch.Tensor]: - """ - Get the next input and target from the data iterator. - Args: - data_iterator: The data iterator to get the next input and target from. - criterion: The loss function to use. - - Returns: - The next input and target from the data iterator. - - """ - input_search, target_search = next(data_iterator) - - input_var = torch.autograd.Variable(input_search, requires_grad=False) - target_var = torch.autograd.Variable(target_search, requires_grad=False) - - input_fmt, target_fmt = format_input_target( - input_var, target_var, criterion=criterion - ) - return input_fmt, target_fmt - - -def _generate_model( - network_: Network, - output_type: IMPLEMENTED_OUTPUT_TYPES, - sampling_strategy: SAMPLING_STRATEGIES, - data_loader: torch.utils.data.DataLoader, - param_update_steps: int, - param_learning_rate_max: float, - param_learning_rate_min: float, - param_momentum: float, - param_weight_decay: float, - grad_clip: float, -) -> Network: - """ - Generate a model architecture from mixed DARTS model. - - Arguments: - sampling_strategy: The sampling strategy used to pick the operations - based on the trained architecture weights (e.g. "max", "sample"). - network: The mixed DARTS model. - coefficient_optimizer: The function to optimize the coefficients of the trained model - output_type: The output value type that is used for the output of the sampled model. - param_update_steps: The number of parameter update steps to perform. - param_learning_rate_max: Initial (maximum) learning rate for the operation parameters. - param_learning_rate_min: Final (minimum) learning rate for the operation parameters. - param_momentum: Momentum for the operation parameters. - param_weight_decay: Weight decay for the operation parameters. - - Returns: - A model architecture that is a combination of the trained model and the output function. - """ - criterion = get_loss_function(ValueType(output_type)) - output_function = get_output_format(ValueType(output_type)) - - # Set edges in the network with the highest weights to 1, others to 0 - model_without_output_function = copy.deepcopy(network_) - - if sampling_strategy == "max": - new_weights = model_without_output_function.max_alphas_normal() - elif sampling_strategy == "sample": - new_weights = model_without_output_function.sample_alphas_normal() - - model_without_output_function.fix_architecture(True, new_weights=new_weights) - - # Re-optimize the parameters - - _optimize_coefficients( - model_without_output_function, - criterion=criterion, - data_loader=data_loader, - grad_clip=grad_clip, - param_learning_rate_max=param_learning_rate_max, - param_learning_rate_min=param_learning_rate_min, - param_momentum=param_momentum, - param_update_steps=param_update_steps, - param_weight_decay=param_weight_decay, - ) - - # Include the output function - model = torch.nn.Sequential(model_without_output_function, output_function) - - return model - - -class DARTSRegressor(BaseEstimator, RegressorMixin): - """ - Differentiable ARchiTecture Search Regressor. - - DARTS finds a composition of functions and coefficients to minimize a loss function suitable for - the dependent variable. - - This class is intended to be compatible with the - [Scikit-Learn Estimator API](https://scikit-learn.org/stable/developers/develop.html). - - Examples: - - >>> import numpy as np - >>> num_samples = 1000 - >>> X = np.linspace(start=0, stop=1, num=num_samples).reshape(-1, 1) - >>> y = 15. * np.ones(num_samples) - >>> estimator = DARTSRegressor(num_graph_nodes=1) - >>> estimator = estimator.fit(X, y) - >>> estimator.predict([[0.5]]) - array([[15.051043]], dtype=float32) - - - Attributes: - network_: represents the optimized network for the architecture search, without the - output function - model_: represents the best-fit model including the output function - after sampling of the network to pick a single computation graph. - By default, this is the computation graph with the maximum weights, - but can be set to a graph based on a sample on the edge weights - by running the `resample_model(sample_strategy="sample")` method. - It can be reset by running the `resample_model(sample_strategy="max")` method. - - - - """ - - def __init__( - self, - batch_size: int = 64, - num_graph_nodes: int = 2, - output_type: IMPLEMENTED_OUTPUT_TYPES = "real", - classifier_weight_decay: float = 1e-2, - darts_type: IMPLEMENTED_DARTS_TYPES = "original", - init_weights_function: Optional[Callable] = None, - param_updates_per_epoch: int = 10, - param_updates_for_sampled_model: int = 100, - param_learning_rate_max: float = 2.5e-2, - param_learning_rate_min: float = 0.01, - param_momentum: float = 9e-1, - param_weight_decay: float = 3e-4, - arch_updates_per_epoch: int = 1, - arch_learning_rate_max: float = 3e-3, - arch_weight_decay: float = 1e-4, - arch_weight_decay_df: float = 3e-4, - arch_weight_decay_base: float = 0.0, - arch_momentum: float = 9e-1, - fair_darts_loss_weight: int = 1, - max_epochs: int = 10, - grad_clip: float = 5, - primitives: Sequence[str] = PRIMITIVES, - train_classifier_coefficients: bool = False, - train_classifier_bias: bool = False, - execution_monitor: Callable = (lambda *args, **kwargs: None), - sampling_strategy: SAMPLING_STRATEGIES = "max", - ) -> None: - """ - Initializes the DARTSRegressor. - - Arguments: - batch_size: Batch size for the data loader. - num_graph_nodes: Number of nodes in the desired computation graph. - output_type: Type of output function to use. This function is applied to transform - the output of the mixture architecture. - classifier_weight_decay: Weight decay for the classifier. - darts_type: Type of DARTS to use ('original' or 'fair'). - init_weights_function: Function to initialize the parameters of each operation. - param_updates_per_epoch: Number of updates to perform per epoch. - for the operation parameters. - param_learning_rate_max: Initial (maximum) learning rate for the operation parameters. - param_learning_rate_min: Final (minimum) learning rate for the operation parameters. - param_momentum: Momentum for the operation parameters. - param_weight_decay: Weight decay for the operation parameters. - arch_updates_per_epoch: Number of architecture weight updates to perform per epoch. - arch_learning_rate_max: Initial (maximum) learning rate for the architecture. - arch_weight_decay: Weight decay for the architecture weights. - arch_weight_decay_df: An additional weight decay that scales with the number of - parameters (degrees of freedom) in the operation. The higher this weight decay, - the more DARTS will prefer simple operations. - arch_weight_decay_base: A base weight decay that is added to the scaled weight decay. - arch_momentum: Momentum for the architecture weights. - fair_darts_loss_weight: Weight of the loss in fair darts which forces architecture - weights to become either 0 or 1. - max_epochs: Maximum number of epochs to train for. - grad_clip: Gradient clipping value for updating the parameters of the operations. - primitives: List of primitives (operations) to use. - train_classifier_coefficients: Whether to train the coefficients of the classifier. - train_classifier_bias: Whether to train the bias of the classifier. - execution_monitor: Function to monitor the execution of the model. - primitives: list of primitive operations used in the DARTS network, - e.g., 'add', 'subtract', 'none'. For details, see - [`autora.theorist.darts.operations`][autora.theorist.darts.operations] - """ - - self.batch_size = batch_size - - self.num_graph_nodes = num_graph_nodes - self.classifier_weight_decay = classifier_weight_decay - self.darts_type = darts_type - self.init_weights_function = init_weights_function - - self.param_updates_per_epoch = param_updates_per_epoch - self.param_updates_for_sampled_model = param_updates_for_sampled_model - - self.param_learning_rate_max = param_learning_rate_max - self.param_learning_rate_min = param_learning_rate_min - self.param_momentum = param_momentum - self.arch_momentum = arch_momentum - self.param_weight_decay = param_weight_decay - - self.arch_updates_per_epoch = arch_updates_per_epoch - self.arch_weight_decay = arch_weight_decay - self.arch_weight_decay_df = arch_weight_decay_df - self.arch_weight_decay_base = arch_weight_decay_base - self.arch_learning_rate_max = arch_learning_rate_max - self.fair_darts_loss_weight = fair_darts_loss_weight - - self.max_epochs = max_epochs - self.grad_clip = grad_clip - - self.primitives = primitives - - self.output_type = output_type - self.darts_type = darts_type - - self.X_: Optional[np.ndarray] = None - self.y_: Optional[np.ndarray] = None - self.network_: Optional[Network] = None - self.model_: Optional[Network] = None - - self.train_classifier_coefficients = train_classifier_coefficients - self.train_classifier_bias = train_classifier_bias - - self.execution_monitor = execution_monitor - - self.sampling_strategy = sampling_strategy - - def fit(self, X: np.ndarray, y: np.ndarray): - """ - Runs the optimization for a given set of `X`s and `y`s. - - Arguments: - X: independent variables in an n-dimensional array - y: dependent variables in an n-dimensional array - - Returns: - self (DARTSRegressor): the fitted estimator - """ - - if self.output_type == "class": - raise NotImplementedError( - "Classification not implemented for DARTSRegressor." - ) - - params = self.get_params() - - fit_results = _general_darts(X=X, y=y, network=self.network_, **params) - self.X_ = X - self.y_ = y - self.network_ = fit_results.network - self.model_ = fit_results.model - return self - - def predict(self, X: np.ndarray) -> np.ndarray: - """ - Applies the fitted model to a set of independent variables `X`, - to give predictions for the dependent variable `y`. - - Arguments: - X: independent variables in an n-dimensional array - - Returns: - y: predicted dependent variable values - """ - X_ = check_array(X) - - # First run the checks using the scikit-learn API, listing the key parameters - check_is_fitted(self, attributes=["model_"]) - - # Since self.model_ is initialized as None, mypy throws an error if we - # just call self.model_(X) in the predict method, as it could still be none. - # MyPy doesn't understand that the sklearn check_is_fitted function - # ensures the self.model_ parameter is initialized and otherwise throws an error, - # so we check that explicitly here and pass the model which can't be None. - assert self.model_ is not None - - y_ = self.model_(torch.as_tensor(X_).float()) - y = y_.detach().numpy() - - return y - - def visualize_model( - self, - input_labels: Optional[Sequence[str]] = None, - ): - """ - Visualizes the model architecture as a graph. - - Arguments: - input_labels: labels for the input nodes - - """ - - check_is_fitted(self, attributes=["model_"]) - assert self.model_ is not None - fitted_sampled_network = self.model_[0] - - genotype = Network.genotype(fitted_sampled_network).normal - ( - _, - _, - param_list, - ) = fitted_sampled_network.count_parameters() - - if input_labels is not None: - input_labels_ = tuple(input_labels) - else: - input_labels_ = self._get_input_labels() - - assert self.y_ is not None - out_dim = 1 if self.y_.ndim == 1 else self.y_.shape[1] - - out_func = get_output_str(ValueType(self.output_type)) - - # call to plot function - graph = darts_model_plot( - genotype=genotype, - input_labels=input_labels_, - param_list=param_list, - full_label=True, - out_dim=out_dim, - out_fnc=out_func, - ) - - return graph - - def _get_input_labels(self): - """ - Returns the input labels for the model. - - Returns: - input_labels: labels for the input nodes - - """ - return self._get_labels(self.X_, "x") - - def _get_output_labels(self): - """ - Returns the output labels for the model. - - Returns: - output_labels: labels for the output nodes - - """ - return self._get_labels(self.y_, "y") - - def _get_labels( - self, data: Optional[np.ndarray], default_label: str - ) -> Sequence[str]: - """ - Returns the labels for the model. - - Arguments: - data: data to get labels for - default_label: default label to use if no labels are provided - - Returns: - labels: labels for the model - - """ - assert data is not None - - if hasattr(data, "columns"): # it's a dataframe with column names - labels_ = tuple(data.columns) - elif ( - hasattr(data, "name") and len(data.shape) == 1 - ): # it's a single series with a single name - labels_ = (data.name,) - - else: - dim = 1 if data.ndim == 1 else data.shape[1] - labels_ = tuple(f"{default_label}{i+1}" for i in range(dim)) - return labels_ - - def model_repr( - self, - input_labels: Optional[Sequence[str]] = None, - output_labels: Optional[Sequence[str]] = None, - output_function_label: str = "", - decimals_to_display: int = 2, - output_format: Literal["latex", "console"] = "console", - ) -> str: - """ - Prints the equations of the model architecture. - - Args: - input_labels: which names to use for the independent variables (X) - output_labels: which names to use for the dependent variables (y) - output_function_label: name to use for the output transformation - decimals_to_display: amount of rounding for the coefficient values - output_format: whether the output should be formatted for - the command line (`console`) or as equations in a latex file (`latex`) - - Returns: - The equations of the model architecture - - """ - assert self.model_ is not None - fitted_sampled_network: Network = self.model_[0] - - if input_labels is None: - input_labels_ = self._get_input_labels() - else: - input_labels_ = input_labels - - if output_labels is None: - output_labels_ = self._get_output_labels() - else: - output_labels_ = output_labels - - edge_list = fitted_sampled_network.architecture_to_str_list( - input_labels=input_labels_, - output_labels=output_labels_, - output_function_label=output_function_label, - decimals_to_display=decimals_to_display, - output_format=output_format, - ) - - model_repr_ = "\n".join(["Model:"] + edge_list) - return model_repr_ - - -class DARTSExecutionMonitor: - """ - A monitor of the execution of the DARTS algorithm. - """ - - def __init__(self): - """ - Initializes the execution monitor. - """ - self.arch_weight_history = list() - self.loss_history = list() - self.epoch_history = list() - self.primitives = list() - - def execution_monitor( - self, - network: Network, - architect: Architect, - epoch: int, - **kwargs: Any, - ): - """ - A function to monitor the execution of the DARTS algorithm. - - Arguments: - network: The DARTS network containing the weights each operation - in the mixture architecture - architect: The architect object used to construct the mixture architecture. - epoch: The current epoch of the training. - **kwargs: other parameters which may be passed from the DARTS optimizer - """ - - # collect data for visualization - self.epoch_history.append(epoch) - self.arch_weight_history.append( - network.arch_parameters()[0].detach().numpy().copy()[np.newaxis, :] - ) - self.loss_history.append(architect.current_loss) - self.primitives = network.primitives - - def display(self): - """ - A function to display the execution monitor. This function will generate two plots: - (1) A plot of the training loss vs. epoch, - (2) a plot of the architecture weights vs. epoch, divided into subplots by each edge - in the mixture architecture. - """ - - loss_fig, loss_ax = plt.subplots(1, 1) - loss_ax.plot(self.loss_history) - - loss_ax.set_ylabel("Loss", fontsize=14) - loss_ax.set_xlabel("Epoch", fontsize=14) - loss_ax.set_title("Training Loss") - - arch_weight_history_array = np.vstack(self.arch_weight_history) - num_epochs, num_edges, num_primitives = arch_weight_history_array.shape - - subplots_per_side = int(np.ceil(np.sqrt(num_edges))) - - arch_fig, arch_axes = plt.subplots( - subplots_per_side, - subplots_per_side, - sharex=True, - sharey=True, - figsize=(10, 10), - squeeze=False, - ) - - arch_fig.suptitle("Architecture Weights", fontsize=10) - - for (edge_i, ax) in zip(range(num_edges), arch_axes.flat): - for primitive_i in range(num_primitives): - print(f"{edge_i}, {primitive_i}, {ax}") - ax.plot( - arch_weight_history_array[:, edge_i, primitive_i], - label=f"{self.primitives[primitive_i]}", - ) - - ax.set_title("k{}".format(edge_i), fontsize=8) - - # there is no need to have the legend for each subplot - if edge_i == 0: - ax.legend(loc="upper center") - ax.set_ylabel("Edge Weights", fontsize=8) - ax.set_xlabel("Epoch", fontsize=8) - - return SimpleNamespace( - loss_fig=loss_fig, - loss_ax=loss_ax, - arch_fig=arch_fig, - arch_axes=arch_axes, - ) diff --git a/autora/synthetic/__init__.py b/autora/synthetic/__init__.py deleted file mode 100644 index e2d0b94aa..000000000 --- a/autora/synthetic/__init__.py +++ /dev/null @@ -1,77 +0,0 @@ -""" -Provides an interface for loading and saving synthetic experiments. - -Examples: - The registry is accessed using the `retrieve` function, optionally setting parameters: - >>> from autora.synthetic import retrieve, describe - >>> import numpy as np - >>> s = retrieve("weber_fechner",rng=np.random.default_rng(seed=180)) # the Weber-Fechner Law - - Use the describe function to give information about the synthetic experiment: - >>> describe(s) # doctest: +ELLIPSIS +NORMALIZE_WHITESPACE - Weber-Fechner Law... - - The synthetic experiement `s` has properties like the name of the experiment: - >>> s.name - 'Weber-Fechner Law' - - ... a valid metadata description: - >>> s.metadata # doctest: +ELLIPSIS - VariableCollection(...) - - ... a function to generate the full domain of the data (if possible) - >>> x = s.domain() - >>> x # doctest: +ELLIPSIS - array([[0...]]) - - ... the experiment_runner runner which can be called to generate experimental results: - >>> import numpy as np - >>> y = s.experiment_runner(x) # doctest: +ELLIPSIS - >>> y - array([[ 0.00433955], - [ 1.79114625], - [ 2.39473454], - ..., - [ 0.00397802], - [ 0.01922405], - [-0.00612883]]) - - ... a function to plot the ground truth: - >>> s.plotter() - - ... against a fitted model if it exists: - >>> from sklearn.linear_model import LinearRegression - >>> model = LinearRegression().fit(x, y) - >>> s.plotter(model) - - These can be used to run a full experimental cycle - >>> from autora.experimentalist.pipeline import make_pipeline - >>> from autora.experimentalist.pooler.general_pool import grid_pool - >>> from autora.experimentalist.sampler.random import random_sampler - >>> from functools import partial - >>> import random - >>> metadata = s.metadata - >>> pool = partial(grid_pool, ivs=metadata.independent_variables) - >>> random.seed(181) # set the seed for the random sampler - >>> sampler = partial(random_sampler, n=20) - >>> experimentalist_pipeline = make_pipeline([pool, sampler]) - - >>> from autora.cycle import Cycle - >>> theorist = LinearRegression() - - >>> cycle = Cycle(metadata=metadata, experimentalist=experimentalist_pipeline, - ... experiment_runner=s.experiment_runner, theorist=theorist) - - >>> c = cycle.run(10) - >>> c.data.theories[-1].coef_ # doctest: +ELLIPSIS - array([-0.53610647, 0.58457307]) -""" - -from autora.synthetic import data -from autora.synthetic.inventory import ( - Inventory, - SyntheticExperimentCollection, - describe, - register, - retrieve, -) diff --git a/autora/synthetic/data/__init__.py b/autora/synthetic/data/__init__.py deleted file mode 100644 index 394d81233..000000000 --- a/autora/synthetic/data/__init__.py +++ /dev/null @@ -1,2 +0,0 @@ -""" Models bundled with AutoRA. """ -from . import expected_value, prospect_theory, weber_fechner diff --git a/autora/synthetic/data/expected_value.py b/autora/synthetic/data/expected_value.py deleted file mode 100644 index a5c86f937..000000000 --- a/autora/synthetic/data/expected_value.py +++ /dev/null @@ -1,184 +0,0 @@ -from functools import partial - -import numpy as np - -from autora.variable import DV, IV, ValueType, VariableCollection - -from ..inventory import SyntheticExperimentCollection, register - - -def get_metadata(minimum_value, maximum_value, resolution): - v_a = IV( - name="V_A", - allowed_values=np.linspace( - minimum_value, - maximum_value, - resolution, - ), - value_range=(minimum_value, maximum_value), - units="dollar", - variable_label="Value of Option A", - type=ValueType.REAL, - ) - - v_b = IV( - name="V_B", - allowed_values=np.linspace( - minimum_value, - maximum_value, - resolution, - ), - value_range=(minimum_value, maximum_value), - units="dollar", - variable_label="Value of Option B", - type=ValueType.REAL, - ) - - p_a = IV( - name="P_A", - allowed_values=np.linspace(0, 1, resolution), - value_range=(0, 1), - units="probability", - variable_label="Probability of Option A", - type=ValueType.REAL, - ) - - p_b = IV( - name="P_B", - allowed_values=np.linspace(0, 1, resolution), - value_range=(0, 1), - units="probability", - variable_label="Probability of Option B", - type=ValueType.REAL, - ) - - dv1 = DV( - name="choose_A", - value_range=(0, 1), - units="probability", - variable_label="Probability of Choosing Option A", - type=ValueType.PROBABILITY, - ) - - metadata_ = VariableCollection( - independent_variables=[v_a, p_a, v_b, p_b], - dependent_variables=[dv1], - ) - return metadata_ - - -def expected_value_theory( - name="Expected Value Theory", - choice_temperature: float = 0.1, - value_lambda: float = 0.5, - resolution=10, - minimum_value=-1, - maximum_value=1, - added_noise: float = 0.01, - rng=np.random.default_rng(), -): - - params = dict( - name=name, - minimum_value=minimum_value, - maximum_value=maximum_value, - resolution=resolution, - choice_temperature=choice_temperature, - value_lambda=value_lambda, - added_noise=added_noise, - random_number_generator=rng, - ) - - metadata = get_metadata( - minimum_value=minimum_value, maximum_value=maximum_value, resolution=resolution - ) - - def experiment_runner(X: np.ndarray, added_noise_=added_noise): - - Y = np.zeros((X.shape[0], 1)) - for idx, x in enumerate(X): - value_A = value_lambda * x[0] - value_B = value_lambda * x[2] - - probability_a = x[1] - probability_b = x[3] - - expected_value_A = value_A * probability_a + rng.normal(0, added_noise_) - expected_value_B = value_B * probability_b + rng.normal(0, added_noise_) - - # compute probability of choosing option A - p_choose_A = np.exp(expected_value_A / choice_temperature) / ( - np.exp(expected_value_A / choice_temperature) - + np.exp(expected_value_B / choice_temperature) - ) - - Y[idx] = p_choose_A - - return Y - - ground_truth = partial(experiment_runner, added_noise_=0.0) - - def domain(): - X = np.array( - np.meshgrid([x.allowed_values for x in metadata.independent_variables]) - ).T.reshape(-1, 4) - return X - - def plotter(model=None): - import matplotlib.colors as mcolors - import matplotlib.pyplot as plt - - v_a_list = [-1, 0.5, 1] - v_b = 0.5 - p_b = 0.5 - p_a = np.linspace(0, 1, 100) - - for idx, v_a in enumerate(v_a_list): - X = np.zeros((len(p_a), 4)) - X[:, 0] = v_a - X[:, 1] = p_a - X[:, 2] = v_b - X[:, 3] = p_b - - y = ground_truth(X) - colors = mcolors.TABLEAU_COLORS - col_keys = list(colors.keys()) - plt.plot( - p_a, y, label=f"$V(A) = {v_a}$ (Original)", c=colors[col_keys[idx]] - ) - if model is not None: - y = model.predict(X) - plt.plot( - p_a, - y, - label=f"$V(A) = {v_a}$ (Recovered)", - c=colors[col_keys[idx]], - linestyle="--", - ) - - x_limit = [0, metadata.independent_variables[1].value_range[1]] - y_limit = [0, 1] - x_label = "Probability of Choosing Option A" - y_label = "Probability of Obtaining V(A)" - - plt.xlim(x_limit) - plt.ylim(y_limit) - plt.xlabel(x_label, fontsize="large") - plt.ylabel(y_label, fontsize="large") - plt.legend(loc=2, fontsize="medium") - plt.title(name, fontsize="x-large") - plt.show() - - collection = SyntheticExperimentCollection( - name=name, - metadata=metadata, - experiment_runner=experiment_runner, - ground_truth=ground_truth, - domain=domain, - plotter=plotter, - params=params, - ) - return collection - - -register("expected_value", expected_value_theory) diff --git a/autora/synthetic/data/prospect_theory.py b/autora/synthetic/data/prospect_theory.py deleted file mode 100644 index 2344e790b..000000000 --- a/autora/synthetic/data/prospect_theory.py +++ /dev/null @@ -1,198 +0,0 @@ -from functools import partial - -import numpy as np - -from ..inventory import SyntheticExperimentCollection, register -from .expected_value import get_metadata - - -def prospect_theory( - name="Prospect Theory", - added_noise=0.01, - choice_temperature=0.1, - value_alpha=0.88, - value_beta=0.88, - value_lambda=2.25, - probability_alpha=0.61, - probability_beta=0.69, - resolution=10, - minimum_value=-1, - maximum_value=1, - rng=np.random.default_rng(), -): - """ - Parameters from - D. Kahneman, A. Tversky, Prospect theory: An analysis of decision under risk. - Econometrica 47, 263–292 (1979). doi:10.2307/1914185 - - Power value function according to: - - A. Tversky, D. Kahneman, Advances in prospect theory: Cumulative representation of - uncertainty. J. Risk Uncertain. 5, 297–323 (1992). doi:10.1007/BF00122574 - - - I. Gilboa, Expected utility with purely subjective non-additive probabilities. - J. Math. Econ. 16, 65–88 (1987). doi:10.1016/0304-4068(87)90022-X - - - D. Schmeidler, Subjective probability and expected utility without additivity. - Econometrica 57, 571 (1989). doi:10.2307/1911053 - - Probability function according to: - A. Tversky, D. Kahneman, Advances in prospect theory: Cumulative representation of - uncertainty. J. Risk Uncertain. 5, 297–323 (1992). doi:10.1007/BF00122574 - - """ - - params = dict( - added_noise=added_noise, - choice_temperature=choice_temperature, - value_alpha=value_alpha, - value_beta=value_beta, - value_lambda=value_lambda, - probability_alpha=probability_alpha, - probability_beta=probability_beta, - resolution=resolution, - minimum_value=minimum_value, - maximum_value=maximum_value, - rng=rng, - name=name, - ) - - metadata = get_metadata( - minimum_value=minimum_value, maximum_value=maximum_value, resolution=resolution - ) - - def experiment_runner(X: np.ndarray, added_noise_=added_noise): - - Y = np.zeros((X.shape[0], 1)) - for idx, x in enumerate(X): - - # power value function according to: - - # A. Tversky, D. Kahneman, Advances in prospect theory: Cumulative representation of - # uncertainty. J. Risk Uncertain. 5, 297–323 (1992). doi:10.1007/BF00122574 - - # I. Gilboa, Expected utility with purely subjective non-additive probabilities. - # J. Math. Econ. 16, 65–88 (1987). doi:10.1016/0304-4068(87)90022-X - - # D. Schmeidler, Subjective probability and expected utility without additivity. - # Econometrica 57, 571 (1989). doi:10.2307/1911053 - - # compute value of option A - if x[0] > 0: - value_A = x[0] ** value_alpha - else: - value_A = -value_lambda * (-x[0]) ** (value_beta) - - # compute value of option B - if x[2] > 0: - value_B = x[2] ** value_alpha - else: - value_B = -value_lambda * (-x[2]) ** (value_beta) - - # probability function according to: - - # A. Tversky, D. Kahneman, Advances in prospect theory: Cumulative representation of - # uncertainty. J. Risk Uncertain. 5, 297–323 (1992). doi:10.1007/BF00122574 - - # compute probability of option A - if x[0] >= 0: - coefficient = probability_alpha - else: - coefficient = probability_beta - - probability_a = x[1] ** coefficient / ( - x[1] ** coefficient + (1 - x[1]) ** coefficient - ) ** (1 / coefficient) - - # compute probability of option B - if x[2] >= 0: - coefficient = probability_alpha - else: - coefficient = probability_beta - - probability_b = x[3] ** coefficient / ( - x[3] ** coefficient + (1 - x[3]) ** coefficient - ) ** (1 / coefficient) - - expected_value_A = value_A * probability_a + rng.normal(0, added_noise_) - expected_value_B = value_B * probability_b + rng.normal(0, added_noise_) - - # compute probability of choosing option A - p_choose_A = np.exp(expected_value_A / choice_temperature) / ( - np.exp(expected_value_A / choice_temperature) - + np.exp(expected_value_B / choice_temperature) - ) - - Y[idx] = p_choose_A - - return Y - - ground_truth = partial(experiment_runner, added_noise_=0.0) - - def domain(): - v_a = metadata.independent_variables[0].allowed_values - p_a = metadata.independent_variables[1].allowed_values - v_b = metadata.independent_variables[2].allowed_values - p_b = metadata.independent_variables[3].allowed_values - - X = np.array(np.meshgrid(v_a, p_a, v_b, p_b)).T.reshape(-1, 4) - return X - - def plotter(model=None): - import matplotlib.colors as mcolors - import matplotlib.pyplot as plt - - v_a_list = [-0.5, 0.5, 1] - p_a = np.linspace(0, 1, 100) - - v_b = 0.5 - p_b = 0.5 - - for idx, v_a in enumerate(v_a_list): - X = np.zeros((len(p_a), 4)) - X[:, 0] = v_a - X[:, 1] = p_a - X[:, 2] = v_b - X[:, 3] = p_b - - y = ground_truth(X) - colors = mcolors.TABLEAU_COLORS - col_keys = list(colors.keys()) - plt.plot( - p_a, y, label=f"$V(A) = {v_a}$ (Original)", c=colors[col_keys[idx]] - ) - if model is not None: - y = model.predict(X) - plt.plot( - p_a, - y, - label=f"$V(A) = {v_a}$ (Recovered)", - c=colors[col_keys[idx]], - linestyle="--", - ) - - x_limit = [0, metadata.independent_variables[1].value_range[1]] - y_limit = [0, 1] - x_label = "Probability of Choosing Option A" - y_label = "Probability of Obtaining V(A)" - - plt.xlim(x_limit) - plt.ylim(y_limit) - plt.xlabel(x_label, fontsize="large") - plt.ylabel(y_label, fontsize="large") - plt.legend(loc=2, fontsize="medium") - plt.title(name, fontsize="x-large") - plt.show() - - collection = SyntheticExperimentCollection( - name=name, - params=params, - metadata=metadata, - domain=domain, - experiment_runner=experiment_runner, - ground_truth=ground_truth, - plotter=plotter, - ) - return collection - - -register("prospect_theory", prospect_theory) diff --git a/autora/synthetic/data/weber_fechner.py b/autora/synthetic/data/weber_fechner.py deleted file mode 100644 index ac5e56ab4..000000000 --- a/autora/synthetic/data/weber_fechner.py +++ /dev/null @@ -1,158 +0,0 @@ -from functools import partial - -import numpy as np - -from autora.variable import DV, IV, ValueType, VariableCollection - -from ..inventory import SyntheticExperimentCollection, register - - -def weber_fechner_law( - name="Weber-Fechner Law", - resolution=100, - constant=1.0, - maximum_stimulus_intensity=5.0, - added_noise=0.01, - rng=np.random.default_rng(), -): - """Weber-Fechner Law. - - Args: - name: name of the experiment - resolution: number of allowed values for stimulus 1 and 2 - constant: constant multiplier - maximum_stimulus_intensity: maximum value for stimulus 1 and 2 - added_noise: standard deviation of normally distributed noise added to y-values - rng: `np.random` random number generator to use for generating noise - - Returns: - - """ - - params = dict( - added_noise=added_noise, - name=name, - resolution=resolution, - constant=constant, - maximum_stimulus_intensity=maximum_stimulus_intensity, - rng=rng, - ) - - iv1 = IV( - name="S1", - allowed_values=np.linspace( - 1 / resolution, maximum_stimulus_intensity, resolution - ), - value_range=(1 / resolution, maximum_stimulus_intensity), - units="intensity", - variable_label="Stimulus 1 Intensity", - type=ValueType.REAL, - ) - - iv2 = IV( - name="S2", - allowed_values=np.linspace( - 1 / resolution, maximum_stimulus_intensity, resolution - ), - value_range=(1 / resolution, maximum_stimulus_intensity), - units="intensity", - variable_label="Stimulus 2 Intensity", - type=ValueType.REAL, - ) - - dv1 = DV( - name="difference_detected", - value_range=(0, maximum_stimulus_intensity), - units="sensation", - variable_label="Sensation", - type=ValueType.REAL, - ) - - metadata = VariableCollection( - independent_variables=[iv1, iv2], - dependent_variables=[dv1], - ) - - def experiment_runner( - X: np.ndarray, - std: float = 0.01, - ): - Y = np.zeros((X.shape[0], 1)) - for idx, x in enumerate(X): - # jnd = np.min(x) * weber_constant - # response = (x[1]-x[0]) - jnd - # y = 1/(1+np.exp(-response)) + np.random.normal(0, std) - y = constant * np.log(x[1] / x[0]) + rng.normal(0, std) - Y[idx] = y - - return Y - - ground_truth = partial(experiment_runner, std=0.0) - - def domain(): - s1_values = metadata.independent_variables[0].allowed_values - s2_values = metadata.independent_variables[1].allowed_values - X = np.array(np.meshgrid(s1_values, s2_values)).T.reshape(-1, 2) - # remove all combinations where s1 > s2 - X = X[X[:, 0] <= X[:, 1]] - return X - - def plotter( - model=None, - ): - import matplotlib.colors as mcolors - import matplotlib.pyplot as plt - - colors = mcolors.TABLEAU_COLORS - col_keys = list(colors.keys()) - - S0_list = [1, 2, 4] - delta_S = np.linspace(0, 5, 100) - - for idx, S0_value in enumerate(S0_list): - S0 = S0_value + np.zeros(delta_S.shape) - S1 = S0 + delta_S - X = np.array([S0, S1]).T - y = ground_truth(X) - plt.plot( - delta_S, - y, - label=f"$S_0 = {S0_value}$ (Original)", - c=colors[col_keys[idx]], - ) - if model is not None: - y = model.predict(X) - plt.plot( - delta_S, - y, - label=f"$S_0 = {S0_value}$ (Recovered)", - c=colors[col_keys[idx]], - linestyle="--", - ) - - x_limit = [0, metadata.independent_variables[0].value_range[1]] - y_limit = [0, 2] - x_label = r"Stimulus Intensity Difference $\Delta S = S_1 - S_0$" - y_label = "Perceived Intensity of Stimulus $S_1$" - - plt.xlim(x_limit) - plt.ylim(y_limit) - plt.xlabel(x_label, fontsize="large") - plt.ylabel(y_label, fontsize="large") - plt.legend(loc=2, fontsize="medium") - plt.title("Weber-Fechner Law", fontsize="x-large") - plt.show() - - collection = SyntheticExperimentCollection( - name=name, - metadata=metadata, - experiment_runner=experiment_runner, - ground_truth=ground_truth, - domain=domain, - plotter=plotter, - params=params, - ) - return collection - - -register("weber_fechner", weber_fechner_law) diff --git a/autora/synthetic/inventory.py b/autora/synthetic/inventory.py deleted file mode 100644 index 4d75be832..000000000 --- a/autora/synthetic/inventory.py +++ /dev/null @@ -1,205 +0,0 @@ -""" -Module for registering and retrieving synthetic models from an inventory. - -Examples: - To add and recover a new model from the inventory, we need to define it using a function - (closure). - We start by importing the modules we'll need: - >>> from functools import partial - >>> import matplotlib.pyplot as plt - >>> import numpy as np - >>> from autora.synthetic import register, retrieve, describe, SyntheticExperimentCollection - >>> from autora.variable import IV, DV, VariableCollection - - Then we can define the function. We define all the arguments we want and add them to a - dictionary. The closure – in this case `sinusoid_experiment` – is the scope for all - the parameters we need. - >>> def sinusoid_experiment(omega=np.pi/3, delta=np.pi/2., m=0.3, resolution=1000, - ... rng=np.random.default_rng()): - ... \"\"\"Shifted sinusoid experiment, combining a sinusoid and a gradient drift. - ... Ground truth: y = sin((x - delta) * omega) + (x * m) - ... Parameters: - ... omega: angular speed in radians - ... delta: offset in radians - ... m: drift gradient in [radians ^ -1] - ... resolution: number of x values - ... \"\"\" - ... - ... name = "Shifted Sinusoid" - ... - ... params = dict(omega=omega, delta=delta, resolution=resolution, m=m, rng=rng) - ... - ... x = IV(name="x", value_range=(-6 * np.pi, 6 * np.pi)) - ... y = DV(name="y", value_range=(-1, 1)) - ... metadata = VariableCollection(independent_variables=[x], dependent_variables=[y]) - ... - ... def domain(): - ... return np.linspace(*x.value_range, resolution).reshape(-1, 1) - ... - ... def experiment_runner(X, std=0.1): - ... return np.sin((X - delta) * omega) + (X * m) + rng.normal(0, std, X.shape) - ... - ... def ground_truth(X): - ... return experiment_runner(X, std=0.) - ... - ... def plotter(model=None): - ... plt.plot(domain(), ground_truth(domain()), label="Ground Truth") - ... if model is not None: - ... plt.plot(domain(), model.predict(domain()), label="Model") - ... plt.title(name) - ... - ... collection = SyntheticExperimentCollection( - ... name=name, - ... params=params, - ... metadata=metadata, - ... domain=domain, - ... experiment_runner=experiment_runner, - ... ground_truth=ground_truth, - ... plotter=plotter, - ... ) - ... - ... return collection - - Then we can register the experiment. We register the function, rather than evaluating it. - >>> register("sinusoid_experiment", sinusoid_experiment) - - When we want to retrieve the experiment, we can just use the default values if we like: - >>> s = retrieve("sinusoid_experiment") - - We can retrieve the docstring of the model using the `describe` function - >>> describe(s) # doctest: +ELLIPSIS - Shifted sinusoid experiment, combining a sinusoid and a gradient drift. - Ground truth: y = sin((x - delta) * omega) + (x * m) - ... - - ... or using its id: - >>> describe("sinusoid_experiment") # doctest: +ELLIPSIS - Shifted sinusoid experiment, combining a sinusoid and a gradient drift. - Ground truth: y = sin((x - delta) * omega) + (x * m) - ... - - ... or we can look at the closure function directly: - >>> describe(sinusoid_experiment) # doctest: +ELLIPSIS - Shifted sinusoid experiment, combining a sinusoid and a gradient drift. - Ground truth: y = sin((x - delta) * omega) + (x * m) - ... - - The object returned includes all the used parameters as a dictionary - >>> s.params # doctest: +ELLIPSIS - {'omega': 1.0..., 'delta': 1.5..., 'resolution': 1000, 'm': 0.3, ...} - - If we need to modify the parameter values, we can pass them as arguments to the retrieve - function: - >>> t = retrieve("sinusoid_experiment",delta=0.2) - >>> t.params # doctest: +ELLIPSIS - {..., 'delta': 0.2, ...} -""" - - -from __future__ import annotations - -from dataclasses import dataclass -from functools import singledispatch -from typing import Any, Callable, Dict, Optional, Protocol, runtime_checkable - -from autora.variable import VariableCollection - - -@runtime_checkable -class _SyntheticExperimentClosure(Protocol): - """A function which returns a SyntheticExperimentCollection.""" - - def __call__(self, *args, **kwargs) -> SyntheticExperimentCollection: - ... - - -class _SupportsPredict(Protocol): - def predict(self, X) -> Any: - ... - - -@dataclass -class SyntheticExperimentCollection: - """ - Represents a synthetic experiment. - - Attributes: - name: the name of the theory - params: a dictionary with the settable parameters of the model and their respective values - metadata: a VariableCollection describing the variables of the model - domain: a function which returns all the available X values for the model - experiment_runner: a function which takes X values and returns simulated y values **with - statistical noise** - ground_truth: a function which takes X values and returns simulated y values **without any - statistical noise** - plotter: a function which plots the ground truth and, optionally, a model with a - `predict` method (e.g. scikit-learn estimators) - """ - - name: Optional[str] = None - params: Optional[Dict] = None - metadata: Optional[VariableCollection] = None - domain: Optional[Callable] = None - experiment_runner: Optional[Callable] = None - ground_truth: Optional[Callable] = None - plotter: Optional[Callable[[Optional[_SupportsPredict]], None]] = None - closure: Optional[Callable] = None - - -Inventory: Dict[str, _SyntheticExperimentClosure] = dict() -""" The dictionary of `SyntheticExperimentCollection`. """ - - -def register(id_: str, closure: _SyntheticExperimentClosure) -> None: - """ - Add a new synthetic experiment to the Inventory. - - Parameters: - id_: the unique id for the model. - closure: a function which returns a SyntheticExperimentCollection - - """ - Inventory[id_] = closure - - -def retrieve(id_: str, **kwargs) -> SyntheticExperimentCollection: - """ - Retrieve a synthetic experiment from the Inventory. - - Parameters: - id_: the unique id for the model - **kwargs: keyword arguments for the synthetic experiment (metadata, coefficients etc.) - Returns: - the synthetic experiment - """ - closure: _SyntheticExperimentClosure = Inventory[id_] - evaluated_closure = closure(**kwargs) - evaluated_closure.closure = closure - return evaluated_closure - - -@singledispatch -def describe(arg): - """ - Print the docstring for a synthetic experiment. - - Args: - arg: the experiment's ID, an object returned from the `retrieve` function, or a closure - which creates a new experiment. - """ - raise NotImplementedError(f"{arg=} not yet supported") - - -@describe.register -def _(closure: _SyntheticExperimentClosure): - print(closure.__doc__) - - -@describe.register -def _(collection: SyntheticExperimentCollection): - describe(collection.closure) - - -@describe.register -def _(id_: str): - describe(retrieve(id_)) diff --git a/autora/theorist/__init__.py b/autora/theorist/__init__.py deleted file mode 100644 index e69de29bb..000000000 diff --git a/autora/theorist/bms/__init__.py b/autora/theorist/bms/__init__.py deleted file mode 100644 index ce93fbce6..000000000 --- a/autora/theorist/bms/__init__.py +++ /dev/null @@ -1,3 +0,0 @@ -from .mcmc import Tree # noqa: F401 -from .parallel import Parallel # noqa: F401 -from .prior import get_priors # noqa: F401 diff --git a/autora/theorist/bms/data/named_equations.wiki.parsed__num_operations.dat b/autora/theorist/bms/data/named_equations.wiki.parsed__num_operations.dat deleted file mode 100644 index 37fbb6085..000000000 --- a/autora/theorist/bms/data/named_equations.wiki.parsed__num_operations.dat +++ /dev/null @@ -1,30 +0,0 @@ -0 2213 -1 572 -2 296 -3 242 -4 168 -5 136 -6 111 -7 83 -8 60 -9 45 -10 26 -11 38 -12 20 -13 20 -14 11 -15 10 -16 6 -17 3 -18 6 -19 2 -20 2 -21 1 -24 1 -26 2 -27 1 -28 1 -31 1 -34 1 -38 1 -52 1 diff --git a/autora/theorist/bms/data/named_equations.wiki.parsed__operation_type.dat b/autora/theorist/bms/data/named_equations.wiki.parsed__operation_type.dat deleted file mode 100644 index 7d25e54f1..000000000 --- a/autora/theorist/bms/data/named_equations.wiki.parsed__operation_type.dat +++ /dev/null @@ -1,18 +0,0 @@ -sinh 5 -cos 65 -log 132 -tanh 6 -pow2 547 -- 520 -abs 27 -sqrt 130 -cosh 4 -fac 7 -+ 1271 -** 652 -exp 129 -pow3 38 -* 2774 -/ 1146 -sin 39 -tan 4 diff --git a/autora/theorist/bms/data/named_equations.wiki.parsed__operation_type_sq.dat b/autora/theorist/bms/data/named_equations.wiki.parsed__operation_type_sq.dat deleted file mode 100644 index 32397b302..000000000 --- a/autora/theorist/bms/data/named_equations.wiki.parsed__operation_type_sq.dat +++ /dev/null @@ -1,18 +0,0 @@ -sinh 5 -cos 113 -log 156 -tanh 6 -pow2 1193 -- 738 -abs 31 -sqrt 266 -cosh 4 -fac 9 -+ 2981 -** 1328 -exp 163 -pow3 50 -* 9374 -/ 2260 -sin 41 -tan 4 diff --git a/autora/theorist/bms/fit_prior.py b/autora/theorist/bms/fit_prior.py deleted file mode 100644 index abe7ca512..000000000 --- a/autora/theorist/bms/fit_prior.py +++ /dev/null @@ -1,278 +0,0 @@ -from datetime import datetime -from optparse import OptionParser -from random import choice, random - -from .mcmc import Tree -from .prior import get_priors - - -# ----------------------------------------------------------------------------- -def parse_options(): - """Parse command-line arguments.""" - parser = OptionParser() - parser.add_option( - "-s", - "--source", - dest="source", - default="named_equations", - help="formula dataset to use ('full' or 'named_equations' (default))", - ) - parser.add_option( - "-n", - "--nvar", - dest="nvar", - type="int", - default=5, - help="number of variables to include (default 5)", - ) - parser.add_option( - "-m", - "--npar", - dest="npar", - type="int", - default=None, - help="number of parameters to include (default: 2*NVAR)", - ) - parser.add_option( - "-f", - "--factor", - dest="fact", - type="float", - default=0.05, - help="factor for the parameter adjustment (default 0.05)", - ) - parser.add_option( - "-r", - "--repetitions", - type="int", - default=1000000, - dest="nrep", - help="formulas to generate between parameter updates", - ) - parser.add_option( - "-M", - "--maxsize", - type="int", - default=50, - dest="max_size", - help="maximum tree (formula) size", - ) - parser.add_option( - "-c", - "--continue", - dest="contfile", - default=None, - help="continue from parameter values in CONTFILE (default: start from scratch)", - ) - parser.add_option( - "-q", - "--quadratic", - action="store_true", - dest="quadratic", - default=False, - help="fit parameters for quadratic terms (default: False)", - ) - return parser - - -# ----------------------------------------------------------------------------- -def read_target_values(source, quadratic=False): - """Read the target proportions for each type of operation.""" - # Number of formulas - infn1 = "./data/%s.wiki.parsed__num_operations.dat" % source - with open(infn1) as inf1: - lines = inf1.readlines() - nform = sum([int(line.strip().split()[1]) for line in lines]) - # Fraction of each of the operations - infn2 = "./data/%s.wiki.parsed__operation_type.dat" % source - with open(infn2) as inf2: - lines = inf2.readlines() - target = dict( - [ - ( - "Nopi_%s" % line.strip().split()[0], - float(line.strip().split()[1]) / nform, - ) - for line in lines - ] - ) - # Fraction of each of the operations squared - if quadratic: - infn3 = "./data/%s.wiki.parsed__operation_type_sq.dat" % (source) - with open(infn3) as inf3: - lines = inf3.readlines() - target2 = dict( - [ - ( - "Nopi2_%s" % line.strip().split()[0], - float(line.strip().split()[1]) / nform, - ) - for line in lines - ] - ) - for k, v in list(target2.items()): - target[k] = v - # Done - return target, nform - - -# ----------------------------------------------------------------------------- -def update_ppar(tree, current, target, terms=None, step=0.05): - """Update the prior parameters using a gradient descend of sorts.""" - - # Which terms should we update? (Default: all) - if terms is None: - terms = list(current.keys()) - # Update - for t in terms: - if current[t] > target[t]: - tree.prior_par[t] += min( - 0.5, - random() * step * float(current[t] - target[t]) / (target[t] + 1e-10), - ) - elif current[t] < target[t]: - tree.prior_par[t] -= min( - 0.5, - random() * step * float(target[t] - current[t]) / (target[t] + 1e-10), - ) - else: - pass - # Make sure quadratic terms are not below the minimum allowed - for t in [t for t in terms if t.startswith("Nopi2_")]: - """ - lint = t.replace('Nopi2_', 'Nopi_') - op = t[6:] - nopmax = float(tree.max_size) / tree.ops[op] - 1. - minval = - tree.prior_par[lint] / nopmax - """ - minval = 0.0 - if tree.prior_par[t] < minval: - tree.prior_par[t] = minval - - return - - -# ----------------------------------------------------------------------------- -def read_prior_par(inFileName): - with open(inFileName) as inf: - lines = inf.readlines() - ppar = dict( - list( - zip( - lines[0].strip().split()[1:], - [float(x) for x in lines[-1].strip().split()[1:]], - ) - ) - ) - return ppar - - -# ----------------------------------------------------------------------------- -# ----------------------------------------------------------------------------- -if __name__ == "__main__": - MAX_SIZE = 50 - parser = parse_options() - opt, args = parser.parse_args() - if opt.npar is None: - opt.npar = 2 * opt.nvar - target, nform = read_target_values(opt.source, quadratic=opt.quadratic) - print(opt.contfile) - print("\n>> TARGET:", target) - - # Create prior parameter dictionary from scratch or load it from file - if opt.contfile is not None: - ppar = read_prior_par(opt.contfile) - # Add values to parameters for the quadratic terms (and modify - # those of the linear terms accordingly) if you loaded ppar - # from a file without quadratic terms - if opt.quadratic: - for t in [ - t - for t in target - if t.startswith("Nopi2_") and t not in list(ppar.keys()) - ]: - ppar[t] = 0.0 - else: - ppar = dict( - [(k, 10.0) for k in target if k.startswith("Nopi_")] - + [(k, 0.0) for k in target if not k.startswith("Nopi_")] - ) - print("\n>> PRIOR_PAR:", ppar) - - # Preliminaries - if opt.quadratic: - outFileName = "prior_param_sq.%s.nv%d.np%d.maxs%d.%s.dat" % ( - opt.source, - opt.nvar, - opt.npar, - opt.max_size, - datetime.now(), - ) - else: - outFileName = "prior_param.%s.nv%d.np%d.maxs%d.%s.dat" % ( - opt.source, - opt.nvar, - opt.npar, - opt.max_size, - datetime.now(), - ) - with open(outFileName, "w") as outf: - print("#", " ".join([o for o in ppar]), file=outf) - iteration = 0 - - # Do the loop! - while True: - # Create new seed formula - tree = Tree( - ops=dict( - [(o[5:], get_priors()[1][o[5:]]) for o in ppar if o.startswith("Nopi_")] - ), - variables=["x%d" % (i + 1) for i in range(opt.nvar)], - parameters=["a%d" % (i + 1) for i in range(opt.npar)], - max_size=opt.max_size, - prior_par=ppar, - ) - - # Generate the formulas and compute the features - current = dict([(t, 0) for t in ppar]) - for rep in range(opt.nrep): - tree.mcmc_step() - for o, nopi in list(tree.nops.items()): - current["Nopi_%s" % o] += nopi - try: - current["Nopi2_%s" % o] += nopi * nopi - except KeyError: - pass - - # Normalize the current counts - current = dict([(t, float(v) / opt.nrep) for t, v in list(current.items())]) - - # Output some info to stdout and to output file - print(40 * "-") - print(tree.prior_par) - with open(outFileName, "a") as outf: - print(iteration, " ".join([str(v) for v in list(ppar.values())]), file=outf) - for t in ppar: - print( - t, - current[t], - target[t], - "%.1f" % (float(current[t] - target[t]) * 100.0 / target[t]), - ) - iteration += 1 - - # Update parameters - dice = random() - # all terms - if dice < 0.8: - update_ppar(tree, current, target, step=opt.fact) - # a single randomly chosen term - else: - update_ppar( - tree, - current, - target, - step=opt.fact, - terms=[choice(list(current.keys()))], - ) - ppar = tree.prior_par diff --git a/autora/theorist/bms/mcmc.py b/autora/theorist/bms/mcmc.py deleted file mode 100644 index afbd71129..000000000 --- a/autora/theorist/bms/mcmc.py +++ /dev/null @@ -1,1582 +0,0 @@ -""" -A Markov-Chain Monte-Carlo module. - -Module constants: - `get_ops()`: - A dictionary of accepted operations: `{operation_name: offspring}` - - `operation_name`: the operation name, e.g. 'sin' for the sinusoid function - - `offspring`: the number of arguments the function requires. - - For instance, `get_ops() = {"sin": 1, "**": 2 }` means for - `sin` the function call looks like `sin(x1)` whereas for - the exponentiation operator `**`, the function call looks like `x1 ** x2` -""" - -import json -import logging -import sys -from copy import deepcopy -from inspect import signature -from itertools import permutations, product -from random import choice, random, seed -from typing import List - -import matplotlib.pyplot as plt -import numpy as np -import pandas as pd -import scipy -from scipy.optimize import curve_fit -from sympy import lambdify, latex, log, sympify - -from .prior import get_priors, relu - -_logger = logging.getLogger(__name__) - - -class Node: - """ - Object that holds algebraic term. This could be a function, variable, or parameter. - - Attributes: - order: number of children nodes this term has - e.g. cos(x) has one child, whereas add(x,y) has two children - """ - - def __init__(self, value, parent=None, offspring=[]): - """ - Initialises the node object. - - Arguments: - parent: parent node - unless this node is the root, this will be whichever node contains - the function this node's term is most immediately nested within - e.g. f(x) is the parent of g(x) in f(g(x)) - offspring: list of child nodes - value: the specific term held by this node - """ - self.parent: Node = parent - self.offspring: List[Node] = offspring - self.value: str = value - self.order: int = len(self.offspring) - - def pr(self, custom_ops, show_pow=False): - """ - Converts expression in readable form - - Returns: String - """ - if self.offspring == []: - return "%s" % self.value - elif len(self.offspring) == 2 and self.value not in custom_ops: - return "(%s %s %s)" % ( - self.offspring[0].pr(custom_ops=custom_ops, show_pow=show_pow), - self.value, - self.offspring[1].pr(custom_ops=custom_ops, show_pow=show_pow), - ) - else: - if show_pow: - return "%s(%s)" % ( - self.value, - ",".join( - [ - o.pr(custom_ops=custom_ops, show_pow=show_pow) - for o in self.offspring - ] - ), - ) - else: - if self.value == "pow2": - return "(%s ** 2)" % ( - self.offspring[0].pr(custom_ops=custom_ops, show_pow=show_pow) - ) - elif self.value == "pow3": - return "(%s ** 3)" % ( - self.offspring[0].pr(custom_ops=custom_ops, show_pow=show_pow) - ) - else: - return "%s(%s)" % ( - self.value, - ",".join( - [ - o.pr(custom_ops=custom_ops, show_pow=show_pow) - for o in self.offspring - ] - ), - ) - - -class Tree: - """ - Object that manages the model equation. It contains the root node, which in turn iteratively - holds children nodes. Collectively this represents the model equation tree - - Attributes: - root: the root node of the equation tree - parameters: the settable parameters for this trees model search - op_orders: order of each function within the ops - nops: number of operations of each type - move_types: possible combinations of function nesting - ets: possible elementary equation trees - dist_par: distinct parameters used - nodes: nodes of the tree (operations and leaves) - et_space: space of all possible leaves and elementary trees - rr_space: space of all possible root replacement trees - num_rr: number of possible root replacement trees - x: independent variable data - y: depedent variable data - par_values: The values of the model parameters (one set of values for each dataset) - fit_par: past successful parameter fittings - sse: sum of squared errors (measure of goodness of fit) - bic: bayesian information criterion (measure of goodness of fit) - E: total energy of model - EB: fraction of energy derived from bic score of model - EP: fraction of energy derived from model given prior - representative: representative tree for each canonical formula - """ - - prior, ops = get_priors() - - def __init__( - self, - ops=ops, - variables=["x"], - parameters=["a"], - prior_par=prior, - x=None, - y=None, - BT=1.0, - PT=1.0, - max_size=50, - root_value=None, - fixed_root=False, - custom_ops={}, - seed_value=None, - ): - """ - Initialises the tree object - - Args: - ops: allowed operations to compose equation - variables: dependent variable names - parameters: parameters that can be used to better fit the equation to the data - prior_par: hyperparameter values over operations within ops - x: dependent variables - y: independent variables - BT: BIC value corresponding to equation - PT: prior temperature - max_size: maximum size of tree (maximum number of nodes) - root_value: algebraic term held at root of equation - """ - if seed_value is not None: - seed(seed_value) - # The variables and parameters - if custom_ops is None: - custom_ops = dict() - self.variables = variables - self.parameters = [ - p if p.startswith("_") and p.endswith("_") else "_%s_" % p - for p in parameters - ] - # The root - self.fixed_root = fixed_root - if root_value is None: - self.root = Node( - choice(self.variables + self.parameters), offspring=[], parent=None - ) - else: - self.root = Node(root_value, offspring=[], parent=None) - root_order = len(signature(custom_ops[root_value]).parameters) - self.root.order = root_order - for _ in range(root_order): - self.root.offspring.append( - Node( - choice(self.variables + self.parameters), - offspring=[], - parent=self.root, - ) - ) - - # The possible operations - self.ops = ops - self.custom_ops = custom_ops - # The possible orders of the operations, move types, and move - # type probabilities - self.op_orders = list(set([0] + [n for n in list(ops.values())])) - self.move_types = [p for p in permutations(self.op_orders, 2)] - # Elementary trees (including leaves), indexed by order - self.ets = dict([(o, []) for o in self.op_orders]) - self.ets[0] = [x for x in self.root.offspring] - self.ets[self.root.order] = [self.root] - # Distinct parameters used - self.dist_par = list( - set([n.value for n in self.ets[0] if n.value in self.parameters]) - ) - self.n_dist_par = len(self.dist_par) - # Nodes of the tree (operations + leaves) - self.nodes = [self.root] - # Tree size and other properties of the model - self.size = 1 - self.max_size = max_size - # Space of all possible leaves and elementary trees - # (dict. indexed by order) - self.et_space = self.build_et_space() - # Space of all possible root replacement trees - self.rr_space = self.build_rr_space() - self.num_rr = len(self.rr_space) - # Number of operations of each type - self.nops = dict([[o, 0] for o in ops]) - if root_value is not None: - self.nops[self.root.value] += 1 - # The parameters of the prior probability (default: 5 everywhere) - if prior_par == {}: - self.prior_par = dict([("Nopi_%s" % t, 10.0) for t in self.ops]) - else: - self.prior_par = prior_par - # The datasets - if x is None: - self.x = {"d0": pd.DataFrame()} - self.y = {"d0": pd.Series(dtype=float)} - elif isinstance(x, pd.DataFrame): - self.x = {"d0": x} - self.y = {"d0": y} - elif isinstance(x, dict): - self.x = x - if y is None: - self.y = dict([(ds, pd.Series(dtype=float)) for ds in self.x]) - else: - self.y = y - else: - raise TypeError("x must be either a dict or a pandas.DataFrame") - # The values of the model parameters (one set of values for each dataset) - self.par_values = dict( - [(ds, deepcopy(dict([(p, 1.0) for p in self.parameters]))) for ds in self.x] - ) - # BIC and prior temperature - self.BT = float(BT) - self.PT = float(PT) - # For fast fitting, we save past successful fits to this formula - self.fit_par = {} - # Goodness of fit measures - self.sse = self.get_sse() - self.bic = self.get_bic() - self.E, self.EB, self.EP = self.get_energy() - # To control formula degeneracy (i.e. different trees that - # correspond to the same canonical formula), we store the - # representative tree for each canonical formula - self.representative = {} - self.representative[self.canonical()] = ( - str(self), - self.E, - deepcopy(self.par_values), - ) - # Done - return - - # ------------------------------------------------------------------------- - def __repr__(self): - """ - Updates tree's internal representation - - Returns: root node representation - - """ - return self.root.pr(custom_ops=self.custom_ops) - - # ------------------------------------------------------------------------- - def pr(self, show_pow=True): - """ - Returns readable representation of tree's root node - - Returns: root node representation - - """ - return self.root.pr(custom_ops=self.custom_ops, show_pow=show_pow) - - # ------------------------------------------------------------------------- - def canonical(self, verbose=False): - """ - Provides canonical form of tree's equation so that functionally equivalent trees - are made into structurally equivalent trees - - Return: canonical form of a tree - """ - try: - cansp = sympify(str(self).replace(" ", "")) - can = str(cansp) - ps = list([str(s) for s in cansp.free_symbols]) - positions = [] - for p in ps: - if p.startswith("_") and p.endswith("_"): - positions.append((can.find(p), p)) - positions.sort() - pcount = 1 - for pos, p in positions: - can = can.replace(p, "c%d" % pcount) - pcount += 1 - except SyntaxError: - if verbose: - print( - "WARNING: Could not get canonical form for", - str(self), - "(using full form!)", - file=sys.stderr, - ) - can = str(self) - return can.replace(" ", "") - - # ------------------------------------------------------------------------- - def latex(self): - """ - translate equation into latex - - Returns: canonical latex form of equation - """ - return latex(sympify(self.canonical())) - - # ------------------------------------------------------------------------- - def build_et_space(self): - """ - Build the space of possible elementary trees, - which is a dictionary indexed by the order of the elementary tree - - Returns: space of elementary trees - """ - et_space = dict([(o, []) for o in self.op_orders]) - et_space[0] = [[x, []] for x in self.variables + self.parameters] - for op, noff in list(self.ops.items()): - for vs in product(et_space[0], repeat=noff): - et_space[noff].append([op, [v[0] for v in vs]]) - return et_space - - # ------------------------------------------------------------------------- - def build_rr_space(self): - """ - Build the space of possible trees for the root replacement move - - Returns: space of possible root replacements - """ - rr_space = [] - for op, noff in list(self.ops.items()): - if noff == 1: - rr_space.append([op, []]) - else: - for vs in product(self.et_space[0], repeat=(noff - 1)): - rr_space.append([op, [v[0] for v in vs]]) - return rr_space - - # ------------------------------------------------------------------------- - def replace_root(self, rr=None, update_gof=True, verbose=False): - """ - Replace the root with a "root replacement" rr (if provided; - otherwise choose one at random from self.rr_space) - - Returns: new root (if move was possible) or None (otherwise) - """ - # If no RR is provided, randomly choose one - if rr is None: - rr = choice(self.rr_space) - # Return None if the replacement is too big - if (self.size + self.ops[rr[0]]) > self.max_size: - return None - # Create the new root and replace existing root - newRoot = Node(rr[0], offspring=[], parent=None) - newRoot.order = 1 + len(rr[1]) - if newRoot.order != self.ops[rr[0]]: - raise - newRoot.offspring.append(self.root) - self.root.parent = newRoot - self.root = newRoot - self.nops[self.root.value] += 1 - self.nodes.append(self.root) - self.size += 1 - oldRoot = self.root.offspring[0] - for leaf in rr[1]: - self.root.offspring.append(Node(leaf, offspring=[], parent=self.root)) - self.nodes.append(self.root.offspring[-1]) - self.ets[0].append(self.root.offspring[-1]) - self.size += 1 - # Add new root to elementary trees if necessary (that is, iff - # the old root was a leaf) - if oldRoot.offspring is []: - self.ets[self.root.order].append(self.root) - # Update list of distinct parameters - self.dist_par = list( - set([n.value for n in self.ets[0] if n.value in self.parameters]) - ) - self.n_dist_par = len(self.dist_par) - # Update goodness of fit measures, if necessary - if update_gof: - self.sse = self.get_sse(verbose=verbose) - self.bic = self.get_bic(verbose=verbose) - self.E = self.get_energy(verbose=verbose) - return self.root - - # ------------------------------------------------------------------------- - def is_root_prunable(self): - """ - Check if the root is "prunable" - - Returns: boolean of root "prunability" - """ - if self.size == 1: - isPrunable = False - elif self.size == 2: - isPrunable = True - else: - isPrunable = True - for o in self.root.offspring[1:]: - if o.offspring != []: - isPrunable = False - break - return isPrunable - - # ------------------------------------------------------------------------- - def prune_root(self, update_gof=True, verbose=False): - """ - Cut the root and its rightmost leaves (provided they are, indeed, leaves), - leaving the leftmost branch as the new tree. Returns the pruned root with the same format - as the replacement roots in self.rr_space (or None if pruning was impossible) - - Returns: the replacement root - """ - # Check if the root is "prunable" (and return None if not) - if not self.is_root_prunable(): - return None - # Let's do it! - rr = [self.root.value, []] - self.nodes.remove(self.root) - try: - self.ets[len(self.root.offspring)].remove(self.root) - except ValueError: - pass - self.nops[self.root.value] -= 1 - self.size -= 1 - for o in self.root.offspring[1:]: - rr[1].append(o.value) - self.nodes.remove(o) - self.size -= 1 - self.ets[0].remove(o) - self.root = self.root.offspring[0] - self.root.parent = None - # Update list of distinct parameters - self.dist_par = list( - set([n.value for n in self.ets[0] if n.value in self.parameters]) - ) - self.n_dist_par = len(self.dist_par) - # Update goodness of fit measures, if necessary - if update_gof: - self.sse = self.get_sse(verbose=verbose) - self.bic = self.get_bic(verbose=verbose) - self.E = self.get_energy(verbose=verbose) - # Done - return rr - - # ------------------------------------------------------------------------- - def _add_et(self, node, et_order=None, et=None, update_gof=True, verbose=False): - """ - Add an elementary tree replacing the node, which must be a leaf - - Returns: the input node - """ - if node.offspring != []: - raise - # If no ET is provided, randomly choose one (of the specified - # order if given, or totally at random otherwise) - if et is None: - if et_order is not None: - et = choice(self.et_space[et_order]) - else: - all_ets = [] - for o in [o for o in self.op_orders if o > 0]: - all_ets += self.et_space[o] - et = choice(all_ets) - et_order = len(et[1]) - else: - et_order = len(et[1]) - # Update the node and its offspring - node.value = et[0] - try: - self.nops[node.value] += 1 - except KeyError: - pass - node.offspring = [Node(v, parent=node, offspring=[]) for v in et[1]] - self.ets[et_order].append(node) - try: - self.ets[len(node.parent.offspring)].remove(node.parent) - except ValueError: - pass - except AttributeError: - pass - # Add the offspring to the list of nodes - for n in node.offspring: - self.nodes.append(n) - # Remove the node from the list of leaves and add its offspring - self.ets[0].remove(node) - for o in node.offspring: - self.ets[0].append(o) - self.size += 1 - # Update list of distinct parameters - self.dist_par = list( - set([n.value for n in self.ets[0] if n.value in self.parameters]) - ) - self.n_dist_par = len(self.dist_par) - # Update goodness of fit measures, if necessary - if update_gof: - self.sse = self.get_sse(verbose=verbose) - self.bic = self.get_bic(verbose=verbose) - self.E = self.get_energy(verbose=verbose) - return node - - # ------------------------------------------------------------------------- - def _del_et(self, node, leaf=None, update_gof=True, verbose=False): - """ - Remove an elementary tree, replacing it by a leaf - - Returns: input node - """ - if self.size == 1: - return None - if leaf is None: - leaf = choice(self.et_space[0])[0] - self.nops[node.value] -= 1 - node.value = leaf - self.ets[len(node.offspring)].remove(node) - self.ets[0].append(node) - for o in node.offspring: - self.ets[0].remove(o) - self.nodes.remove(o) - self.size -= 1 - node.offspring = [] - if node.parent is not None: - is_parent_et = True - for o in node.parent.offspring: - if o not in self.ets[0]: - is_parent_et = False - break - if is_parent_et: - self.ets[len(node.parent.offspring)].append(node.parent) - # Update list of distinct parameters - self.dist_par = list( - set([n.value for n in self.ets[0] if n.value in self.parameters]) - ) - self.n_dist_par = len(self.dist_par) - # Update goodness of fit measures, if necessary - if update_gof: - self.sse = self.get_sse(verbose=verbose) - self.bic = self.get_bic(verbose=verbose) - self.E = self.get_energy(verbose=verbose) - return node - - # ------------------------------------------------------------------------- - def et_replace(self, target, new, update_gof=True, verbose=False): - """ - Replace one elementary tree with another one, both of arbitrary order. target is a - Node and new is a tuple [node_value, [list, of, offspring, values]] - - Returns: target - """ - oini, ofin = len(target.offspring), len(new[1]) - if oini == 0: - added = self._add_et(target, et=new, update_gof=False, verbose=verbose) - else: - if ofin == 0: - added = self._del_et( - target, leaf=new[0], update_gof=False, verbose=verbose - ) - else: - self._del_et(target, update_gof=False, verbose=verbose) - added = self._add_et(target, et=new, update_gof=False, verbose=verbose) - # Update goodness of fit measures, if necessary - if update_gof: - self.sse = self.get_sse(verbose=verbose) - self.bic = self.get_bic(verbose=verbose) - # Done - return added - - # ------------------------------------------------------------------------- - def get_sse(self, fit=True, verbose=False): - """ - Get the sum of squared errors, fitting the expression represented by the Tree - to the existing data, if specified (by default, yes) - - Returns: sum of square errors (sse) - """ - # Return 0 if there is no data - if list(self.x.values())[0].empty or list(self.y.values())[0].empty: - self.sse = 0 - return 0 - # Convert the Tree into a SymPy expression - ex = sympify(str(self)) - # Convert the expression to a function that can be used by - # curve_fit, i.e. that takes as arguments (x, a0, a1, ..., an) - atomd = dict([(a.name, a) for a in ex.atoms() if a.is_Symbol]) - variables = [atomd[v] for v in self.variables if v in list(atomd.keys())] - parameters = [atomd[p] for p in self.parameters if p in list(atomd.keys())] - dic: dict = dict( - { - "fac": scipy.special.factorial, - "sig": scipy.special.expit, - "relu": relu, - }, - **self.custom_ops - ) - try: - flam = lambdify( - variables + parameters, - ex, - [ - "numpy", - dic, - ], - ) - except (SyntaxError, KeyError): - self.sse = dict([(ds, np.inf) for ds in self.x]) - return self.sse - if fit: - if len(parameters) == 0: # Nothing to fit - for ds in self.x: - for p in self.parameters: - self.par_values[ds][p] = 1.0 - elif str(self) in self.fit_par: # Recover previously fit parameters - self.par_values = self.fit_par[str(self)] - else: # Do the fit for all datasets - self.fit_par[str(self)] = {} - for ds in self.x: - this_x, this_y = self.x[ds], self.y[ds] - xmat = [this_x[v.name] for v in variables] - - def feval(x, *params): - args = [xi for xi in x] + [p for p in params] - return flam(*args) - - try: - # Fit the parameters - res = curve_fit( - feval, - xmat, - this_y, - p0=[self.par_values[ds][p.name] for p in parameters], - maxfev=10000, - ) - # Reassign the values of the parameters - self.par_values[ds] = dict( - [ - (parameters[i].name, res[0][i]) - for i in range(len(res[0])) - ] - ) - for p in self.parameters: - if p not in self.par_values[ds]: - self.par_values[ds][p] = 1.0 - # Save this fit - self.fit_par[str(self)][ds] = deepcopy(self.par_values[ds]) - except RuntimeError: - # Save this (unsuccessful) fit and print warning - self.fit_par[str(self)][ds] = deepcopy(self.par_values[ds]) - if verbose: - print( - "#Cannot_fit:%s # # # # #" % str(self).replace(" ", ""), - file=sys.stderr, - ) - - # Sum of squared errors - self.sse = {} - for ds in self.x: - this_x, this_y = self.x[ds], self.y[ds] - xmat = [this_x[v.name] for v in variables] - ar = [np.array(xi) for xi in xmat] + [ - self.par_values[ds][p.name] for p in parameters - ] - try: - se = np.square(this_y - flam(*ar)) - if sum(np.isnan(se)) > 0: - raise ValueError - else: - self.sse[ds] = np.sum(se) - except ValueError: - if verbose: - print("> Cannot calculate SSE for %s: inf" % self, file=sys.stderr) - self.sse[ds] = np.inf - - # Done - return self.sse - - # ------------------------------------------------------------------------- - def get_bic(self, reset=True, fit=False, verbose=False): - """ - Calculate the Bayesian information criterion (BIC) of the current expression, - given the data. If reset==False, the value of self.bic will not be updated - (by default, it will) - - Returns: Bayesian information criterion (BIC) - """ - if list(self.x.values())[0].empty or list(self.y.values())[0].empty: - if reset: - self.bic = 0 - return 0 - # Get the sum of squared errors (fitting, if required) - sse = self.get_sse(fit=fit, verbose=verbose) - # Calculate the BIC - parameters = set([p.value for p in self.ets[0] if p.value in self.parameters]) - k = 1 + len(parameters) - BIC = 0.0 - for ds in self.y: - n = len(self.y[ds]) - BIC += (k - n) * np.log(n) + n * (np.log(2.0 * np.pi) + log(sse[ds]) + 1) - for ds in self.y: - if sse[ds] == 0.0: - BIC = -np.inf - if reset: - self.bic = BIC - return BIC - - # ------------------------------------------------------------------------- - def get_energy(self, bic=False, reset=False, verbose=False): - """ - Calculate the "energy" of a given formula, that is, approximate minus log-posterior - of the formula given the data (the approximation coming from the use of the BIC - instead of the exactly integrated likelihood) - - Returns: Energy of formula (as E, EB, and EP) - """ - # Contribution of the data (recalculating BIC if necessary) - if bic: - EB = self.get_bic(reset=reset, verbose=verbose) / 2.0 - else: - EB = self.bic / 2.0 - # Contribution from the prior - EP = 0.0 - for op, nop in list(self.nops.items()): - try: - EP += self.prior_par["Nopi_%s" % op] * nop - except KeyError: - pass - try: - EP += self.prior_par["Nopi2_%s" % op] * nop**2 - except KeyError: - pass - # Reset the value, if necessary - if reset: - self.EB = EB - self.EP = EP - self.E = EB + EP - # Done - return EB + EP, EB, EP - - # ------------------------------------------------------------------------- - def update_representative(self, verbose=False): - """Check if we've seen this formula before, either in its current form - or in another form. - - *If we haven't seen it, save it and return 1. - - *If we have seen it and this IS the representative, just return 0. - - *If we have seen it and the representative has smaller energy, just return -1. - - *If we have seen it and the representative has higher energy, update - the representatitve and return -2. - - Returns: Integer value (0, 1, or -1) corresponding to: - 0: we have seen this canonical form before - 1: we haven't seen this canonical form before - -1: we have seen this equation's canonical form before but it isn't in that form yet - """ - # Check for canonical representative - canonical = self.canonical(verbose=verbose) - try: # We've seen this canonical before! - rep, rep_energy, rep_par_values = self.representative[canonical] - except KeyError: # Never seen this canonical formula before: - # save it and return 1 - self.get_bic(reset=True, fit=True, verbose=verbose) - new_energy = self.get_energy(bic=False, verbose=verbose) - self.representative[canonical] = ( - str(self), - new_energy, - deepcopy(self.par_values), - ) - return 1 - - # If we've seen this canonical before, check if the - # representative needs to be updated - if rep == str(self): # This IS the representative: return 0 - return 0 - else: - return -1 - - # ------------------------------------------------------------------------- - def dE_et(self, target, new, verbose=False): - """ - Calculate the energy change associated to the replacement of one elementary tree - with another, both of arbitrary order. "target" is a Node() and "new" is - a tuple [node_value, [list, of, offspring, values]]. - - Returns: change in energy associated with an elementary tree replacement move - """ - dEB, dEP = 0.0, 0.0 - - # Some terms of the acceptance (number of possible move types - # from initial and final configurations), as well as checking - # if the tree is canonically acceptable. - - # number of possible move types from initial - nif = sum( - [ - int(len(self.ets[oi]) > 0 and (self.size + of - oi) <= self.max_size) - for oi, of in self.move_types - ] - ) - # replace - old = [target.value, [o.value for o in target.offspring]] - old_bic, old_sse, old_energy = self.bic, deepcopy(self.sse), self.E - old_par_values = deepcopy(self.par_values) - added = self.et_replace(target, new, update_gof=False, verbose=verbose) - # number of possible move types from final - nfi = sum( - [ - int(len(self.ets[oi]) > 0 and (self.size + of - oi) <= self.max_size) - for oi, of in self.move_types - ] - ) - # check/update canonical representative - rep_res = self.update_representative(verbose=verbose) - if rep_res == -1: - # this formula is forbidden - self.et_replace(added, old, update_gof=False, verbose=verbose) - self.bic, self.sse, self.E = old_bic, deepcopy(old_sse), old_energy - self.par_values = old_par_values - return np.inf, np.inf, np.inf, deepcopy(self.par_values), nif, nfi - # leave the whole thing as it was before the back & fore - self.et_replace(added, old, update_gof=False, verbose=verbose) - self.bic, self.sse, self.E = old_bic, deepcopy(old_sse), old_energy - self.par_values = old_par_values - # Prior: change due to the numbers of each operation - try: - dEP -= self.prior_par["Nopi_%s" % target.value] - except KeyError: - pass - try: - dEP += self.prior_par["Nopi_%s" % new[0]] - except KeyError: - pass - try: - dEP += self.prior_par["Nopi2_%s" % target.value] * ( - (self.nops[target.value] - 1) ** 2 - (self.nops[target.value]) ** 2 - ) - except KeyError: - pass - try: - dEP += self.prior_par["Nopi2_%s" % new[0]] * ( - (self.nops[new[0]] + 1) ** 2 - (self.nops[new[0]]) ** 2 - ) - except KeyError: - pass - - # Data - if not list(self.x.values())[0].empty: - bicOld = self.bic - sseOld = deepcopy(self.sse) - par_valuesOld = deepcopy(self.par_values) - old = [target.value, [o.value for o in target.offspring]] - # replace - added = self.et_replace(target, new, update_gof=True, verbose=verbose) - bicNew = self.bic - par_valuesNew = deepcopy(self.par_values) - # leave the whole thing as it was before the back & fore - self.et_replace(added, old, update_gof=False, verbose=verbose) - self.bic = bicOld - self.sse = deepcopy(sseOld) - self.par_values = par_valuesOld - dEB += (bicNew - bicOld) / 2.0 - else: - par_valuesNew = deepcopy(self.par_values) - # Done - try: - dEB = float(dEB) - dEP = float(dEP) - dE = dEB + dEP - except (ValueError, TypeError): - dEB, dEP, dE = np.inf, np.inf, np.inf - return dE, dEB, dEP, par_valuesNew, nif, nfi - - # ------------------------------------------------------------------------- - def dE_lr(self, target, new, verbose=False): - """ - Calculate the energy change associated to a long-range move - (the replacement of the value of a node. "target" is a Node() and "new" is a node_value - - Returns: energy change associated with a long-range move - """ - dEB, dEP = 0.0, 0.0 - par_valuesNew = deepcopy(self.par_values) - - if target.value != new: - - # Check if the new tree is canonically acceptable. - old = target.value - old_bic, old_sse, old_energy = self.bic, deepcopy(self.sse), self.E - old_par_values = deepcopy(self.par_values) - target.value = new - try: - self.nops[old] -= 1 - self.nops[new] += 1 - except KeyError: - pass - # check/update canonical representative - rep_res = self.update_representative(verbose=verbose) - if rep_res == -1: - # this formula is forbidden - target.value = old - try: - self.nops[old] += 1 - self.nops[new] -= 1 - except KeyError: - pass - self.bic, self.sse, self.E = old_bic, deepcopy(old_sse), old_energy - self.par_values = old_par_values - return np.inf, np.inf, np.inf, None - # leave the whole thing as it was before the back & fore - target.value = old - try: - self.nops[old] += 1 - self.nops[new] -= 1 - except KeyError: - pass - self.bic, self.sse, self.E = old_bic, deepcopy(old_sse), old_energy - self.par_values = old_par_values - - # Prior: change due to the numbers of each operation - try: - dEP -= self.prior_par["Nopi_%s" % target.value] - except KeyError: - pass - try: - dEP += self.prior_par["Nopi_%s" % new] - except KeyError: - pass - try: - dEP += self.prior_par["Nopi2_%s" % target.value] * ( - (self.nops[target.value] - 1) ** 2 - (self.nops[target.value]) ** 2 - ) - except KeyError: - pass - try: - dEP += self.prior_par["Nopi2_%s" % new] * ( - (self.nops[new] + 1) ** 2 - (self.nops[new]) ** 2 - ) - except KeyError: - pass - - # Data - if not list(self.x.values())[0].empty: - bicOld = self.bic - sseOld = deepcopy(self.sse) - par_valuesOld = deepcopy(self.par_values) - old = target.value - target.value = new - bicNew = self.get_bic(reset=True, fit=True, verbose=verbose) - par_valuesNew = deepcopy(self.par_values) - # leave the whole thing as it was before the back & fore - target.value = old - self.bic = bicOld - self.sse = deepcopy(sseOld) - self.par_values = par_valuesOld - dEB += (bicNew - bicOld) / 2.0 - else: - par_valuesNew = deepcopy(self.par_values) - - # Done - try: - dEB = float(dEB) - dEP = float(dEP) - dE = dEB + dEP - return dE, dEB, dEP, par_valuesNew - except (ValueError, TypeError): - return np.inf, np.inf, np.inf, None - - # ------------------------------------------------------------------------- - def dE_rr(self, rr=None, verbose=False): - """ - Calculate the energy change associated to a root replacement move. - If rr==None, then it returns the energy change associated to pruning the root; otherwise, - it returns the energy change associated to adding the root replacement "rr" - - Returns: energy change associated with a root replacement move - """ - dEB, dEP = 0.0, 0.0 - - # Root pruning - if rr is None: - if not self.is_root_prunable(): - return np.inf, np.inf, np.inf, self.par_values - - # Check if the new tree is canonically acceptable. - # replace - old_bic, old_sse, old_energy = self.bic, deepcopy(self.sse), self.E - old_par_values = deepcopy(self.par_values) - oldrr = [self.root.value, [o.value for o in self.root.offspring[1:]]] - self.prune_root(update_gof=False, verbose=verbose) - # check/update canonical representative - rep_res = self.update_representative(verbose=verbose) - if rep_res == -1: - # this formula is forbidden - self.replace_root(rr=oldrr, update_gof=False, verbose=verbose) - self.bic, self.sse, self.E = old_bic, deepcopy(old_sse), old_energy - self.par_values = old_par_values - return np.inf, np.inf, np.inf, deepcopy(self.par_values) - # leave the whole thing as it was before the back & fore - self.replace_root(rr=oldrr, update_gof=False, verbose=verbose) - self.bic, self.sse, self.E = old_bic, deepcopy(old_sse), old_energy - self.par_values = old_par_values - - # Prior: change due to the numbers of each operation - dEP -= self.prior_par["Nopi_%s" % self.root.value] - try: - dEP += self.prior_par["Nopi2_%s" % self.root.value] * ( - (self.nops[self.root.value] - 1) ** 2 - - (self.nops[self.root.value]) ** 2 - ) - except KeyError: - pass - - # Data correction - if not list(self.x.values())[0].empty: - bicOld = self.bic - sseOld = deepcopy(self.sse) - par_valuesOld = deepcopy(self.par_values) - oldrr = [self.root.value, [o.value for o in self.root.offspring[1:]]] - # replace - self.prune_root(update_gof=False, verbose=verbose) - bicNew = self.get_bic(reset=True, fit=True, verbose=verbose) - par_valuesNew = deepcopy(self.par_values) - # leave the whole thing as it was before the back & fore - self.replace_root(rr=oldrr, update_gof=False, verbose=verbose) - self.bic = bicOld - self.sse = deepcopy(sseOld) - self.par_values = par_valuesOld - dEB += (bicNew - bicOld) / 2.0 - else: - par_valuesNew = deepcopy(self.par_values) - # Done - try: - dEB = float(dEB) - dEP = float(dEP) - dE = dEB + dEP - except (ValueError, TypeError): - dEB, dEP, dE = np.inf, np.inf, np.inf - return dE, dEB, dEP, par_valuesNew - - # Root replacement - else: - # Check if the new tree is canonically acceptable. - # replace - old_bic, old_sse, old_energy = self.bic, deepcopy(self.sse), self.E - old_par_values = deepcopy(self.par_values) - newroot = self.replace_root(rr=rr, update_gof=False, verbose=verbose) - if newroot is None: # Root cannot be replaced (due to max_size) - return np.inf, np.inf, np.inf, deepcopy(self.par_values) - # check/update canonical representative - rep_res = self.update_representative(verbose=verbose) - if rep_res == -1: - # this formula is forbidden - self.prune_root(update_gof=False, verbose=verbose) - self.bic, self.sse, self.E = old_bic, deepcopy(old_sse), old_energy - self.par_values = old_par_values - return np.inf, np.inf, np.inf, deepcopy(self.par_values) - # leave the whole thing as it was before the back & fore - self.prune_root(update_gof=False, verbose=verbose) - self.bic, self.sse, self.E = old_bic, deepcopy(old_sse), old_energy - self.par_values = old_par_values - - # Prior: change due to the numbers of each operation - dEP += self.prior_par["Nopi_%s" % rr[0]] - try: - dEP += self.prior_par["Nopi2_%s" % rr[0]] * ( - (self.nops[rr[0]] + 1) ** 2 - (self.nops[rr[0]]) ** 2 - ) - except KeyError: - pass - - # Data - if not list(self.x.values())[0].empty: - bicOld = self.bic - sseOld = deepcopy(self.sse) - par_valuesOld = deepcopy(self.par_values) - # replace - newroot = self.replace_root(rr=rr, update_gof=False, verbose=verbose) - if newroot is None: - return np.inf, np.inf, np.inf, self.par_values - bicNew = self.get_bic(reset=True, fit=True, verbose=verbose) - par_valuesNew = deepcopy(self.par_values) - # leave the whole thing as it was before the back & fore - self.prune_root(update_gof=False, verbose=verbose) - self.bic = bicOld - self.sse = deepcopy(sseOld) - self.par_values = par_valuesOld - dEB += (bicNew - bicOld) / 2.0 - else: - par_valuesNew = deepcopy(self.par_values) - # Done - try: - dEB = float(dEB) - dEP = float(dEP) - dE = dEB + dEP - except (ValueError, TypeError): - dEB, dEP, dE = np.inf, np.inf, np.inf - return dE, dEB, dEP, par_valuesNew - - # ------------------------------------------------------------------------- - def mcmc_step(self, verbose=False, p_rr=0.05, p_long=0.45): - """ - Make a single MCMC step - - Returns: None or expression list - """ - topDice = random() - # Root replacement move - if topDice < p_rr: - if random() < 0.5: - # Try to prune the root - dE, dEB, dEP, par_valuesNew = self.dE_rr(rr=None, verbose=verbose) - if -dEB / self.BT - dEP / self.PT > 300: - paccept = 1 - else: - paccept = np.exp(-dEB / self.BT - dEP / self.PT) / float( - self.num_rr - ) - dice = random() - if dice < paccept: - # Accept move - self.prune_root(update_gof=False, verbose=verbose) - self.par_values = par_valuesNew - self.get_bic(reset=True, fit=False, verbose=verbose) - self.E += dE - self.EB += dEB - self.EP += dEP - else: - # Try to replace the root - newrr = choice(self.rr_space) - dE, dEB, dEP, par_valuesNew = self.dE_rr(rr=newrr, verbose=verbose) - if self.num_rr > 0 and -dEB / self.BT - dEP / self.PT > 0: - paccept = 1.0 - elif self.num_rr == 0: - paccept = 0.0 - else: - paccept = self.num_rr * np.exp(-dEB / self.BT - dEP / self.PT) - dice = random() - if dice < paccept: - # Accept move - self.replace_root(rr=newrr, update_gof=False, verbose=verbose) - self.par_values = par_valuesNew - self.get_bic(reset=True, fit=False, verbose=verbose) - self.E += dE - self.EB += dEB - self.EP += dEP - - # Long-range move - elif topDice < (p_rr + p_long) and not ( - self.fixed_root and len(self.nodes) == 1 - ): - # Choose a random node in the tree, and a random new operation - target = choice(self.nodes) - if self.fixed_root: - while target is self.root: - target = choice(self.nodes) - nready = False - while not nready: - if len(target.offspring) == 0: - new = choice(self.variables + self.parameters) - nready = True - else: - new = choice(list(self.ops.keys())) - if self.ops[new] == self.ops[target.value]: - nready = True - dE, dEB, dEP, par_valuesNew = self.dE_lr(target, new, verbose=verbose) - try: - paccept = np.exp(-dEB / self.BT - dEP / self.PT) - except ValueError: - _logger.warning("Potentially failing to set paccept properly") - if (dEB / self.BT + dEP / self.PT) < 0: - paccept = 1.0 - # Accept move, if necessary - dice = random() - if dice < paccept: - # update number of operations - if target.offspring != []: - self.nops[target.value] -= 1 - self.nops[new] += 1 - # move - target.value = new - # recalculate distinct parameters - self.dist_par = list( - set([n.value for n in self.ets[0] if n.value in self.parameters]) - ) - self.n_dist_par = len(self.dist_par) - # update others - self.par_values = deepcopy(par_valuesNew) - self.get_bic(reset=True, fit=False, verbose=verbose) - self.E += dE - self.EB += dEB - self.EP += dEP - - # Elementary tree (short-range) move - else: - target = None - while target is None or self.fixed_root and target is self.root: - # Choose a feasible move (doable and keeping size<=max_size) - while True: - oini, ofin = choice(self.move_types) - if len(self.ets[oini]) > 0 and ( - self.size - oini + ofin <= self.max_size - ): - break - # target and new ETs - target = choice(self.ets[oini]) - new = choice(self.et_space[ofin]) - # omegai and omegaf - omegai = len(self.ets[oini]) - omegaf = len(self.ets[ofin]) + 1 - if ofin == 0: - omegaf -= oini - if oini == 0 and target.parent in self.ets[ofin]: - omegaf -= 1 - # size of et_space of each type - si = len(self.et_space[oini]) - sf = len(self.et_space[ofin]) - # Probability of acceptance - dE, dEB, dEP, par_valuesNew, nif, nfi = self.dE_et( - target, new, verbose=verbose - ) - try: - paccept = ( - float(nif) * omegai * sf * np.exp(-dEB / self.BT - dEP / self.PT) - ) / (float(nfi) * omegaf * si) - except ValueError: - if (dEB / self.BT + dEP / self.PT) < -200: - paccept = 1.0 - # Accept / reject - dice = random() - if dice < paccept: - # Accept move - self.et_replace(target, new, verbose=verbose) - self.par_values = par_valuesNew - self.get_bic(verbose=verbose) - self.E += dE - self.EB += dEB - self.EP += dEP - - # Done - return - - # ------------------------------------------------------------------------- - def mcmc( - self, - tracefn="trace.dat", - progressfn="progress.dat", - write_files=True, - reset_files=True, - burnin=2000, - thin=10, - samples=10000, - verbose=False, - progress=True, - ): - """ - Sample the space of formula trees using MCMC, and write the trace and some progress - information to files (unless write_files is False) - - Returns: None or expression list - """ - self.get_energy(reset=True, verbose=verbose) - - # Burning - if progress: - sys.stdout.write("# Burning in\t") - sys.stdout.write("[%s]" % (" " * 50)) - sys.stdout.flush() - sys.stdout.write("\b" * (50 + 1)) - for i in range(burnin): - self.mcmc_step(verbose=verbose) - if progress and (i % (burnin / 50) == 0): - sys.stdout.write("=") - sys.stdout.flush() - # Sample - if write_files: - if reset_files: - tracef = open(tracefn, "w") - progressf = open(progressfn, "w") - else: - tracef = open(tracefn, "a") - progressf = open(progressfn, "a") - if progress: - sys.stdout.write("\n# Sampling\t") - sys.stdout.write("[%s]" % (" " * 50)) - sys.stdout.flush() - sys.stdout.write("\b" * (50 + 1)) - for s in range(samples): - for i in range(thin): - self.mcmc_step(verbose=verbose) - if progress and (s % (samples / 50) == 0): - sys.stdout.write("=") - sys.stdout.flush() - if write_files: - json.dump( - [ - s, - float(self.bic), - float(self.E), - str(self.get_energy(verbose=verbose)), - str(self), - self.par_values, - ], - tracef, - ) - tracef.write("\n") - tracef.flush() - progressf.write("%d %lf %lf\n" % (s, self.E, self.bic)) - progressf.flush() - # Done - if progress: - sys.stdout.write("\n") - return - - # ------------------------------------------------------------------------- - def predict(self, x): - """ - Calculate the value of the formula at the given data x. The data x - must have the same format as the training data and, in particular, it - it must specify to which dataset the example data belongs, if multiple - datasets where used for training. - - Returns: predicted y values - """ - if isinstance(x, np.ndarray): - columns = list() - for col in range(x.shape[1]): - columns.append("X" + str(col)) - x = pd.DataFrame(x, columns=columns) - - if isinstance(x, pd.DataFrame): - this_x = {"d0": x} - input_type = "df" - elif isinstance(x, dict): - this_x = x - input_type = "dict" - else: - raise TypeError("x must be either a dict or a pandas.DataFrame") - - # Convert the Tree into a SymPy expression - ex = sympify(str(self)) - # Convert the expression to a function - atomd = dict([(a.name, a) for a in ex.atoms() if a.is_Symbol]) - variables = [atomd[v] for v in self.variables if v in list(atomd.keys())] - parameters = [atomd[p] for p in self.parameters if p in list(atomd.keys())] - flam = lambdify( - variables + parameters, - ex, - [ - "numpy", - dict( - { - "fac": scipy.special.factorial, - "sig": scipy.special.expit, - "relu": relu, - }, - **self.custom_ops - ), - ], - ) - # Loop over datasets - predictions = {} - for ds in this_x: - # Prepare variables and parameters - xmat = [this_x[ds][v.name] for v in variables] - params = [self.par_values[ds][p.name] for p in parameters] - args = [xi for xi in xmat] + [p for p in params] - # Predict - try: - prediction = flam(*args) - except SyntaxError: - # Do it point by point - prediction = [np.nan for i in range(len(this_x[ds]))] - predictions[ds] = pd.Series(prediction, index=list(this_x[ds].index)) - - if input_type == "df": - return predictions["d0"] - else: - return predictions - - # ------------------------------------------------------------------------- - def trace_predict( - self, - x, - burnin=1000, - thin=2000, - samples=1000, - tracefn="trace.dat", - progressfn="progress.dat", - write_files=False, - reset_files=True, - verbose=False, - progress=True, - ): - """ - Sample the space of formula trees using MCMC, - and predict y(x) for each of the sampled formula trees - - Returns: predicted y values for each of the sampled formula trees - """ - ypred = {} - # Burning - if progress: - sys.stdout.write("# Burning in\t") - sys.stdout.write("[%s]" % (" " * 50)) - sys.stdout.flush() - sys.stdout.write("\b" * (50 + 1)) - for i in range(burnin): - self.mcmc_step(verbose=verbose) - if progress and (i % (burnin / 50) == 0): - sys.stdout.write("=") - sys.stdout.flush() - # Sample - if write_files: - if reset_files: - tracef = open(tracefn, "w") - progressf = open(progressfn, "w") - else: - tracef = open(tracefn, "a") - progressf = open(progressfn, "a") - if progress: - sys.stdout.write("\n# Sampling\t") - sys.stdout.write("[%s]" % (" " * 50)) - sys.stdout.flush() - sys.stdout.write("\b" * (50 + 1)) - - for s in range(samples): - for kk in range(thin): - self.mcmc_step(verbose=verbose) - # Make prediction - ypred[s] = self.predict(x) - # Output - if progress and (s % (samples / 50) == 0): - sys.stdout.write("=") - sys.stdout.flush() - if write_files: - json.dump( - [ - s, - float(self.bic), - float(self.E), - float(self.get_energy(verbose=verbose)), - str(self), - self.par_values, - ], - tracef, - ) - tracef.write("\n") - tracef.flush() - progressf.write("%d %lf %lf\n" % (s, self.E, self.bic)) - progressf.flush() - # Done - if progress: - sys.stdout.write("\n") - return pd.DataFrame.from_dict(ypred) - - -# ----------------------------------------------------------------------------- -# ----------------------------------------------------------------------------- -# MAIN -# ----------------------------------------------------------------------------- -# ----------------------------------------------------------------------------- - - -def test3(num_points=10, samples=100000): - # Create the data - x = pd.DataFrame( - dict([("x%d" % i, np.random.uniform(0, 10, num_points)) for i in range(5)]) - ) - eps = np.random.normal(0.0, 5, num_points) - y = 50.0 * np.sin(x["x0"]) / x["x2"] - 4.0 * x["x1"] + 3 + eps - x.to_csv("data_x.csv", index=False) - y.to_csv("data_y.csv", index=False, header=["y"]) - - # Create the formula - prior_par, _ = get_priors() - t = Tree( - variables=["x%d" % i for i in range(5)], - parameters=["a%d" % i for i in range(10)], - x=x, - y=y, - prior_par=prior_par, - BT=1.0, - ) - # MCMC - t.mcmc(burnin=2000, thin=10, samples=samples, verbose=True) - - # Predict - print(t.predict(x)) - print(y) - print(50.0 * np.sin(x["x0"]) / x["x2"] - 4.0 * x["x1"] + 3) - - plt.plot(t.predict(x), 50.0 * np.sin(x["x0"]) / x["x2"] - 4.0 * x["x1"] + 3) - plt.show() - - return t - - -def test4(num_points=10, samples=1000): - # Create the data - x = pd.DataFrame( - dict([("x%d" % i, np.random.uniform(0, 10, num_points)) for i in range(5)]) - ) - eps = np.random.normal(0.0, 5, num_points) - y = 50.0 * np.sin(x["x0"]) / x["x2"] - 4.0 * x["x1"] + 3 + eps - x.to_csv("data_x.csv", index=False) - y.to_csv("data_y.csv", index=False, header=["y"]) - - xtrain, ytrain = x.iloc[5:], y.iloc[5:] - xtest, ytest = x.iloc[:5], y.iloc[:5] - - # Create the formula - prior_par, _ = get_priors() - t = Tree( - variables=["x%d" % i for i in range(5)], - parameters=["a%d" % i for i in range(10)], - x=xtrain, - y=ytrain, - prior_par=prior_par, - ) - print(xtest) - - # Predict - ypred = t.trace_predict(xtest, samples=samples, burnin=10000) - - print(ypred) - print(ytest) - print(50.0 * np.sin(xtest["x0"]) / xtest["x2"] - 4.0 * xtest["x1"] + 3) - - # Done - return t - - -def test5(string="(P120 + (((ALPHACAT / _a2) + (_a2 * CDH3)) + _a0))"): - # Create the formula - prior_par, _ = get_priors("GuimeraTest2020") - - t = Tree(prior_par=prior_par, from_string=string) - for i in range(1000000): - t.mcmc_step(verbose=True) - print("-" * 150) - t2 = Tree(from_string=str(t)) - print(t) - print(t2) - if str(t2) != str(t): - raise - - return t - - -if __name__ == "__main__": - NP, NS = 100, 1000 - test5() diff --git a/autora/theorist/bms/parallel.py b/autora/theorist/bms/parallel.py deleted file mode 100644 index 6956304f5..000000000 --- a/autora/theorist/bms/parallel.py +++ /dev/null @@ -1,171 +0,0 @@ -import sys -from copy import deepcopy -from random import randint, random -from typing import Optional, Tuple - -from numpy import exp - -from .mcmc import Tree -from .prior import get_priors - - -class Parallel: - """ - The Parallel Machine Scientist Object, equipped with parallel tempering - - Attributes: - Ts: list of parallel temperatures - trees: list of parallel trees, corresponding to each parallel temperature - t1: equation tree which best describes the data - """ - - # ------------------------------------------------------------------------- - def __init__( - self, - Ts: list, - ops=get_priors()[1], - custom_ops={}, - variables=["x"], - parameters=["a"], - max_size=50, - prior_par=get_priors()[0], - x=None, - y=None, - root=None, - seed=None, - ) -> None: - """ - Initialises Parallel Machine Scientist - - Args: - Ts: list of temperature values - ops: allowed operations for the search task - variables: independent variables from data - parameters: settable values to improve model fit - max_size: maximum size (number of nodes) in a tree - prior_par: prior values over ops - x: independent variables of dataset - y: dependent variable of dataset - root: fixed root of the tree - """ - self.root = root - # All trees are initialized to the same tree but with different BT - Ts.sort() - self.Ts = [str(T) for T in Ts] - self.trees = { - "1.0": Tree( - ops=ops, - variables=deepcopy(variables), - parameters=deepcopy(parameters), - prior_par=deepcopy(prior_par), - x=x, - y=y, - max_size=max_size, - BT=1, - root_value=root.__name__ if root is not None else None, - fixed_root=True if root is not None else False, - custom_ops=custom_ops, - seed_value=seed, - ) - } - self.t1 = self.trees["1.0"] - for BT in [T for T in self.Ts if T != 1]: - treetmp = Tree( - ops=ops, - variables=deepcopy(variables), - parameters=deepcopy(parameters), - prior_par=deepcopy(prior_par), - x=x, - y=y, - root_value=root.__name__ if root is not None else None, - fixed_root=self.t1.fixed_root, - custom_ops=custom_ops, - max_size=max_size, - BT=float(BT), - seed_value=seed, - ) - self.trees[BT] = treetmp - # Share fitted parameters and representative with other trees - self.trees[BT].fit_par = self.t1.fit_par - self.trees[BT].representative = self.t1.representative - - # ------------------------------------------------------------------------- - def mcmc_step(self, verbose=False, p_rr=0.05, p_long=0.45) -> None: - """ - Perform a MCMC step in each of the trees - """ - # Loop over all trees - if self.root is not None: - p_rr = 0.0 - for T, tree in list(self.trees.items()): - # MCMC step - tree.mcmc_step(verbose=verbose, p_rr=p_rr, p_long=p_long) - self.t1 = self.trees["1.0"] - - # ------------------------------------------------------------------------- - def tree_swap(self) -> Tuple[Optional[str], Optional[str]]: - """ - Choose a pair of trees of adjacent temperatures and attempt to swap their temperatures - based on the resultant energy change - - Returns: new temperature values for the pair of trees - """ - # Choose Ts to swap - nT1 = randint(0, len(self.Ts) - 2) - nT2 = nT1 + 1 - t1 = self.trees[self.Ts[nT1]] - t2 = self.trees[self.Ts[nT2]] - # The temperatures and energies - BT1, BT2 = t1.BT, t2.BT - EB1, EB2 = t1.EB, t2.EB - # The energy change - DeltaE = float(EB1) * (1.0 / BT2 - 1.0 / BT1) + float(EB2) * ( - 1.0 / BT1 - 1.0 / BT2 - ) - if DeltaE > 0: - paccept = exp(-DeltaE) - else: - paccept = 1.0 - # Accept/reject change - if random() < paccept: - self.trees[self.Ts[nT1]] = t2 - self.trees[self.Ts[nT2]] = t1 - t1.BT = BT2 - t2.BT = BT1 - self.t1 = self.trees["1.0"] - return self.Ts[nT1], self.Ts[nT2] - else: - return None, None - - # ------------------------------------------------------------------------- - def anneal(self, n=1000, factor=5) -> None: - """ - Annealing function for the Machine Scientist - - Args: - n: number of mcmc step & tree swap iterations - factor: degree of annealing - how much the temperatures are raised - - Returns: Nothing - - """ - for t in list(self.trees.values()): - t.BT *= factor - for kk in range(n): - print( - "# Annealing heating at %g: %d / %d" % (self.trees["1.0"].BT, kk, n), - file=sys.stderr, - ) - self.mcmc_step() - self.tree_swap() - # Cool down (return to original temperatures) - for BT, t in list(self.trees.items()): - t.BT = float(BT) - for kk in range(2 * n): - print( - "# Annealing cooling at %g: %d / %d" - % (self.trees["1.0"].BT, kk, 2 * n), - file=sys.stderr, - ) - self.mcmc_step() - self.tree_swap() diff --git a/autora/theorist/bms/prior.py b/autora/theorist/bms/prior.py deleted file mode 100644 index 973d9bdd2..000000000 --- a/autora/theorist/bms/prior.py +++ /dev/null @@ -1,90 +0,0 @@ -import numpy as np - - -def __get_prior(prior_name): - prior_dict = { - "GuimeraTest2020": { - "Nopi_/": 0, - "Nopi_cosh": 0, - "Nopi_-": 0, - "Nopi_sin": 0, - "Nopi_tan": 0, - "Nopi_tanh": 0, - "Nopi_**": 0, - "Nopi_pow2": 0, - "Nopi_pow3": 0, - "Nopi_exp": 0, - "Nopi_log": 0, - "Nopi_sqrt": 0, - "Nopi_cos": 0, - "Nopi_sinh": 0, - "Nopi_abs": 0, - "Nopi_+": 0, - "Nopi_*": 0, - "Nopi_fac": 0, - "Nopi_sig": 0, - "Nopi_relu": 0, - }, - "Guimera2020": { - "Nopi_/": 5.912205942815285, - "Nopi_cosh": 8.12720511103694, - "Nopi_-": 3.350846072163632, - "Nopi_sin": 5.965917796154835, - "Nopi_tan": 8.127427922862411, - "Nopi_tanh": 7.799259068142255, - "Nopi_**": 6.4734429542245495, - "Nopi_pow2": 3.3017352779079734, - "Nopi_pow3": 5.9907496760026175, - "Nopi_exp": 4.768665265735502, - "Nopi_log": 4.745957377206544, - "Nopi_sqrt": 4.760686909134266, - "Nopi_cos": 5.452564657261127, - "Nopi_sinh": 7.955723540761046, - "Nopi_abs": 6.333544134938385, - "Nopi_+": 5.808163661224514, - "Nopi_*": 5.002213595420244, - "Nopi_fac": 10.0, - "Nopi2_*": 1.0, - "Nopi_sig": 1.0, # arbitrarily set for now - "Nopi_relu": 1.0, # arbitrarily set for now - }, - } - assert prior_dict[prior_name] is not None, "prior key not recognized" - return prior_dict[prior_name] - - -def __get_ops(): - ops = { - "sin": 1, - "cos": 1, - "tan": 1, - "exp": 1, - "log": 1, - "sinh": 1, - "cosh": 1, - "tanh": 1, - "pow2": 1, - "pow3": 1, - "abs": 1, - "sqrt": 1, - "fac": 1, - "-": 1, - "+": 2, - "*": 2, - "/": 2, - "**": 2, - "sig": 1, - "relu": 1, - } - return ops - - -def get_priors(prior="Guimera2020"): - priors = __get_prior(prior) - all_ops = __get_ops() - ops = {k: v for k, v in all_ops.items() if "Nopi_" + k in priors} - return priors, ops - - -def relu(x): - return np.maximum(x, 0) diff --git a/autora/theorist/bms/utils.py b/autora/theorist/bms/utils.py deleted file mode 100755 index d9f047f85..000000000 --- a/autora/theorist/bms/utils.py +++ /dev/null @@ -1,89 +0,0 @@ -import logging -from copy import deepcopy -from typing import List, Tuple - -import matplotlib.pyplot as plt -import numpy as np -import pandas as pd -from tqdm import tqdm - -from .mcmc import Tree -from .parallel import Parallel - -logging.basicConfig(level=logging.INFO) -_logger = logging.getLogger(__name__) - - -def run( - pms: Parallel, num_steps: int, thinning: int = 100 -) -> Tuple[Tree, float, List[float]]: - """ - - Args: - pms: Parallel Machine Scientist (BMS is essentially a wrapper for pms) - num_steps: number of epochs / mcmc step & tree swap iterations - thinning: number of epochs between recording model loss to the trace - - Returns: - model: The equation which best describes the data - model_len: (defined as description length) loss function score - desc_len: Record of loss function score over time - - """ - desc_len, model, model_len = [], pms.t1, np.inf - for n in tqdm(range(num_steps)): - pms.mcmc_step() - pms.tree_swap() - if num_steps % thinning == 0: # sample less often if we thin more - desc_len.append(pms.t1.E) # Add the description length to the trace - if pms.t1.E < model_len: # Check if this is the MDL expression so far - model, model_len = deepcopy(pms.t1), pms.t1.E - _logger.debug("Finish iteration {}".format(n)) - return model, model_len, desc_len - - -def present_results(model: Tree, model_len: float, desc_len: List[float]) -> None: - """ - Prints out the best equation, its description length, - along with a plot of how this has progressed over the course of the search tasks - - Args: - model: The equation which best describes the data - model_len: The equation loss (defined as description length) - desc_len: Record of equation loss over time - - Returns: Nothing - - """ - print("Best model:\t", model) - print("Desc. length:\t", model_len) - plt.figure(figsize=(15, 5)) - plt.plot(desc_len) - plt.xlabel("MCMC step", fontsize=14) - plt.ylabel("Description length", fontsize=14) - plt.title("MDL model: $%s$" % model.latex()) - plt.show() - - -def predict(model: Tree, x: pd.DataFrame, y: pd.DataFrame) -> dict: - """ - Maps independent variable data onto expected dependent variable data - - Args: - model: The equation / function that best maps x onto y - x: The independent variables of the data - y: The dependent variable of the data - - Returns: Predicted values for y given x and the model as trained - """ - plt.figure(figsize=(6, 6)) - plt.scatter(model.predict(x), y) - - all_y = np.append(y, model.predict(x)) - y_range = all_y.min().item(), all_y.max().item() - plt.plot(y_range, y_range) - - plt.xlabel("MDL model predictions", fontsize=14) - plt.ylabel("Actual values", fontsize=14) - plt.show() - return model.predict(x) diff --git a/autora/theorist/bsr/__init__.py b/autora/theorist/bsr/__init__.py deleted file mode 100644 index e69de29bb..000000000 diff --git a/autora/theorist/bsr/funcs.py b/autora/theorist/bsr/funcs.py deleted file mode 100644 index 15c728777..000000000 --- a/autora/theorist/bsr/funcs.py +++ /dev/null @@ -1,927 +0,0 @@ -import copy -from enum import Enum -from functools import wraps -from typing import Callable, Dict, List, Optional, Tuple, Union, cast - -import numpy as np -import pandas as pd -from scipy.stats import invgamma, norm - -from .node import Node, NodeType - - -def check_empty(func: Callable): - """ - A decorator that, if applied to `func`, checks whether an argument in `func` is an - un-initialized node (i.e. node.node_type == NodeType.Empty). If so, an error is raised. - """ - - @wraps(func) - def func_wrapper(*args, **kwargs): - for arg in args: - if isinstance(arg, Node): - if arg.node_type == NodeType.EMPTY: - raise TypeError( - "uninitialized node found in {}".format(func.__name__) - ) - break - return func(*args, **kwargs) - - return func_wrapper - - -@check_empty -def get_height(node: Node) -> int: - """ - Get the height of a tree starting from `node` as root. The height of a leaf is defined as 0. - - Arguments: - node: the Node that we hope to calculate `height` for - Returns: - height: the height of `node` - """ - if node.node_type == NodeType.LEAF: - return 0 - elif node.node_type == NodeType.UNARY: - return 1 + get_height(node.left) - else: # binary node - return 1 + max(get_height(node.left), get_height(node.right)) - - -@check_empty -def update_depth(node: Node, depth: int): - """ - Update the depth information of all nodes starting from root `node`, whose depth - is set equal to the given `depth`. - """ - node.depth = depth - if node.node_type == NodeType.UNARY: - update_depth(node.left, depth + 1) - elif node.node_type == NodeType.BINARY: - update_depth(node.left, depth + 1) - update_depth(node.right, depth + 1) - - -@check_empty -def get_all_nodes(node: Node) -> List[Node]: - """ - Get all the nodes below (and including) the given `node` via pre-order traversal - - Return: - a list with all the nodes below (and including) the given `node` - """ - nodes = [node] - if node.node_type == NodeType.UNARY: - nodes.extend(get_all_nodes(node.left)) - elif node.node_type == NodeType.BINARY: - nodes.extend(get_all_nodes(node.left)) - nodes.extend(get_all_nodes(node.right)) - return nodes - - -@check_empty -def get_num_lt_nodes(node: Node) -> int: - """ - Get the number of nodes with `lt` operation in a tree starting from `node` - """ - if node.node_type == NodeType.LEAF: - return 0 - else: - base = 1 if node.op_name == "ln" else 0 - if node.node_type == NodeType.UNARY: - return base + get_num_lt_nodes(node.left) - else: - return base + get_num_lt_nodes(node.left) + get_num_lt_nodes(node.right) - - -@check_empty -def calc_tree_ll( - node: Node, ops_priors: Dict[str, Dict], n_feature: int = 1, **hyper_params -): - """ - Calculate the likelihood-related quantities of the given tree `node`. - - Arguments: - node: the tree node for which the calculations are done - ops_priors: the dictionary that maps operation names to their prior info - n_feature: number of features in the input data - hyperparams: hyperparameters for initialization - - Returns: - struct_ll: tree structure-related likelihood - params_ll: tree parameters-related likelihood - """ - struct_ll = 0 # log likelihood of tree structure S = (T,M) - params_ll = 0 # log likelihood of linear params - depth = node.depth - beta = hyper_params.get("beta", -1) - sigma_a, sigma_b = hyper_params.get("sigma_a", 1), hyper_params.get("sigma_b", 1) - - # contribution of hyperparameter sigma_theta - if not depth: # root node - struct_ll += np.log(invgamma.pdf(sigma_a, 1)) - struct_ll += np.log(invgamma.pdf(sigma_b, 1)) - - # contribution of splitting the node or becoming leaf node - if node.node_type == NodeType.LEAF: - # contribution of choosing terminal - struct_ll += np.log(1 - 1 / np.power((1 + depth), -beta)) - # contribution of feature selection - struct_ll -= np.log(n_feature) - return struct_ll, params_ll - elif node.node_type == NodeType.UNARY: # unitary operator - # contribution of child nodes are added since the log likelihood is additive - # if we assume the parameters are independent. - left = cast(Node, node.left) - struct_ll_left, params_ll_left = calc_tree_ll( - left, ops_priors, n_feature, **hyper_params - ) - struct_ll += struct_ll_left - params_ll += params_ll_left - # contribution of parameters of linear nodes - # make sure the below parameter ll calculation is extendable - if node.op_name == "ln": - params_ll -= np.power((node.params["a"] - 1), 2) / (2 * sigma_a) - params_ll -= np.power(node.params["b"], 2) / (2 * sigma_b) - params_ll -= 0.5 * np.log(4 * np.pi**2 * sigma_a * sigma_b) - else: # binary operator - left = cast(Node, node.left) - right = cast(Node, node.right) - struct_ll_left, params_ll_left = calc_tree_ll( - left, ops_priors, n_feature, **hyper_params - ) - struct_ll_right, params_ll_right = calc_tree_ll( - right, ops_priors, n_feature, **hyper_params - ) - struct_ll += struct_ll_left + struct_ll_right - params_ll += params_ll_left + params_ll_right - - op_weight = ops_priors[node.op_name]["weight"] - # for unary & binary nodes, additionally consider the contribution of splitting - if not depth: # root node - struct_ll += np.log(op_weight) - else: - struct_ll += np.log((1 + depth)) * beta + np.log(op_weight) - - return struct_ll, params_ll - - -def calc_y_ll(y: np.ndarray, outputs: Union[np.ndarray, pd.DataFrame], sigma_y: float): - """ - Calculate the log likelihood f(y|S,Theta,x) where (S,Theta) is represented by the - node prior is y ~ N(output,sigma) and output is the matrix of outputs corresponding to - different roots. - - Returns: - log_sum: the data log likelihood - """ - outputs = copy.deepcopy(outputs) - scale = np.max(np.abs(outputs)) - outputs = outputs / scale - epsilon = np.eye(outputs.shape[1]) * 1e-6 - beta = np.linalg.inv(np.matmul(outputs.transpose(), outputs) + epsilon) - beta = np.matmul(beta, np.matmul(outputs.transpose(), y)) - # perform the linear combination - output = np.matmul(outputs, beta) - # calculate the squared error - error = np.sum(np.square(y - output[:, 0])) - - log_sum = error - var = 2 * sigma_y * sigma_y - log_sum = -log_sum / var - log_sum -= 0.5 * len(y) * np.log(np.pi * var) - return log_sum - - -def stay(lt_nodes: List[Node], **hyper_params: Dict): - """ - ACTION 1: Stay represents the action of doing nothing but to update the parameters for `ln` - operators. - - Arguments: - lt_nodes: the list of nodes with `ln` operator - hyper_params: hyperparameters for re-initialization - """ - for lt_node in lt_nodes: - lt_node._init_param(**hyper_params) - - -def grow( - node: Node, - ops_name_lst: List[str], - ops_weight_lst: List[float], - ops_priors: Dict[str, Dict], - n_feature: int = 1, - **hyper_params -): - """ - ACTION 2: Grow represents the action of growing a subtree from a given `node` - - Arguments: - node: the tree node from where the subtree starts to grow - ops_name_lst: list of operation names - ops_weight_lst: list of operation prior weights - ops_priors: the dictionary of operation prior properties - n_feature: the number of features in input data - hyper_params: hyperparameters for re-initialization - """ - depth = node.depth - p = 1 / np.power((1 + depth), -hyper_params.get("beta", -1)) - - if depth > 0 and p < np.random.uniform(0, 1, 1): # create leaf node - node.setup(feature=np.random.randint(0, n_feature, 1)) - else: - ops_name = np.random.choice(ops_name_lst, p=ops_weight_lst) - ops_prior = ops_priors[ops_name] - node.setup(ops_name, ops_prior, hyper_params=hyper_params) - - # recursively set up downstream nodes - grow( - cast(Node, node.left), - ops_name_lst, - ops_weight_lst, - ops_priors, - n_feature, - **hyper_params - ) - if node.node_type == NodeType.BINARY: - grow( - cast(Node, node.right), - ops_name_lst, - ops_weight_lst, - ops_priors, - n_feature, - **hyper_params - ) - - -@check_empty -def prune(node: Node, n_feature: int = 1): - """ - ACTION 3: Prune a non-terminal node into a terminal node and assign it a feature - - Arguments: - node: the tree node to be pruned - n_feature: the number of features in input data - """ - node.setup(feature=np.random.randint(0, n_feature, 1)) - - -@check_empty -def de_transform(node: Node) -> Tuple[Node, Optional[Node]]: - """ - ACTION 4: De-transform deletes the current `node` and replaces it with children - according to the following rule: if the `node` is unary, simply replace with its - child; if `node` is binary and root, choose any children that's not leaf; if `node` - is binary and not root, pick any children. - - Arguments: - node: the tree node that gets de-transformed - - Returns: - first node is the replaced node when `node` has been de-transformed - second node is the discarded node - """ - left = cast(Node, node.left) - if node.node_type == NodeType.UNARY: - return left, None - - r = np.random.random() - right = cast(Node, node.right) - # picked node is root - if not node.depth: - if left.node_type == NodeType.LEAF: - return right, left - elif right.node_type == NodeType.LEAF: - return left, right - else: - return (left, right) if r < 0.5 else (right, left) - elif r < 0.5: - return left, right - else: - return right, left - - -@check_empty -def transform( - node: Node, - ops_name_lst: List[str], - ops_weight_lst: List[float], - ops_priors: Dict[str, Dict], - n_feature: int = 1, - **hyper_params: Dict -) -> Node: - """ - ACTION 5: Transform inserts a middle node between the picked `node` and its - parent. Assign an operation to this middle node using the priors. If the middle - node is binary, `grow` its right child. The left child of the middle node is - set to `node` and its parent becomes `node.parent`. - - Arguments: - node: the tree node that gets transformed - ops_name_lst: list of operation names - ops_weight_lst: list of operation prior weights - ops_priors: the dictionary of operation prior properties - n_feature: the number of features in input data - hyper_params: hyperparameters for re-initialization - - Return: - the middle node that gets inserted - """ - parent = node.parent - - insert_node = Node(depth=node.depth, parent=parent) - insert_op = np.random.choice(ops_name_lst, 1, ops_weight_lst)[0] - insert_node.setup(insert_op, ops_priors[insert_op], hyper_params=hyper_params) - - if parent: - is_left = node is parent.left - if is_left: - parent.left = insert_node - else: - parent.right = insert_node - - # set the left child as `node` and grow the right child if needed (binary case) - insert_node.left = node - node.parent = insert_node - if insert_node.node_type == NodeType.BINARY: - grow( - cast(Node, insert_node.right), - ops_name_lst, - ops_weight_lst, - ops_priors, - n_feature, - **hyper_params - ) - - # make sure the depth property is updated correctly - update_depth(node, node.depth + 1) - return insert_node - - -@check_empty -def reassign_op( - node: Node, - ops_name_lst: List[str], - ops_weight_lst: List[float], - ops_priors: Dict[str, Dict], - n_feature: int = 1, - **hyper_params: Dict -): - """ - ACTION 6: Re-assign action uniformly picks a non-terminal node, and assign a new operator. - If the node changes from unary to binary, its original child is taken as the left child, - and we grow a new subtree as right child. If the node changes from binary to unary, we - preserve the left subtree (this is to make the transition reversible). - - Arguments: - node: the tree node that gets re-assigned an operator - ops_name_lst: list of operation names - ops_weight_lst: list of operation prior weights - ops_priors: the dictionary of operation prior properties - n_feature: the number of features in input data - hyper_params: hyperparameters for re-initialization - """ - # make sure `node` is non-terminal - old_type = node.node_type - assert old_type != NodeType.LEAF - - # store the original children and re-setup the `node` - old_left, old_right = node.left, node.right - new_op = np.random.choice(ops_name_lst, 1, ops_weight_lst)[0] - node.setup(new_op, ops_priors[new_op], hyper_params=hyper_params) - - new_type = node.node_type - - node.left = old_left - if old_type == new_type: # binary -> binary & unary -> unary - node.right = old_right - elif new_type == NodeType.BINARY: # unary -> binary - grow( - cast(Node, node.right), - ops_name_lst, - ops_weight_lst, - ops_priors, - n_feature, - **hyper_params - ) - else: - node.right = None - - -@check_empty -def reassign_feat(node: Node, n_feature: int = 1): - """ - ACTION 7: Re-assign feature randomly picks a feature and assign it to `node`. - - Arguments: - node: the tree node that gets re-assigned a feature - n_feature: the number of features in input data - """ - # make sure we have a leaf node - assert node.node_type == NodeType.LEAF - node.setup(feature=np.random.randint(0, n_feature, 1)) - - -class Action(int, Enum): - """ - Enum class that represents a MCMC step with a certain action - """ - - STAY = 0 - GROW = 1 - PRUNE = 2 - DE_TRANSFORM = 3 - TRANSFORM = 4 - REASSIGN_OP = 5 - REASSIGN_FEAT = 6 - - @classmethod - def rand_action( - cls, lt_num: int, term_num: int, de_trans_num: int - ) -> Tuple[int, List[float]]: - """ - Draw a random action for MCMC algorithm to take a step - - Arguments: - lt_num: the number of linear (`lt`) nodes in the tree - term_num: the number of terminal nodes in the tree - de_trans_num: the number of de-trans qualified nodes in the tree - (see `propose` for details) - - Returns: - action: the MCMC action to perform - weights: the probabilities for each action - """ - # from the BSR paper - weights = [] - weights.append(0.25 * lt_num / (lt_num + 3)) # p_stay - weights.append((1 - weights[0]) * min(1, 4 / (term_num + 2)) / 3) # p_grow - weights.append((1 - weights[0]) / 3 - weights[1]) # p_prune - weights.append( - ((1 - weights[0]) * (1 / 3) * de_trans_num / (3 + de_trans_num)) - ) # p_detrans - weights.append((1 - weights[0]) / 3 - weights[3]) # p_trans - weights.append((1 - weights[0]) / 6) # p_reassign_op - weights.append(1 - sum(weights)) # p_reassign_feat - assert weights[-1] >= 0 - - action = np.random.choice(np.arange(7), p=weights) - return action, weights - - -def _get_tree_classified_nodes( - root: Node, -) -> Tuple[List[Node], List[Node], List[Node], List[Node]]: - """ - calculate the classified lists of nodes from a tree - - Argument: - root: the root node where the calculation starts from - Returns: - term_nodes: the list of terminal nodes (or the count of this list, same below) - nterm_nodes: the list of non-terminal nodes - lt_nodes: the list of nodes with linear operator - de_trans_nodes: the list of nodes that can be de-transformed - """ - term_nodes: List[Node] = [] - nterm_nodes: List[Node] = [] - lt_nodes: List[Node] = [] - de_trans_nodes: List[Node] = [] - for node in get_all_nodes(root): - if node.node_type == NodeType.LEAF: - term_nodes.append(node) - else: - nterm_nodes.append(node) - # rules for deciding whether a non-terminal node is de-transformable - # 1. node is not root OR 2. children are not both terminal nodes - if node.depth or (node.left or node.right): - de_trans_nodes.append(node) - if node.op_name == "ln": - lt_nodes.append(node) - - return term_nodes, nterm_nodes, lt_nodes, de_trans_nodes - - -def _get_tree_classified_counts(root: Node) -> Tuple[int, int, int, int]: - """ - Helper function that returns the counts (lengths) of the classified node lists from - `_get_tree_classified_nodes`, instead of the lists themselves. - """ - term_nodes, nterm_nodes, lt_nodes, de_trans_nodes = _get_tree_classified_nodes(root) - return len(term_nodes), len(nterm_nodes), len(lt_nodes), len(de_trans_nodes) - - -@check_empty -def prop( - node: Node, - ops_name_lst: List[str], - ops_weight_lst: List[float], - ops_priors: Dict[str, Dict], - n_feature: int = 1, - **hyper_params -): - """ - Propose a new tree from an existing tree with root `node`. - - Arguments: - node: the existing tree node - ops_name_lst: the list of operator names - ops_weight_lst: the list of operator weights - ops_priors: the dictionary of operator prior information - n_feature: the number of features in input data - hyper_params: hyperparameters for initialization - - Return: - new_node: the new node after some action is applied - expand_node: whether the node has been expanded - shrink_node: whether the node has been shrunk - q: quantities for calculating acceptance prob - q_inv: quantities for calculating acceptance prob - """ - # PART 1: collect necessary information - new_node = copy.deepcopy(node) - term_nodes, nterm_nodes, lt_nodes, de_trans_nodes = _get_tree_classified_nodes( - new_node - ) - - # PART 2: sample random action and perform the action - # this step also calculates q and q_inv, quantities necessary for calculating - # the acceptance probability in MCMC algorithm - action, probs = Action.rand_action( - len(lt_nodes), len(term_nodes), len(de_trans_nodes) - ) - # flags indicating potential dimensionality change (expand or shrink) in node - expand_node, shrink_node = False, False - - # ACTION 1: STAY - # q and q_inv simply equal the probability of choosing this action - if action == Action.STAY: - q = probs[Action.STAY] - q_inv = probs[Action.STAY] - stay(lt_nodes, **hyper_params) - # ACTION 2: GROW - # q and q_inv simply equal the probability if the grown node is a leaf node - # otherwise, we calculate new information of the `new_node` after the action is applied - elif action == Action.GROW: - i = np.random.randint(0, len(term_nodes), 1)[0] - grown_node: Node = term_nodes[i] - grow( - grown_node, - ops_name_lst, - ops_weight_lst, - ops_priors, - n_feature, - **hyper_params - ) - if grown_node.node_type == NodeType.LEAF: - q = q_inv = 1 - else: - tree_ll, param_ll = calc_tree_ll( - grown_node, ops_priors, n_feature, **hyper_params - ) - # calculate q - q = probs[Action.GROW] * np.exp(tree_ll) / len(term_nodes) - # calculate q_inv by using updated information of `new_node` - ( - new_term_count, - new_nterm_count, - new_lt_count, - _, - ) = _get_tree_classified_counts(new_node) - new_prob = ( - (1 - 0.25 * new_lt_count / (new_lt_count + 3)) - * (1 - min(1, 4 / (new_nterm_count + 2))) - / 3 - ) - q_inv = new_prob / max(1, new_nterm_count - 1) # except the root - if new_lt_count > len(lt_nodes): - expand_node = True - # ACTION 3: PRUNE - elif action == Action.PRUNE: - i = np.random.randint(0, len(nterm_nodes), 1)[0] - pruned_node: Node = nterm_nodes[i] - prune(pruned_node, n_feature) - tree_ll, param_ll = calc_tree_ll( - pruned_node, ops_priors, n_feature, **hyper_params - ) - - new_term_count, new_nterm_count, new_lt_count, _ = _get_tree_classified_counts( - new_node - ) - # pruning any tree with `ln` operator will result in shrinkage - if new_lt_count < len(lt_nodes): - shrink_node = True - - # calculate q - q = probs[Action.PRUNE] / ((len(nterm_nodes) - 1) * n_feature) - pg = 1 - 0.25 * new_lt_count / (new_lt_count + 3) * 0.75 * min( - 1, 4 / (new_nterm_count + 2) - ) - # calculate q_inv - q_inv = pg * np.exp(tree_ll) / new_term_count - # ACTION 4: DE_TRANSFORM - elif action == Action.DE_TRANSFORM: - num_de_trans = len(de_trans_nodes) - i = np.random.randint(0, num_de_trans, 1)[0] - de_trans_node: Node = de_trans_nodes[i] - replaced_node, discarded_node = de_transform(de_trans_node) - par_node = de_trans_node.parent - - q = probs[Action.DE_TRANSFORM] / num_de_trans - if ( - not par_node - and de_trans_node.left - and de_trans_node.right - and de_trans_node.left.node_type != NodeType.LEAF - and de_trans_node.right.node_type != NodeType.LEAF - ): - q = q / 2 - elif de_trans_node.node_type == NodeType.BINARY: - q = q / 2 - - if not par_node: # de-transformed the root - new_node = replaced_node - new_node.parent = None - update_depth(new_node, 0) - elif par_node.left is de_trans_node: - par_node.left = replaced_node - replaced_node.parent = par_node - update_depth(replaced_node, par_node.depth + 1) - else: - par_node.right = replaced_node - replaced_node.parent = par_node - update_depth(replaced_node, par_node.depth + 1) - - ( - new_term_count, - new_nterm_count, - new_lt_count, - new_det_count, - ) = _get_tree_classified_counts(new_node) - - if new_lt_count < len(lt_nodes): - shrink_node = True - - new_prob = 0.25 * new_lt_count / (new_lt_count + 3) - # calculate q_inv - new_pdetr = (1 - new_prob) * (1 / 3) * new_det_count / (new_det_count + 3) - new_ptr = (1 - new_prob) / 3 - new_pdetr - q_inv = ( - new_ptr - * ops_priors[de_trans_node.op_name]["weight"] - / (new_term_count + new_nterm_count) - ) - if discarded_node: - tree_ll, _ = calc_tree_ll( - discarded_node, ops_priors, n_feature, **hyper_params - ) - q_inv = q_inv * np.exp(tree_ll) - # ACTION 5: TRANSFORM - elif action == Action.TRANSFORM: - all_nodes = get_all_nodes(new_node) - i = np.random.randint(0, len(all_nodes), 1)[0] - trans_node: Node = all_nodes[i] - inserted_node: Node = transform( - trans_node, - ops_name_lst, - ops_weight_lst, - ops_priors, - n_feature, - **hyper_params - ) - - if inserted_node.right: - ll_right, _ = calc_tree_ll( - inserted_node.right, ops_priors, n_feature, **hyper_params - ) - else: - ll_right = 0 - # calculate q - q = ( - probs[Action.TRANSFORM] - * ops_priors[inserted_node.op_name]["weight"] - * np.exp(ll_right) - / len(all_nodes) - ) - - ( - new_term_count, - new_nterm_count, - new_lt_count, - new_det_count, - ) = _get_tree_classified_counts(new_node) - if new_lt_count > len(lt_nodes): - expand_node = True - - new_prob = 0.25 * new_lt_count / (new_lt_count + 3) - # calculate q_inv - new_pdetr = (1 - new_prob) * (1 / 3) * new_det_count / (new_det_count + 3) - q_inv = new_pdetr / new_det_count - if ( - inserted_node.left - and inserted_node.right - and inserted_node.left.node_type != NodeType.LEAF - and inserted_node.right.node_type != NodeType.LEAF - ): - q_inv = q_inv / 2 - # ACTION 6: REASSIGN OPERATION - elif action == Action.REASSIGN_OP: - i = np.random.randint(0, len(nterm_nodes), 1)[0] - reassign_node: Node = nterm_nodes[i] - old_right = reassign_node.right - old_op_name, old_type = reassign_node.op_name, reassign_node.node_type - reassign_op( - reassign_node, - ops_name_lst, - ops_weight_lst, - ops_priors, - n_feature, - **hyper_params - ) - new_type = reassign_node.node_type - _, new_nterm_count, new_lt_count, _ = _get_tree_classified_counts(new_node) - - if old_type == new_type: # binary -> binary & unary -> unary - q = ops_priors[reassign_node.op_name]["weight"] - q_inv = ops_priors[old_op_name]["weight"] - else: - op_weight = ops_priors[reassign_node.op_name]["weight"] - if old_type == NodeType.UNARY: # unary -> binary - tree_ll, _ = calc_tree_ll( - reassign_node.right, ops_priors, n_feature, **hyper_params - ) - q = ( - probs[Action.REASSIGN_OP] - * np.exp(tree_ll) - * op_weight - / len(nterm_nodes) - ) - ll_factor = 1 - else: # binary -> unary - tree_ll, _ = calc_tree_ll( - old_right, ops_priors, n_feature, **hyper_params - ) - q = probs[Action.REASSIGN_OP] * op_weight / len(nterm_nodes) - ll_factor = tree_ll - # calculate q_inv - new_prob = new_lt_count / (4 * (new_lt_count + 3)) - q_inv = ( - 0.125 - * (1 - new_prob) - * ll_factor - * ops_priors[old_op_name]["weight"] - / new_nterm_count - ) - if new_lt_count > len(lt_nodes): - expand_node = True - elif new_lt_count < len(lt_nodes): - shrink_node = True - # ACTION 7: REASSIGN FEATURE - else: - i = np.random.randint(0, len(term_nodes), 1)[0] - reassign_node = term_nodes[i] - reassign_feat(reassign_node, n_feature) - q = q_inv = 1 - - return new_node, expand_node, shrink_node, q, q_inv - - -def calc_aux_ll(node: Node, **hyper_params) -> Tuple[float, int]: - """ - Calculate the likelihood of generating auxiliary parameters - - Arguments: - node: the node from which the auxiliary params are generated - hyper_params: hyperparameters for generating auxiliary params - - Returns: - log_aux: log likelihood of auxiliary params - lt_count: number of nodes with `lt` operator in the tree with - `node` as its root - """ - sigma_a, sigma_b = hyper_params["sigma_a"], hyper_params["sigma_b"] - log_aux = np.log(invgamma.pdf(sigma_a, 1)) + np.log(invgamma.pdf(sigma_b, 1)) - - all_nodes = get_all_nodes(node) - lt_count = 0 - for i in range(all_nodes): - if all_nodes[i].op_name == "ln": - lt_count += 1 - a, b = all_nodes[i].params["a"], all_nodes[i].params["b"] - log_aux += np.log(norm.pdf(a, 1, np.sqrt(sigma_a))) - log_aux += np.log(norm.pdf(b, 0, np.sqrt(sigma_b))) - - return log_aux, lt_count - - -def prop_new( - roots: List[Node], - index: int, - sigma_y: float, - beta: float, - sigma_a: float, - sigma_b: float, - X: Union[np.ndarray, pd.DataFrame], - y: Union[np.ndarray, pd.DataFrame], - ops_name_lst: List[str], - ops_weight_lst: List[float], - ops_priors: Dict[str, Dict], -) -> Tuple[bool, Node, float, float, float]: - """ - Propose new structure, sample new parameters and decide whether to accept the new tree. - - Arguments: - roots: the list of root nodes - index: the index of the root node to update - sigma_y: scale hyperparameter for linear mixture of expression trees - beta: hyperparameter for growing an uninitialized expression tree - sigma_a: hyperparameters for `lt` operator initialization - sigma_b: hyperparameters for `lt` operator initialization - X: input data (independent variable) matrix - y: dependent variable vector - ops_name_lst: the list of operator names - ops_weight_lst: the list of operator weights - ops_priors: the dictionary of operator prior information - - Returns: - accept: whether to accept or reject the new expression tree - root: the old or new expression tree, determined by whether to accept the new tree - sigma_y: the old or new sigma_y - sigma_a: the old or new sigma_a - sigma_b: the old or new sigma_b - """ - # the hyper-param for linear combination, i.e. for `sigma_y` - sig = 4 - K = len(roots) - root = roots[index] - use_aux_ll = True - - # sample new sigma_a and sigma_b - new_sigma_a = invgamma.rvs(1) - new_sigma_b = invgamma.rvs(1) - - hyper_params = {"sigma_a": sigma_a, "sigma_b": sigma_b, "beta": beta} - new_hyper_params = {"sigma_a": new_sigma_a, "sigma_b": new_sigma_b, "beta": beta} - # propose a new tree `node` - new_root, expand_node, shrink_node, q, q_inv = prop( - root, ops_name_lst, ops_weight_lst, ops_priors, X.shape[1], **new_hyper_params - ) - - n_feature = X.shape[0] - new_outputs = np.zeros((len(y), K)) - old_outputs = np.zeros((len(y), K)) - - for i in np.arange(K): - tmp_old = root.evaluate(X) - old_outputs[:, i] = tmp_old - if i == index: - new_outputs[:, i] = new_root.evaluate(X) - else: - new_outputs[:, i] = tmp_old - - if np.linalg.matrix_rank(new_outputs) < K: # rejection due to insufficient rank - return False, root, sigma_y, sigma_a, sigma_b - - y_ll_old = calc_y_ll(y, old_outputs, sigma_y) - # a magic number here as the parameter for generating new sigma_y - new_sigma_y = invgamma.rvs(sig) - y_ll_new = calc_y_ll(y, new_outputs, new_sigma_y) - - log_y_ratio = y_ll_new - y_ll_old - # contribution of f(Theta, S) - if shrink_node or expand_node: - struct_ll_old = sum(calc_tree_ll(root, ops_priors, n_feature, **hyper_params)) - struct_ll_new = sum( - calc_tree_ll(new_root, ops_priors, n_feature, **hyper_params) - ) - log_struct_ratio = struct_ll_new - struct_ll_old - else: - log_struct_ratio = calc_tree_ll( - new_root, ops_priors, n_feature, **hyper_params - )[0] - calc_tree_ll(root, ops_priors, n_feature, **hyper_params) - - # contribution of proposal Q and Qinv - log_q_ratio = np.log(max(1e-5, q_inv / q)) - - log_r = ( - log_y_ratio - + log_struct_ratio - + log_q_ratio - + np.log(invgamma.pdf(new_sigma_y, sig)) - - np.log(invgamma.pdf(sigma_y, sig)) - ) - - if use_aux_ll and (expand_node or shrink_node): - old_aux_ll, old_lt_count = calc_aux_ll(root, **hyper_params) - new_aux_ll, _ = calc_aux_ll(new_root, **new_hyper_params) - log_r += old_aux_ll - new_aux_ll - # log for the Jacobian matrix - log_r += np.log(max(1e-5, 1 / np.power(2, 2 * old_lt_count))) - - alpha = min(log_r, 0) - test = np.random.uniform(0, 1, 0)[0] - if np.log(test) >= alpha: # no accept - return False, root, sigma_y, sigma_a, sigma_b - else: # accept - return True, new_root, new_sigma_y, new_sigma_a, new_sigma_b diff --git a/autora/theorist/bsr/misc.py b/autora/theorist/bsr/misc.py deleted file mode 100644 index 9470d71db..000000000 --- a/autora/theorist/bsr/misc.py +++ /dev/null @@ -1,48 +0,0 @@ -from typing import Dict - -""" -a file for all miscellaneous functions that are used in BSR. -""" - - -def normalize_prior_dict(prior_dict: Dict[str, float]): - """ - Normalize the prior weights for the operators so that the weights sum to - 1 and thus can be directly interpreted/used as probabilities. - """ - prior_sum = 0.0 - for k in prior_dict: - prior_sum += prior_dict[k] - if prior_sum > 0: - for k in prior_dict: - prior_dict[k] = prior_dict[k] / prior_sum - else: - for k in prior_dict: - prior_dict[k] = 1 / len(prior_dict) - - -def get_ops_expr() -> Dict[str, str]: - """ - Get the literal expression for the operation, the `{}` placeholder represents - an expression that is recursively evaluated from downstream operations. If an - operator's expression contains additional parameters (e.g. slope/intercept in - linear operator), write the parameter like `{param}` - the param will be passed - in using `expr.format(xxx, **params)` format. - - Return: - A dictionary that maps operator name to its literal expression. - """ - ops_expr = { - "neg": "-({})", - "sin": "sin({})", - "pow2": "({})^2", - "pow3": "({})^3", - "exp": "exp({})", - "cos": "cos({})", - "+": "{}+{}", - "*": "({})*({})", - "-": "{}-{}", - "inv": "1/[{}]", - "linear": "{a}*({})+{b}", - } - return ops_expr diff --git a/autora/theorist/bsr/node.py b/autora/theorist/bsr/node.py deleted file mode 100644 index 1f0072d5a..000000000 --- a/autora/theorist/bsr/node.py +++ /dev/null @@ -1,178 +0,0 @@ -from enum import Enum -from typing import Callable, Dict, List, Optional, Union - -import numpy as np -import pandas as pd - -from .misc import get_ops_expr - - -class NodeType(Enum): - """ - -1 represents newly grown node (not decided yet) - 0 represents no child, as a terminal node - 1 represents one child, - 2 represents 2 children - """ - - EMPTY = -1 - LEAF = 0 - UNARY = 1 - BINARY = 2 - - -class Node: - def __init__( - self, - depth: int = 0, - node_type: NodeType = NodeType.EMPTY, - left: Optional["Node"] = None, - right: Optional["Node"] = None, - parent: Optional["Node"] = None, - operator: Optional[Callable] = None, - op_name: str = "", - op_arity: int = 0, - op_init: Optional[Callable] = None, - ): - # tree structure attributes - self.depth = depth - self.node_type = node_type - self.left = left - self.right = right - self.parent = parent - - # a function that does the actual calculation, see definitions below - self.operator = operator - self.op_name = op_name - self.op_arity = op_arity - self.op_init = op_init - - # holding temporary calculation result, see `evaluate()` - self.result = None - # params for additional inputs into `operator` - self.params: Dict = {} - - def _init_param(self, **hyper_params): - # init is a function randomized by some hyper-params - if callable(self.op_init): - self.params = self.op_init(**hyper_params) - else: # init is deterministic dict - self.params = self.op_init - - def setup( - self, op_name: str = "", ops_prior: Dict = {}, feature: int = 0, **hyper_params - ): - """ - Initialize an uninitialized node with given feature, in the case of a leaf node, or some - given operator information, in the case of unary or binary node. The type of the node is - determined by the feature/operator assigned to it. - - Arguments: - op_name: the operator name, if given - ops_prior: the prior dictionary of the given operator - feature: the index of the assigned feature, if given - hyper_params: hyperparameters for initializing the node - """ - self.op_name = op_name - self.operator = ops_prior.get("fn", None) - self.op_arity = ops_prior.get("arity", 0) - self.op_init = ops_prior.get("init", {}) - self._init_param(**hyper_params) - - if self.op_arity == 0: - self.params["feature"] = feature - self.node_type = NodeType.LEAF - elif self.op_arity == 1: - self.left = Node(depth=self.depth + 1, parent=self) - self.node_type = NodeType.UNARY - elif self.op_arity == 2: - self.left = Node(depth=self.depth + 1, parent=self) - self.right = Node(depth=self.depth + 1, parent=self) - self.node_type = NodeType.BINARY - else: - raise ValueError( - "operation arity should be either 0, 1, 2; get {} instead".format( - self.op_arity - ) - ) - - def evaluate( - self, X: Union[np.ndarray, pd.DataFrame], store_result: bool = False - ) -> np.array: - """ - Evaluate the expression, as represented by an expression tree with `self` as the root, - using the given data matrix `X`. - - Arguments: - X: the data matrix with each row being a data point and each column a feature - store_result: whether to store the result of this calculation - - Return: - result: the result of this calculation - """ - if X is None: - raise TypeError("input data X is non-existing") - if isinstance(X, np.ndarray): - X = pd.DataFrame(X) - if self.node_type == NodeType.LEAF: - result = np.array(X.iloc[:, self.params["feature"]]).flatten() - elif self.node_type == NodeType.UNARY: - assert self.left and self.operator - result = self.operator(self.left.evaluate(X), **self.params) - elif self.node_type == NodeType.BINARY: - assert self.left and self.right and self.operator - result = self.operator( - self.left.evaluate(X), self.right.evaluate(X), **self.params - ) - else: - raise NotImplementedError("node evaluated before being setup") - if store_result: - self.result = result - return result - - def get_expression( - self, - ops_expr: Optional[Dict[str, str]] = None, - feature_names: Optional[List[str]] = None, - ) -> str: - """ - Get a literal (string) expression of the expression tree - - Arguments: - ops_expr: the dictionary that maps an operation name to its literal format; if not - offered, use the default one in `get_ops_expr()` - feature_names: the list of names for the data features - Return: - a literal expression of the tree - """ - if not ops_expr: - ops_expr = get_ops_expr() - if self.node_type == NodeType.LEAF: - if feature_names: - return feature_names[self.params["feature"]] - else: - return f"x{self.params['feature']}" - elif self.node_type == NodeType.UNARY: - # if the expr for an operator is not defined, use placeholder - # e.g. operator `cosh` -> `cosh(xxx)` - assert self.left - place_holder = self.op_name + "({})" - left_expr = self.left.get_expression(ops_expr, feature_names) - expr_fmt = ops_expr.get(self.op_name, place_holder) - return expr_fmt.format(left_expr, **self.params) - elif self.node_type == NodeType.BINARY: - assert self.left and self.right - place_holder = self.op_name + "({})" - left_expr = self.left.get_expression(ops_expr, feature_names) - right_expr = self.right.get_expression(ops_expr, feature_names) - expr_fmt = ops_expr.get(self.op_name, place_holder) - return expr_fmt.format(left_expr, right_expr, **self.params) - else: # empty node - return "(empty node)" - - def __str__(self) -> str: - """ - Get a literal (string) representation of a tree `node` data structure. - See `get_expression` for more information. - """ - return self.get_expression() diff --git a/autora/theorist/bsr/operation.py b/autora/theorist/bsr/operation.py deleted file mode 100644 index 2d43b12a5..000000000 --- a/autora/theorist/bsr/operation.py +++ /dev/null @@ -1,70 +0,0 @@ -from typing import Callable, Dict - -import numpy as np - -""" -this file contains functions (operators) for actually carrying out the computations -in our expression tree model. An operator can take in either 1 (unary) or 2 (binary) -operands - corresponding to being used in a unary or binary node (see `node.py`). The -operand(s) are recursively evaluated `np.array` from an operation or literal (in the -case of a leaf node) in downstream node(s). - -For certain operator, e.g. a linear operator, auxiliary parameters (slope/intercept) -are needed and can be passed in through `params` dictionary. These parameters are -initialized in `prior.py` by their specified initialization functions. -""" - - -# a linear operator with default `a` = 1 and `b` = 0 (i.e. identity operation) -def linear_op(operand: np.array, **params: Dict) -> np.array: - a, b = params.get("a", 1), params.get("b", 0) - return a * operand + b - - -# a safe `exp` operation that has a cutoff (default = 1e-10) and avoids overflow -def exp_op(operand: np.array, **params: Dict) -> np.array: - cutoff = params.get("cutoff", 1e-10) - return 1 / (cutoff + np.exp(-operand)) - - -# a safe `inv` operation that has a cutoff (default = 1e-10) and avoids overflow -def inv_op(operand: np.array, **params: Dict) -> np.array: - cutoff = params.get("cutoff", 1e-10) - return 1 / (cutoff + operand) - - -def neg_op(operand: np.array) -> np.array: - return -operand - - -def sin_op(operand: np.array) -> np.array: - return np.sin(operand) - - -def cos_op(operand: np.array) -> np.array: - return np.cos(operand) - - -# high-level func that produces power funcs such as `square`, `cubic`, etc. -def make_pow_op(power: int) -> Callable[[np.array], np.array]: - def pow_op(operand: np.array) -> np.array: - return np.power(operand, power) - - return pow_op - - -""" -a list of binary operators -""" - - -def plus_op(operand_a: np.array, operand_b: np.array): - return operand_a + operand_b - - -def minus_op(operand_a: np.array, operand_b: np.array): - return operand_a - operand_b - - -def multiply_op(operand_a: np.array, operand_b: np.array): - return operand_a * operand_b diff --git a/autora/theorist/bsr/prior.py b/autora/theorist/bsr/prior.py deleted file mode 100644 index 30649d370..000000000 --- a/autora/theorist/bsr/prior.py +++ /dev/null @@ -1,175 +0,0 @@ -from typing import Callable, Dict, Union - -import numpy as np -from scipy.stats import norm - -from .misc import normalize_prior_dict -from .operation import ( - cos_op, - exp_op, - inv_op, - linear_op, - make_pow_op, - minus_op, - multiply_op, - neg_op, - plus_op, - sin_op, -) - - -def _get_ops_with_arity(): - """ - Get the operator function and arity (number of operands) of each operator. - - Returns: - ops_fn_and_arity: a dictionary that maps operator name to a list, where - the first item is the operator function and the second is the number of - operands that it takes. - """ - ops_fn_and_arity = { - "ln": [linear_op, 1], - "exp": [exp_op, 1], - "inv": [inv_op, 1], - "neg": [neg_op, 1], - "sin": [sin_op, 1], - "cos": [cos_op, 1], - "pow2": [make_pow_op(2), 1], - "pow3": [make_pow_op(3), 1], - "+": [plus_op, 2], - "*": [multiply_op, 2], - "-": [minus_op, 2], - } - return ops_fn_and_arity - - -def linear_init(**hyper_params) -> Dict: - """ - Initialization function for the linear operator. Two parameters, slope - (a) and intercept (b) are initialized. - - Arguments: - hyper_params: the dictionary for hyperparameters. Specifically, this - function requires `sigma_a` and `sigma_b` to be present. - Returns: - a dictionary with initialized `a` and `b` parameters. - """ - sigma_a, sigma_b = hyper_params.get("sigma_a", 1), hyper_params.get("sigma_b", 1) - return { - "a": norm.rvs(loc=1, scale=np.sqrt(sigma_a)), - "b": norm.rvs(loc=0, scale=np.sqrt(sigma_b)), - } - - -def _get_ops_init() -> Dict[str, Union[Callable, object]]: - """ - Get the initialization functions for operators that require additional - parameters. - - Returns: - ops_init: a dictionary that maps operator name to either a parameter - dict (in the case that the initialization is hard-coded) or an - initialization function (when it is randomized). The dictionary - value will be used in growing the `node` (see `funcs_legacy.py`). - """ - ops_init = { - "ln": linear_init, - "inv": {"cutoff": 1e-10}, - "exp": {"cutoff": 1e-10}, - } - return ops_init - - -def _get_prior(prior_name: str, prob: bool = True) -> Dict[str, float]: - prior_dict = { - "Uniform": { - "neg": 1.0, - "sin": 1.0, - "pow2": 1.0, - "pow3": 1.0, - "exp": 1.0, - "cos": 1.0, - "+": 1.0, - "*": 1.0, - "-": 1.0, - "inv": 1.0, - "ln": 1.0, - }, - "Guimera2020": { - "neg": 3.350846072163632, - "sin": 5.965917796154835, - "pow2": 3.3017352779079734, - "pow3": 5.9907496760026175, - "exp": 4.768665265735502, - "cos": 5.452564657261127, - "+": 5.808163661224514, - "*": 5.002213595420244, - "-": 1.0, # set arbitrarily now, - "inv": 1.0, # set arbitrarily now, - "ln": 1.0, # set arbitrarily now, - }, - } - assert prior_dict[prior_name] is not None, "prior key not recognized" - if prob: - normalize_prior_dict(prior_dict[prior_name]) - return prior_dict[prior_name] - - -def get_prior_dict(prior_name="Uniform"): - """ - Get the dictionary of prior information as well as several list of key operator properties - - Argument: - prior_name: the name of the prior dictionary to use - - Returns: - ops_name_lst: the list of operator names - ops_weight_lst: the list of operator weights - prior_dict: the dictionary of operator prior information - """ - ops_prior = _get_prior(prior_name) - ops_init = _get_ops_init() - ops_fn_and_arity = _get_ops_with_arity() - - ops_name_lst = list(ops_prior.keys()) - ops_weight_lst = list(ops_prior.values()) - prior_dict = { - k: { - "init": ops_init.get(k, {}), - "fn": ops_fn_and_arity[k][0], - "arity": ops_fn_and_arity[k][1], - "weight": ops_prior[k], - } - for k in ops_prior - } - - return ops_name_lst, ops_weight_lst, prior_dict - - -def get_prior_list(prior_name="Uniform"): - """ - Get a dictionary of key prior properties - - Argument: - prior_name: the name of the prior dictionary to use - - Returns: - a dictionary that maps a prior property (e.g. `name`) to the list of such properties - for each operator. - """ - ops_prior = _get_prior(prior_name) - ops_init = _get_ops_init() - ops_fn_and_arity = _get_ops_with_arity() - - ops_name_lst = list(ops_prior.keys()) - ops_weight_lst = list(ops_prior.values()) - ops_init_lst = [ops_init.get(k, None) for k in ops_name_lst] - ops_fn_lst = [ops_fn_and_arity[k][0] for k in ops_name_lst] - ops_arity_lst = [ops_fn_and_arity[k][1] for k in ops_name_lst] - return { - "name": ops_name_lst, - "weight": ops_weight_lst, - "init": ops_init_lst, - "fn": ops_fn_lst, - "arity": ops_arity_lst, - } diff --git a/autora/theorist/darts/__init__.py b/autora/theorist/darts/__init__.py deleted file mode 100644 index 6c7d2f2a4..000000000 --- a/autora/theorist/darts/__init__.py +++ /dev/null @@ -1,12 +0,0 @@ -from .architect import Architect -from .dataset import DARTSDataset, darts_dataset_from_ndarray -from .model_search import DARTSType, Network -from .operations import PRIMITIVES -from .utils import ( - AvgrageMeter, - format_input_target, - get_loss_function, - get_output_format, - get_output_str, -) -from .visualize import darts_model_plot diff --git a/autora/theorist/darts/architect.py b/autora/theorist/darts/architect.py deleted file mode 100755 index c7d723e29..000000000 --- a/autora/theorist/darts/architect.py +++ /dev/null @@ -1,337 +0,0 @@ -from typing import Optional - -import numpy as np -import torch -import torch.nn.functional as F -from torch.autograd import Variable - -from autora.theorist.darts.model_search import DARTSType, Network -from autora.theorist.darts.operations import isiterable - - -def _concat(xs) -> torch.Tensor: - """ - A function to concatenate a list of tensors. - Args: - xs: The list of tensors to concatenate. - - Returns: - The concatenated tensor. - """ - return torch.cat([x.view(-1) for x in xs]) - - -class Architect(object): - """ - A learner operating on the architecture weights of a DARTS model. - This learner handles training the weights associated with mixture operations - (architecture weights). - """ - - def __init__( - self, - model: Network, - arch_learning_rate_max: float, - arch_momentum: float, - arch_weight_decay: float, - arch_weight_decay_df: float = 0, - arch_weight_decay_base: float = 0, - fair_darts_loss_weight: float = 1, - ): - """ - Initializes the architecture learner. - - Arguments: - model: a network model implementing the full DARTS model. - arch_learning_rate_max: learning rate for the architecture weights - arch_momentum: arch_momentum used in the Adam optimizer for architecture weights - arch_weight_decay: general weight decay for the architecture weights - arch_weight_decay_df: (weight decay applied to architecture weights in proportion - to the number of parameters of an operation) - arch_weight_decay_base: (a constant weight decay applied to architecture weights) - fair_darts_loss_weight: (a regularizer that pushes architecture weights more toward - zero or one in the fair DARTS variant) - """ - # set parameters for architecture learning - self.network_arch_momentum = arch_momentum - self.network_weight_decay = arch_weight_decay - self.network_weight_decay_df = arch_weight_decay_df - self.arch_weight_decay_base = arch_weight_decay_base * model._steps - self.fair_darts_loss_weight = fair_darts_loss_weight - - self.model = model - self.lr = arch_learning_rate_max - # architecture is optimized using Adam - self.optimizer = torch.optim.Adam( - self.model.arch_parameters(), - lr=arch_learning_rate_max, - betas=(0.5, 0.999), - weight_decay=arch_weight_decay, - ) - - # initialize weight decay matrix - self._init_decay_weights() - - # initialize the logged loss - self.current_loss = 0 - - def _init_decay_weights(self): - """ - This function initializes the weight decay matrix. The weight decay matrix - is subtracted from the architecture weight matrix on every learning step. The matrix - specifies a weight decay which is proportional to the number of parameters used in an - operation. - """ - n_params = list() - for operation in self.model.cells._ops[0]._ops: - if isiterable(operation): - n_params_total = ( - 1 # any non-zero operation is counted as an additional parameter - ) - for subop in operation: - for parameter in subop.parameters(): - if parameter.requires_grad is True: - n_params_total += parameter.data.numel() - else: - n_params_total = 0 # no operation gets zero parameters - n_params.append(n_params_total) - - self.decay_weights = Variable( - torch.zeros(self.model.arch_parameters()[0].data.shape) - ) - for idx, param in enumerate(n_params): - if param > 0: - self.decay_weights[:, idx] = ( - param * self.network_weight_decay_df + self.arch_weight_decay_base - ) - else: - self.decay_weights[:, idx] = param - self.decay_weights = self.decay_weights - self.decay_weights = self.decay_weights.data - - def _compute_unrolled_model( - self, - input: torch.Tensor, - target: torch.Tensor, - eta: float, - network_optimizer: torch.optim.Optimizer, - ): - """ - Helper function used to compute the approximate architecture gradient. - - Arguments: - input: input patterns - target: target patterns - eta: learning rate - network_optimizer: optimizer used to updating the architecture weights - - Returns: - unrolled_model: the unrolled architecture - """ - loss = self.model._loss(input, target) - theta = _concat(self.model.parameters()).data - try: - moment = _concat( - network_optimizer.state[v]["momentum_buffer"] - for v in self.model.parameters() - ).mul_(self.network_arch_momentum) - except Exception: - moment = torch.zeros_like(theta) - dtheta = ( - _concat(torch.autograd.grad(loss, self.model.parameters())).data - + self.network_weight_decay * theta - ) - unrolled_model = self._construct_model_from_theta( - theta.sub(eta, moment + dtheta) - ) - return unrolled_model - - def step( - self, - input_valid: torch.Tensor, - target_valid: torch.Tensor, - network_optimizer: torch.optim.Optimizer, - unrolled: bool, - input_train: Optional[torch.Tensor] = None, - target_train: Optional[torch.Tensor] = None, - eta: float = 1, - ): - """ - Updates the architecture parameters for one training iteration - - Arguments: - input_valid: input patterns for validation set - target_valid: target patterns for validation set - network_optimizer: optimizer used to updating the architecture weights - unrolled: whether to use the unrolled architecture or not (i.e., whether to use - the approximate architecture gradient or not) - input_train: input patterns for training set - target_train: target patterns for training set - eta: learning rate for the architecture weights - """ - - # input_train, target_train only needed for approximation (unrolled=True) - # of architecture gradient - # when performing a single weigh update - - # initialize gradients to be zero - self.optimizer.zero_grad() - # use different backward step depending on whether to use - # 2nd order approximation for gradient update - if unrolled: # probably using eta of parameter update here - self._backward_step_unrolled( - input_train, - target_train, - input_valid, - target_valid, - eta, - network_optimizer, - ) - else: - self._backward_step(input_valid, target_valid) - # move Adam one step - self.optimizer.step() - - # backward step (using non-approximate architecture gradient, i.e., full training) - def _backward_step(self, input_valid: torch.Tensor, target_valid: torch.Tensor): - """ - Computes the loss and updates the architecture weights assuming full optimization - of coefficients for the current architecture. - - Arguments: - input_valid: input patterns for validation set - target_valid: target patterns for validation set - """ - if self.model.DARTS_type == DARTSType.ORIGINAL: - loss = self.model._loss(input_valid, target_valid) - elif self.model.DARTS_type == DARTSType.FAIR: - loss1 = self.model._loss(input_valid, target_valid) - loss2 = -F.mse_loss( - torch.sigmoid(self.model.alphas_normal), - 0.5 * torch.ones(self.model.alphas_normal.shape, requires_grad=False), - ) # torch.tensor(0.5, requires_grad=False) - loss = loss1 + self.fair_darts_loss_weight * loss2 - else: - raise Exception( - "DARTS Type " + str(self.model.DARTS_type) + " not implemented" - ) - - loss.backward() - self.current_loss = loss.item() - - # weight decay proportional to degrees of freedom - for p in self.model.arch_parameters(): - p.data.sub_((self.decay_weights * self.lr)) # weight decay - - # backward pass using second order approximation - def _backward_step_unrolled( - self, - input_train: torch.Tensor, - target_train: torch.Tensor, - input_valid: torch.Tensor, - target_valid: torch.Tensor, - eta: float, - network_optimizer: torch.optim.Optimizer, - ): - """ - Computes the loss and updates the architecture weights using the approximate architecture - gradient. - - Arguments: - input_train: input patterns for training set - target_train: target patterns for training set - input_valid: input patterns for validation set - target_valid: target patterns for validation set - eta: learning rate - network_optimizer: optimizer used to updating the architecture weights - - """ - - # gets the model - unrolled_model = self._compute_unrolled_model( - input_train, target_train, eta, network_optimizer - ) - - if self.model.DARTS_type == DARTSType.ORIGINAL: - unrolled_loss = unrolled_model._loss(input_valid, target_valid) - elif self.model.DARTS_type == DARTSType.FAIR: - loss1 = self.model._loss(input_valid, target_valid) - loss2 = -F.mse_loss( - torch.sigmoid(self.model.alphas_normal), - torch.tensor(0.5, requires_grad=False), - ) - unrolled_loss = loss1 + self.fair_darts_loss_weight * loss2 - else: - raise Exception( - "DARTS Type " + str(self.model.DARTS_type) + " not implemented" - ) - - unrolled_loss.backward() - dalpha = [v.grad for v in unrolled_model.arch_parameters()] - vector = [v.grad.data for v in unrolled_model.parameters()] - implicit_grads = self._hessian_vector_product(vector, input_train, target_train) - - for g, ig in zip(dalpha, implicit_grads): - g.data.sub_(eta, ig.data) - - for v, g in zip(self.model.arch_parameters(), dalpha): - if v.grad is None: - v.grad = Variable(g.data) - else: - v.grad.data.copy_(g.data) - - def _construct_model_from_theta(self, theta: torch.Tensor): - """ - Helper function used to compute the approximate gradient update - for the architecture weights. - - Arguments: - theta: term used to compute approximate gradient update - - """ - model_new = self.model.new() - model_dict = self.model.state_dict() - - params, offset = {}, 0 - for k, v in self.model.named_parameters(): - v_length = np.prod(v.size()) - params[k] = theta[offset : (offset + v_length)].view(v.size()) - offset += v_length - - assert offset == len(theta) - model_dict.update(params) - model_new.load_state_dict(model_dict) - return model_new # .cuda() # Edit SM 10/26/19: uncommented for cuda - - # second order approximation of architecture gradient (see Eqn. 8 from Liu et al, 2019) - def _hessian_vector_product( - self, vector: torch.Tensor, input: torch.Tensor, target: torch.Tensor, r=1e-2 - ): - """ - Helper function used to compute the approximate gradient update - for the architecture weights. It computes the hessian vector product outlined in Eqn. 8 - from Liu et al, 2019. - - Arguments: - vector: input vector - input: input patterns - target: target patterns - r: coefficient used to compute the hessian vector product - - """ - R = r / _concat(vector).norm() - for p, v in zip(self.model.parameters(), vector): - p.data.add_(R, v) - loss = self.model._loss(input, target) - grads_p = torch.autograd.grad(loss, self.model.arch_parameters()) - - for p, v in zip(self.model.parameters(), vector): - p.data.sub_(2 * R, v) - loss = self.model._loss(input, target) - grads_n = torch.autograd.grad(loss, self.model.arch_parameters()) - - for p, v in zip(self.model.parameters(), vector): - p.data.add_(R, v) - - # this implements Eqn. 8 from Liu et al. (2019) - return [(x - y).div_(2 * R) for x, y in zip(grads_p, grads_n)] diff --git a/autora/theorist/darts/dataset.py b/autora/theorist/darts/dataset.py deleted file mode 100644 index d9ae8690d..000000000 --- a/autora/theorist/darts/dataset.py +++ /dev/null @@ -1,72 +0,0 @@ -from typing import Optional, Tuple - -import numpy as np -import torch -from torch.utils.data import Dataset - - -class DARTSDataset(Dataset): - """ - A dataset for the DARTS algorithm. - """ - - def __init__(self, input_data: torch.tensor, output_data: torch.tensor): - """ - Initializes the dataset. - - Arguments: - input_data: The input data to the dataset. - output_data: The output data to the dataset. - """ - assert input_data.shape[0] == output_data.shape[0] - self.input_data = input_data - self.output_data = output_data - - def __len__(self, experiment_id: Optional[int] = None) -> int: - """ - Returns the length of the dataset. - - Arguments: - experiment_id: - - Returns: - The length of the dataset. - """ - return self.input_data.shape[0] - - def __getitem__(self, idx: int) -> Tuple[torch.tensor, torch.tensor]: - """ - Returns the item at the given index. - - Arguments: - idx: The index of the item to return. - - Returns: - The item at the given index. - - """ - input_tensor = self.input_data[idx] - output_tensor = self.output_data[idx] - return input_tensor, output_tensor - - -def darts_dataset_from_ndarray( - input_data: np.ndarray, output_data: np.ndarray -) -> DARTSDataset: - """ - A function to create a dataset from numpy arrays. - - Arguments: - input_data: The input data to the dataset. - output_data: The output data to the dataset. - - Returns: - The dataset. - - """ - - obj = DARTSDataset( - torch.tensor(input_data, dtype=torch.get_default_dtype()), - torch.tensor(output_data, dtype=torch.get_default_dtype()), - ) - return obj diff --git a/autora/theorist/darts/fan_out.py b/autora/theorist/darts/fan_out.py deleted file mode 100644 index 54fbcc404..000000000 --- a/autora/theorist/darts/fan_out.py +++ /dev/null @@ -1,42 +0,0 @@ -import torch -import torch.nn as nn - - -class Fan_Out(nn.Module): - """ - A neural network class that splits a given input vector into separate nodes. Each element of - the original input vector is allocated a separate node in a computation graph. - """ - - def __init__(self, num_inputs: int): - """ - Initialize the Fan Out operation. - - Arguments: - num_inputs (int): The number of distinct input nodes to generate - """ - super(Fan_Out, self).__init__() - - self._num_inputs = num_inputs - - self.input_output = list() - for i in range(num_inputs): - linearConnection = nn.Linear(num_inputs, 1, bias=False) - linearConnection.weight.data = torch.zeros(1, num_inputs) - linearConnection.weight.data[0, i] = 1 - linearConnection.weight.requires_grad = False - self.input_output.append(linearConnection) - - def forward(self, input: torch.Tensor) -> torch.Tensor: - """ - Forward pass of the Fan Out operation. - - Arguments: - input: input vector whose elements are split into separate input nodes - """ - - output = list() - for i in range(self._num_inputs): - output.append(self.input_output[i](input)) - - return output diff --git a/autora/theorist/darts/model_search.py b/autora/theorist/darts/model_search.py deleted file mode 100755 index 738c39dc2..000000000 --- a/autora/theorist/darts/model_search.py +++ /dev/null @@ -1,796 +0,0 @@ -import random -import warnings -from enum import Enum -from typing import Callable, List, Literal, Optional, Sequence, Tuple - -import numpy as np -import torch -import torch.nn as nn -import torch.nn.functional as F -from torch.autograd import Variable - -from autora.theorist.darts.fan_out import Fan_Out -from autora.theorist.darts.operations import ( - PRIMITIVES, - Genotype, - get_operation_label, - isiterable, - operation_factory, -) - - -class DARTSType(str, Enum): - """ - Enumerator that indexes different variants of DARTS. - """ - - # Liu, Simonyan & Yang (2018). Darts: Differentiable architecture search - ORIGINAL = "original" - - # Chu, Zhou, Zhang & Li (2020). Fair darts: Eliminating unfair advantages - # in differentiable architecture search - FAIR = "fair" - - -# for 2 input nodes, 1 output node and 4 intermediate nodes, -# there are 14 possible edges (x 8 operations) -# Let input nodes be 1, 2 intermediate nodes 3, 4, 5, 6, and output node 7 -# The edges are 3-1, 3-2; 4-1, 4-2, 4-3; 5-1, 5-2, 5-3, 5-4; 6-1, 6-2, -# 6-3, 6-4, 6-5; 2 + 3 + 4 + 5 = 14 edges - - -class MixedOp(nn.Module): - """ - Mixture operation as applied in Differentiable Architecture Search (DARTS). - A mixture operation amounts to a weighted mixture of a pre-defined set of operations - that is applied to an input variable. - """ - - def __init__(self, primitives: Sequence[str] = PRIMITIVES): - """ - Initializes a mixture operation based on a pre-specified set of primitive operations. - - Arguments: - primitives: list of primitives to be used in the mixture operation - """ - super(MixedOp, self).__init__() - self._ops = nn.ModuleList() - # loop through all the 8 primitive operations - for primitive in primitives: - # OPS returns an nn module for a given primitive (defines as a string) - op = operation_factory(primitive) - - # add the operation - self._ops.append(op) - - def forward(self, x: torch.Tensor, weights: torch.Tensor) -> float: - """ - Computes a mixture operation as a weighted sum of all primitive operations. - - Arguments: - x: input to the mixture operations - weights: weight vector containing the weights associated with each operation - - Returns: - y: result of the weighted mixture operation - """ - # there are 8 weights for all the eight primitives. then it returns the - # weighted sum of all operations performed on a given input - return sum(w * op(x) for w, op in zip(weights, self._ops)) - - -# Let a cell be a DAG(directed acyclic graph) containing N nodes (2 input -# nodes 1 output node?) -class Cell(nn.Module): - """ - A cell as defined in differentiable architecture search. A single cell corresponds - to a computation graph with the number of input nodes defined by n_input_states and - the number of hidden nodes defined by steps. Input nodes only project to hidden nodes and hidden - nodes project to each other with an acyclic connectivity pattern. The output of a cell - corresponds to the concatenation of all hidden nodes. Hidden nodes are computed by integrating - transformed outputs from sending nodes. Outputs from sending nodes correspond to - mixture operations, i.e. a weighted combination of pre-specified operations applied to the - variable specified by the sending node (see MixedOp). - - Attributes: - _steps: number of hidden nodes - _n_input_states: number of input nodes - _ops: list of mixture operations (amounts to the list of edges in the cell) - """ - - def __init__( - self, - steps: int = 2, - n_input_states: int = 1, - primitives: Sequence[str] = PRIMITIVES, - ): - """ - Initializes a cell based on the number of hidden nodes (steps) - and the number of input nodes (n_input_states). - - Arguments: - steps: number of hidden nodes - n_input_states: number of input nodes - """ - # The first and second nodes of cell k are set equal to the outputs of - # cell k − 2 and cell k − 1, respectively, and 1 × 1 convolutions - # (ReLUConvBN) are inserted as necessary - super(Cell, self).__init__() - - # set parameters - self._steps = steps # hidden nodes - self._n_input_states = n_input_states # input nodes - - # EDIT 11/04/19 SM: adapting to new SimpleNet data (changed from - # multiplier to steps) - self._multiplier = steps - - # set operations according to number of modules (empty) - self._ops = nn.ModuleList() - # iterate over edges: edges between each hidden node and input nodes + - # prev hidden nodes - for i in range(self._steps): # hidden nodes - for j in range(self._n_input_states + i): # 2 refers to the 2 input nodes - # defines the stride for link between cells - # adds a mixed operation (derived from architecture parameters alpha) - # for 4 intermediate nodes, a total of 14 connections - # (MixedOps) is added - op = MixedOp(primitives) - # appends cell with mixed operation - self._ops.append(op) - - def forward(self, input_states: List, weights: torch.Tensor): - """ - Computes the output of a cell given a list of input states - (variables represented in input nodes) and a weight matrix specifying the weights of each - operation for each edge. - - Arguments: - input_states: list of input nodes - weights: matrix specifying architecture weights, i.e. the weights associated - with each operation for each edge - """ - # initialize states (activities of each node in the cell) - states = list() - - # add each input node to the number of states - for input in input_states: - states.append(input) - - offset = 0 - # this computes the states from intermediate nodes and adds them to the list of states - # (values of nodes) - # for each hidden node, compute edge between existing states (input - # nodes / previous hidden) nodes and current node - for i in range( - self._steps - ): # compute the state for each hidden node, first hidden node is - # sum of input nodes, second is sum of input and first hidden - s = sum( - self._ops[offset + j](h, weights[offset + j]) - for j, h in enumerate(states) - ) - offset += len(states) - states.append(s) - - # concatenates the states of the last n (self._multiplier) intermediate - # nodes to get the output of a cell - result = torch.cat(states[-self._multiplier :], dim=1) - return result - - -class Network(nn.Module): - """ - A PyTorch computation graph according to DARTS. - It consists of a single computation cell which transforms an - input vector (containing all input variable) into an output vector, by applying a set of - mixture operations which are defined by the architecture weights (labeled "alphas" of the - network). - - The network flow looks as follows: An input vector (with _n_input_states elements) is split into - _n_input_states separate input nodes (one node per element). The input nodes are then passed - through a computation cell with _steps hidden nodes (see Cell). The output of the computation - cell corresponds to the concatenation of its hidden nodes (a single vector). The final output - corresponds to a (trained) affine transformation of this concatenation (labeled "classifier"). - - Attributes: - _n_input_states: length of input vector (translates to number of input nodes) - _num_classes: length of output vector - _criterion: optimization criterion used to define the loss - _steps: number of hidden nodes in the cell - _architecture_fixed: specifies whether the architecture weights shall remain fixed - (not trained) - _classifier_weight_decay: a weight decay applied to the classifier - - """ - - def __init__( - self, - num_classes: int, - criterion: Callable, - steps: int = 2, - n_input_states: int = 2, - architecture_fixed: bool = False, - train_classifier_coefficients: bool = False, - train_classifier_bias: bool = False, - classifier_weight_decay: float = 0, - darts_type: DARTSType = DARTSType.ORIGINAL, - primitives: Sequence[str] = PRIMITIVES, - ): - """ - Initializes the network. - - Arguments: - num_classes: length of output vector - criterion: optimization criterion used to define the loss - steps: number of hidden nodes in the cell - n_input_states: length of input vector (translates to number of input nodes) - architecture_fixed: specifies whether the architecture weights shall remain fixed - train_classifier_coefficients: specifies whether the classifier coefficients shall be - trained - train_classifier_bias: specifies whether the classifier bias shall be trained - classifier_weight_decay: a weight decay applied to the classifier - darts_type: variant of DARTS (regular or fair) that is applied for training - """ - super(Network, self).__init__() - - # set parameters - self._num_classes = num_classes # number of output classes - self._criterion = criterion # optimization criterion (e.g., softmax) - self._steps = steps # the number of intermediate nodes (e.g., 2) - self._n_input_states = n_input_states # number of input nodes - self.DARTS_type = darts_type # darts variant - self._multiplier = ( - 1 # the number of internal nodes that get concatenated to the output - ) - self.primitives = primitives - - # set parameters - self._dim_output = self._steps - self._architecture_fixed = architecture_fixed - self._classifier_weight_decay = classifier_weight_decay - - # input nodes - self.stem = nn.Sequential(Fan_Out(self._n_input_states)) - - self.cells = ( - nn.ModuleList() - ) # get list of all current modules (should be empty) - - # generate a cell that undergoes architecture search - self.cells = Cell(steps, self._n_input_states, self.primitives) - - # last layer is a linear classifier (e.g. with 10 CIFAR classes) - self.classifier = nn.Linear( - self._dim_output, num_classes - ) # make this the number of input states - - # initialize classifier weights - if train_classifier_coefficients is False: - self.classifier.weight.data.fill_(1) - self.classifier.weight.requires_grad = False - - if train_classifier_bias is False: - self.classifier.bias.data.fill_(0) - self.classifier.bias.requires_grad = False - - # initializes weights of the architecture - self._initialize_alphas() - - # function for copying the network - def new(self) -> nn.Module: - """ - Returns a copy of the network. - - Returns: - a copy of the network - - """ - - model_new = Network( - # self._C, self._num_classes, self._criterion, steps=self._steps - num_classes=self._num_classes, - criterion=self._criterion, - steps=self._steps, - n_input_states=self._n_input_states, - architecture_fixed=self._architecture_fixed, - classifier_weight_decay=self._classifier_weight_decay, - darts_type=self.DARTS_type, - primitives=self.primitives, - ) - - for x, y in zip(model_new.arch_parameters(), self.arch_parameters()): - x.data.copy_(y.data) - return model_new - - # computes forward pass for full network - def forward(self, x: torch.Tensor): - """ - Computes output of the network. - - Arguments: - x: input to the network - """ - - # compute stem first - input_states = self.stem(x) - - # get architecture weights - if self._architecture_fixed: - weights = self.alphas_normal - else: - if self.DARTS_type == DARTSType.ORIGINAL: - weights = F.softmax(self.alphas_normal, dim=-1) - elif self.DARTS_type == DARTSType.FAIR: - weights = torch.sigmoid(self.alphas_normal) - else: - raise Exception( - "DARTS Type " + str(self.DARTS_type) + " not implemented" - ) - - # then apply cell with weights - cell_output = self.cells(input_states, weights) - - # compute logits - logits = self.classifier(cell_output.view(cell_output.size(0), -1)) - # just gets output to have only 2 dimensions (batch_size x num units in - # output layer) - - return logits - - def _loss(self, input: torch.Tensor, target: torch.Tensor) -> torch.Tensor: - """ - Computes the loss of the network for the specified criterion. - - Arguments: - input: input patterns - target: target patterns - - Returns: - loss - """ - logits = self(input) - return self._criterion(logits, target) # returns cross entropy by default - - # regularization - def apply_weight_decay_to_classifier(self, lr: float): - """ - Applies a weight decay to the weights projecting from the cell to the final output layer. - - Arguments: - lr: learning rate - """ - # weight decay proportional to degrees of freedom - for p in self.classifier.parameters(): - if p.requires_grad is False: - continue - p.data.sub_( - self._classifier_weight_decay - * lr - * torch.sign(p.data) - * (torch.abs(p.data)) - ) # weight decay - - def _initialize_alphas(self): - """ - Initializes the architecture weights. - """ - # compute the number of possible connections between nodes - k = sum(1 for i in range(self._steps) for n in range(self._n_input_states + i)) - # number of available primitive operations (8 different types for a - # conv net) - num_ops = len(self.primitives) - - # e.g., generate 14 (number of available edges) by 8 (operations) - # weight matrix for normal alphas of the architecture - self.alphas_normal = Variable( - 1e-3 * torch.randn(k, num_ops), requires_grad=True - ) - # those are all the parameters of the architecture - self._arch_parameters = [self.alphas_normal] - - # provide back the architecture as a parameter - def arch_parameters(self) -> List: - """ - Returns architecture weights. - - Returns: - _arch_parameters: architecture weights. - """ - return self._arch_parameters - - # fixes architecture - def fix_architecture( - self, switch: bool, new_weights: Optional[torch.Tensor] = None - ): - """ - Freezes or unfreezes the architecture weights. - - Arguments: - switch: set true to freeze architecture weights or false unfreeze - new_weights: new set of architecture weights - """ - self._architecture_fixed = switch - if new_weights is not None: - self.alphas_normal = new_weights - return - - def sample_alphas_normal( - self, sample_amp: float = 1, fair_darts_weight_threshold: float = 0 - ) -> torch.Tensor: - """ - Samples an architecture from the mixed operations from a probability distribution that is - defined by the (softmaxed) architecture weights. - This amounts to selecting one operation per edge (i.e., setting the architecture - weight of that operation to one while setting the others to zero). - - Arguments: - sample_amp: temperature that is applied before passing the weights through a softmax - fair_darts_weight_threshold: used in fair DARTS. If an architecture weight is below - this value then it is set to zero. - - Returns: - alphas_normal_sample: sampled architecture weights. - """ - - alphas_normal = self.alphas_normal.clone() - alphas_normal_sample = Variable(torch.zeros(alphas_normal.data.shape)) - - for edge in range(alphas_normal.data.shape[0]): - if self.DARTS_type == DARTSType.ORIGINAL: - W_soft = F.softmax(alphas_normal[edge] * sample_amp, dim=0) - elif self.DARTS_type == DARTSType.FAIR: - transformed_alphas_normal = alphas_normal[edge] - above_threshold = False - for idx in range(len(transformed_alphas_normal.data)): - if ( - torch.sigmoid(transformed_alphas_normal).data[idx] - > fair_darts_weight_threshold - ): - above_threshold = True - break - if above_threshold: - W_soft = F.softmax(transformed_alphas_normal * sample_amp, dim=0) - else: - W_soft = Variable(torch.zeros(alphas_normal[edge].shape)) - W_soft[self.primitives.index("none")] = 1 - - else: - raise Exception( - "DARTS Type " + str(self.DARTS_type) + " not implemented" - ) - - if torch.any(W_soft != W_soft): - warnings.warn( - "Cannot properly sample from architecture weights due to nan entries." - ) - k_sample = random.randrange(len(W_soft)) - else: - k_sample = np.random.choice(range(len(W_soft)), p=W_soft.data.numpy()) - alphas_normal_sample[edge, k_sample] = 1 - - return alphas_normal_sample - - def max_alphas_normal(self) -> torch.Tensor: - """ - Samples an architecture from the mixed operations by selecting, for each edge, - the operation with the largest architecture weight. - - Returns: - alphas_normal_sample: sampled architecture weights. - """ - alphas_normal = self.alphas_normal.clone() - alphas_normal_sample = Variable(torch.zeros(alphas_normal.data.shape)) - - for edge in range(alphas_normal.data.shape[0]): - row = alphas_normal[edge] - max_idx = np.argmax(row.data) - alphas_normal_sample[edge, max_idx] = 1 - - return alphas_normal_sample - - # returns the genotype of the model - def genotype(self, sample: bool = False) -> Genotype: - """ - Computes a genotype of the model which specifies the current computation graph based on - the largest architecture weight for each edge, or based on a sample. - The genotype can be used for parsing or plotting the computation graph. - - Arguments: - sample: if set to true, the architecture will be determined by sampling - from a probability distribution that is determined by the - softmaxed architecture weights. If set to false (default), the architecture will be - determined based on the largest architecture weight per edge. - - Returns: - genotype: genotype describing the current (sampled) architecture - """ - # this function uses the architecture weights to retrieve the - # operations with the highest weights - def _parse(weights): - gene = [] - n = ( - self._n_input_states - ) # 2 ... changed this to adapt to number of input states - start = 0 - for i in range(self._steps): - end = start + n - W = weights[start:end].copy() - # first get all the edges for a given node, edges are sorted according to their - # highest (non-none) weight, starting from the edge with the smallest heighest - # weight - - if "none" in self.primitives: - none_index = self.primitives.index("none") - else: - none_index = -1 - - edges = sorted( - range(n), - key=lambda x: -max( - W[x][k] for k in range(len(W[x])) if k != none_index - ), - ) - # for each edge, figure out which is the primitive with the - # highest - for ( - j - ) in edges: # looping through all the edges for the current node (i) - if sample: - W_soft = F.softmax(Variable(torch.from_numpy(W[j]))) - k_best = np.random.choice( - range(len(W[j])), p=W_soft.data.numpy() - ) - else: - k_best = None - # looping through all the primitives - for k in range(len(W[j])): - # choose the primitive with the highest weight - # if k != self.primitives.index('none'): - # EDIT SM 01/13: commented to include "none" - # weights in genotype - if k_best is None or W[j][k] > W[j][k_best]: - k_best = k - # add gene (primitive, edge number) - gene.append((self.primitives[k_best], j)) - start = end - n += 1 - return gene - - if self._architecture_fixed: - gene_normal = _parse(self.alphas_normal.data.cpu().numpy()) - else: - gene_normal = _parse( - F.softmax(self.alphas_normal, dim=-1).data.cpu().numpy() - ) - - concat = range(2 + self._steps - self._multiplier, self._steps + 2) - genotype = Genotype( - normal=gene_normal, - normal_concat=concat, - ) - return genotype - - def count_parameters(self, print_parameters: bool = False) -> Tuple[int, int, list]: - """ - Counts and returns the parameters (coefficients) of the architecture defined by the - highest architecture weights. - - Arguments: - print_parameters: if set to true, the function will print all parameters. - - Returns: - n_params_total: total number of parameters - n_params_base: number of parameters determined by the classifier - param_list: list of parameters specifying the corresponding edge (operation) - and value - """ - - # counts only parameters of operations with the highest architecture weight - n_params_total = 0 - - # count classifier - for parameter in self.classifier.parameters(): - if parameter.requires_grad is True: - n_params_total += parameter.data.numel() - - # count stem - for parameter in self.stem.parameters(): - if parameter.requires_grad is True: - n_params_total += parameter.data.numel() - - n_params_base = ( - n_params_total # number of parameters, excluding individual cells - ) - - param_list = list() - # now count number of parameters for cells that have highest - # probability - for idx, op in enumerate(self.cells._ops): - # pick most operation with highest likelihood - values = self.alphas_normal[idx, :].data.numpy() - maxIdx = np.where(values == max(values)) - - tmp_param_list = list() - if isiterable(op._ops[maxIdx[0].item(0)]): # Zero is not iterable - - for subop in op._ops[maxIdx[0].item(0)]: - - for parameter in subop.parameters(): - tmp_param_list.append(parameter.data.numpy().squeeze()) - if parameter.requires_grad is True: - n_params_total += parameter.data.numel() - - if print_parameters: - print( - "Edge (" - + str(idx) - + "): " - + get_operation_label( - self.primitives[maxIdx[0].item(0)], tmp_param_list - ) - ) - param_list.append(tmp_param_list) - - # # get parameters from final linear classifier - # tmp_param_list = list() - # for parameter in self.classifier.parameters(): - # for subparameter in parameter: - # tmp_param_list.append(subparameter.data.numpy().squeeze()) - - # get parameters from final linear for each edge - for edge in range(self._steps): - tmp_param_list = list() - # add weight - tmp_param_list.append( - self.classifier._parameters["weight"].data[:, edge].numpy() - ) - # add partial bias (bias of classifier units will be divided by - # number of edges) - if "bias" in self.classifier._parameters.keys() and edge == 0: - tmp_param_list.append(self.classifier._parameters["bias"].data.numpy()) - param_list.append(tmp_param_list) - - if print_parameters: - print( - "Classifier from Node " - + str(edge) - + ": " - + get_operation_label("classifier_concat", tmp_param_list) - ) - - return (n_params_total, n_params_base, param_list) - - def architecture_to_str_list( - self, - input_labels: Sequence[str], - output_labels: Sequence[str], - output_function_label: str = "", - decimals_to_display: int = 2, - output_format: Literal["latex", "console"] = "console", - ) -> List: - """ - Returns a list of strings representing the model. - - Arguments: - input_labels: list of strings representing the input states. - output_labels: list of strings representing the output states. - output_function_label: string representing the output function. - decimals_to_display: number of decimals to display. - output_format: if set to `"console"`, returns equations formatted for the command line, - if set to `"latex"`, returns equations in latex format - - - Returns: - list of strings representing the model - """ - (n_params_total, n_params_base, param_list) = self.count_parameters( - print_parameters=False - ) - genotype = self.genotype().normal - steps = self._steps - edge_list = list() - - n = len(input_labels) - start = 0 - for i in range(steps): # for every node - end = start + n - # for k in [2*i, 2*i + 1]: - - edge_operations_list = list() - op_list = list() - - for k in range(start, end): - if ( - output_format == "latex" - ): # for every edge projecting to current node - v = "k_" + str(i + 1) - else: - v = "k" + str(i + 1) - op, j = genotype[k] - if j < len(input_labels): - u = input_labels[j] - else: - if output_format == "latex": - u = "k_" + str(j - len(input_labels) + 1) - else: - u = "k" + str(j - len(input_labels) + 1) - if op != "none": - op_label = op - params = param_list[ - start + j - ] # note: genotype order and param list order don't align - op_label = get_operation_label( - op, - params, - decimals=decimals_to_display, - input_var=u, - output_format=output_format, - ) - op_list.append(op) - edge_operations_list.append(op_label) - - if len(edge_operations_list) == 0: - edge_str = v + " = 0" - else: - edge_str = "" - for i, edge_operation in enumerate(edge_operations_list): - if i == 0: - edge_str += v + " = " + edge_operation - if i > 0: - if ( - op_list[i] != "add" - and op_list[i] != "subtract" - and op_list[i] != "none" - ): - edge_str += " +" - edge_str += " " + edge_operation - - edge_list.append(edge_str) - start = end - n += 1 - - # TODO: extend to multiple outputs - if output_format == "latex": - classifier_str = output_labels[0] + " = " + output_function_label - if output_function_label != "": - classifier_str += "\\left(" - else: - classifier_str = output_labels[0] + " = " + output_function_label - if output_function_label != "": - classifier_str += "(" - - bias = None - for i in range(steps): - param_idx = len(param_list) - steps + i - tmp_param_list = param_list[param_idx] - if i == 0 and len(tmp_param_list) == 2: - bias = tmp_param_list[1] - if i > 0: - classifier_str += " + " - - if output_format == "latex": - input_var = "k_" + str(i + 1) - else: - input_var = "k" + str(i + 1) - - classifier_str += get_operation_label( - "classifier", - tmp_param_list[0], - decimals=decimals_to_display, - input_var=input_var, - ) - - if i == steps - 1 and bias is not None: - classifier_str += " + " + str(bias[0]) - - if i == steps - 1: - if output_function_label != "": - if output_format == "latex": - classifier_str += "\\right)" - else: - classifier_str += ")" - - edge_list.append(classifier_str) - - return edge_list diff --git a/autora/theorist/darts/operations.py b/autora/theorist/darts/operations.py deleted file mode 100755 index 05603b04b..000000000 --- a/autora/theorist/darts/operations.py +++ /dev/null @@ -1,665 +0,0 @@ -import typing -from collections import namedtuple - -import torch -import torch.nn as nn - -Genotype = namedtuple("Genotype", "normal normal_concat") - - -def isiterable(p_object: typing.Any) -> bool: - """ - Checks if an object is iterable. - - Arguments: - p_object: object to be checked - """ - try: - iter(p_object) - except TypeError: - return False - return True - - -def get_operation_label( - op_name: str, - params_org: typing.List, - decimals: int = 4, - input_var: str = "x", - output_format: typing.Literal["latex", "console"] = "console", -) -> str: - r""" - Returns a complete string describing a DARTS operation. - - Arguments: - op_name: name of the operation - params_org: original parameters of the operation - decimals: number of decimals to be used for converting the parameters into string format - input_var: name of the input variable - output_format: format of the output string (either "latex" or "console") - - Examples: - >>> get_operation_label("classifier", [1], decimals=2) - '1.00 * x' - >>> import numpy as np - >>> print(get_operation_label("classifier_concat", np.array([1, 2, 3]), - ... decimals=2, output_format="latex")) - x \circ \left(1.00\right) + \left(2.00\right) + \left(3.00\right) - >>> get_operation_label("classifier_concat", np.array([1, 2, 3]), - ... decimals=2, output_format="console") - 'x .* (1.00) .+ (2.00) .+ (3.00)' - >>> get_operation_label("linear_exp", [1,2], decimals=2) - 'exp(1.00 * x + 2.00)' - >>> get_operation_label("none", []) - '' - >>> get_operation_label("reciprocal", [1], decimals=0) - '1 / x' - >>> get_operation_label("linear_reciprocal", [1, 2], decimals=0) - '1 / (1 * x + 2)' - >>> get_operation_label("linear_relu", [1], decimals=0) - 'ReLU(1 * x)' - >>> print(get_operation_label("linear_relu", [1], decimals=0, output_format="latex")) - \operatorname{ReLU}\left(1x\right) - >>> get_operation_label("linear", [1, 2], decimals=0) - '1 * x + 2' - >>> get_operation_label("linear", [1, 2], decimals=0, output_format="latex") - '1 x + 2' - >>> get_operation_label("linrelu", [1], decimals=0) # Mistyped operation name - Traceback (most recent call last): - ... - NotImplementedError: operation 'linrelu' is not defined for output_format 'console' - """ - if output_format != "latex" and output_format != "console": - raise ValueError("output_format must be either 'latex' or 'console'") - - params = params_org.copy() - - format_string = "{:." + "{:.0f}".format(decimals) + "f}" - - classifier_str = "" - if op_name == "classifier": - value = params[0] - classifier_str = f"{format_string.format(value)} * {input_var}" - return classifier_str - - if op_name == "classifier_concat": - if output_format == "latex": - classifier_str = input_var + " \\circ \\left(" - else: - classifier_str = input_var + " .* (" - for param_idx, param in enumerate(params): - - if param_idx > 0: - if output_format == "latex": - classifier_str += " + \\left(" - else: - classifier_str += " .+ (" - - if isiterable(param.tolist()): - - param_formatted = list() - for value in param.tolist(): - param_formatted.append(format_string.format(value)) - - for value_idx, value in enumerate(param_formatted): - if value_idx < len(param) - 1: - classifier_str += value + " + " - else: - if output_format == "latex": - classifier_str += value + "\\right)" - else: - classifier_str += value + ")" - - else: - value = format_string.format(param) - - if output_format == "latex": - classifier_str += value + "\\right)" - else: - classifier_str += value + ")" - - return classifier_str - - num_params = len(params) - - c = [str(format_string.format(p)) for p in params_org] - c.extend(["", "", ""]) - - if num_params == 1: # without bias - if output_format == "console": - labels = { - "none": "", - "add": f"+ {input_var}", - "subtract": f"- {input_var}", - "mult": f"{c[0]} * {input_var}", - "linear": f"{c[0]} * {input_var}", - "relu": f"ReLU({input_var})", - "linear_relu": f"ReLU({c[0]} * {input_var})", - "logistic": f"logistic({input_var})", - "linear_logistic": f"logistic({c[0]} * {input_var})", - "exp": f"exp({input_var})", - "linear_exp": f"exp({c[0]} * {input_var})", - "reciprocal": f"1 / {input_var}", - "linear_reciprocal": f"1 / ({c[0]} * {input_var})", - "ln": f"ln({input_var})", - "linear_ln": f"ln({c[0]} * {input_var})", - "cos": f"cos({input_var})", - "linear_cos": f"cos({c[0]} * {input_var})", - "sin": f"sin({input_var})", - "linear_sin": f"sin({c[0]} * {input_var})", - "tanh": f"tanh({input_var})", - "linear_tanh": f"tanh({c[0]} * {input_var})", - "classifier": classifier_str, - } - elif output_format == "latex": - labels = { - "none": "", - "add": f"+ {input_var}", - "subtract": f"- {input_var}", - "mult": f"{c[0]} {input_var}", - "linear": c[0] + "" + input_var, - "relu": f"\\operatorname{{ReLU}}\\left({input_var}\\right)", - "linear_relu": f"\\operatorname{{ReLU}}\\left({c[0]}{input_var}\\right)", - "logistic": f"\\sigma\\left({input_var}\\right)", - "linear_logistic": f"\\sigma\\left({c[0]} {input_var} \\right)", - "exp": f"+ e^{input_var}", - "linear_exp": f"e^{{{c[0]} {input_var} }}", - "reciprocal": f"\\frac{{1}}{{{input_var}}}", - "linear_reciprocal": f"\\frac{{1}}{{{c[0]} {input_var} }}", - "ln": f"\\ln\\left({input_var}\\right)", - "linear_ln": f"\\ln\\left({c[0]} {input_var} \\right)", - "cos": f"\\cos\\left({input_var}\\right)", - "linear_cos": f"\\cos\\left({c[0]} {input_var} \\right)", - "sin": f"\\sin\\left({input_var}\\right)", - "linear_sin": f"\\sin\\left({c[0]} {input_var} \\right)", - "tanh": f"\\tanh\\left({input_var}\\right)", - "linear_tanh": f"\\tanh\\left({c[0]} {input_var} \\right)", - "classifier": classifier_str, - } - else: # with bias - if output_format == "console": - labels = { - "none": "", - "add": f"+ {input_var}", - "subtract": f"- {input_var}", - "mult": f"{c[0]} * {input_var}", - "linear": f"{c[0]} * {input_var} + {c[1]}", - "relu": f"ReLU({input_var})", - "linear_relu": f"ReLU({c[0]} * {input_var} + {c[1]} )", - "logistic": f"logistic({input_var})", - "linear_logistic": f"logistic({c[0]} * {input_var} + {c[1]})", - "exp": f"exp({input_var})", - "linear_exp": f"exp({c[0]} * {input_var} + {c[1]})", - "reciprocal": f"1 / {input_var}", - "linear_reciprocal": f"1 / ({c[0]} * {input_var} + {c[1]})", - "ln": f"ln({input_var})", - "linear_ln": f"ln({c[0]} * {input_var} + {c[1]})", - "cos": f"cos({input_var})", - "linear_cos": f"cos({c[0]} * {input_var} + {c[1]})", - "sin": f"sin({input_var})", - "linear_sin": f"sin({c[0]} * {input_var} + {c[1]})", - "tanh": f"tanh({input_var})", - "linear_tanh": f"tanh({c[0]} * {input_var} + {c[1]})", - "classifier": classifier_str, - } - elif output_format == "latex": - labels = { - "none": "", - "add": f"+ {input_var}", - "subtract": f"- {input_var}", - "mult": f"{c[0]} * {input_var}", - "linear": f"{c[0]} {input_var} + {c[1]}", - "relu": f"\\operatorname{{ReLU}}\\left( {input_var}\\right)", - "linear_relu": f"\\operatorname{{ReLU}}\\left({c[0]}{input_var} + {c[1]} \\right)", - "logistic": f"\\sigma\\left( {input_var} \\right)", - "linear_logistic": f"\\sigma\\left( {c[0]} {input_var} + {c[1]} \\right)", - "exp": f"e^{input_var}", - "linear_exp": f"e^{{ {c[0]} {input_var} + {c[1]} }}", - "reciprocal": f"\\frac{{1}}{{{input_var}}}", - "linear_reciprocal": f"\\frac{{1}} {{ {c[0]}{input_var} + {c[1]} }}", - "ln": f"\\ln\\left({input_var}\\right)", - "linear_ln": f"\\ln\\left({c[0]} {input_var} + {c[1]} \\right)", - "cos": f"\\cos\\left({input_var}\\right)", - "linear_cos": f"\\cos\\left({c[0]} {input_var} + {c[1]} \\right)", - "sin": f"\\sin\\left({input_var}\\right)", - "linear_sin": f"\\sin\\left({c[0]} {input_var} + {c[1]} \\right)", - "tanh": f"\\tanh\\left({input_var}\\right)", - "linear_tanh": f"\\tanh\\left({c[0]} {input_var} + {c[1]} \\right)", - "classifier": classifier_str, - } - - if op_name not in labels: - raise NotImplementedError( - f"operation '{op_name}' is not defined for output_format '{output_format}'" - ) - - return labels[op_name] - - -class Identity(nn.Module): - """ - A pytorch module implementing the identity function. - - $$ - x = x - $$ - """ - - def __init__(self): - """ - Initializes the identify function. - """ - super(Identity, self).__init__() - - def forward(self, x: torch.Tensor) -> torch.Tensor: - """ - Forward pass of the identity function. - - Arguments: - x: input tensor - """ - return x - - -class NegIdentity(nn.Module): - """ - A pytorch module implementing the inverse of an identity function. - - $$ - x = -x - $$ - """ - - def __init__(self): - """ - Initializes the inverse of an identity function. - """ - super(NegIdentity, self).__init__() - - def forward(self, x: torch.Tensor) -> torch.Tensor: - """ - Forward pass of the inverse of an identity function. - - Arguments: - x: input tensor - """ - return -x - - -class Exponential(nn.Module): - """ - A pytorch module implementing the exponential function. - - $$ - x = e^x - $$ - """ - - def __init__(self): - """ - Initializes the exponential function. - """ - super(Exponential, self).__init__() - - def forward(self, x: torch.Tensor) -> torch.Tensor: - """ - Forward pass of the exponential function. - - Arguments: - x: input tensor - """ - return torch.exp(x) - - -class Cosine(nn.Module): - r""" - A pytorch module implementing the cosine function. - - $$ - x = \cos(x) - $$ - """ - - def __init__(self): - """ - Initializes the cosine function. - """ - super(Cosine, self).__init__() - - def forward(self, x: torch.Tensor) -> torch.Tensor: - """ - Forward pass of the cosine function. - - Arguments: - x: input tensor - """ - return torch.cos(x) - - -class Sine(nn.Module): - r""" - A pytorch module implementing the sine function. - - $$ - x = \sin(x) - $$ - """ - - def __init__(self): - """ - Initializes the sine function. - """ - super(Sine, self).__init__() - - def forward(self, x: torch.Tensor) -> torch.Tensor: - """ - Forward pass of the sine function. - - Arguments: - x: input tensor - """ - return torch.sin(x) - - -class Tangens_Hyperbolicus(nn.Module): - r""" - A pytorch module implementing the tangens hyperbolicus function. - - $$ - x = \tanh(x) - $$ - """ - - def __init__(self): - """ - Initializes the tangens hyperbolicus function. - """ - super(Tangens_Hyperbolicus, self).__init__() - - def forward(self, x: torch.Tensor) -> torch.Tensor: - """ - Forward pass of the tangens hyperbolicus function. - - Arguments: - x: input tensor - """ - return torch.tanh(x) - - -class NatLogarithm(nn.Module): - r""" - A pytorch module implementing the natural logarithm function. - - $$ - x = \ln(x) - $$ - - """ - - def __init__(self): - """ - Initializes the natural logarithm function. - """ - super(NatLogarithm, self).__init__() - - def forward(self, x: torch.Tensor) -> torch.Tensor: - """ - Forward pass of the natural logarithm function. - - Arguments: - x: input tensor - """ - # make sure x is in domain of natural logarithm - mask = x.clone() - mask[(x <= 0.0).detach()] = 0 - mask[(x > 0.0).detach()] = 1 - - epsilon = 1e-10 - result = torch.log(nn.functional.relu(x) + epsilon) * mask - - return result - - -class MultInverse(nn.Module): - r""" - A pytorch module implementing the multiplicative inverse. - - $$ - x = \frac{1}{x} - $$ - """ - - def __init__(self): - """ - Initializes the multiplicative inverse. - """ - super(MultInverse, self).__init__() - - def forward(self, x: torch.Tensor) -> torch.Tensor: - """ - Forward pass of the multiplicative inverse. - - Arguments: - x: input tensor - """ - return torch.pow(x, -1) - - -class Zero(nn.Module): - """ - A pytorch module implementing the zero operation (i.e., a null operation). A zero operation - presumes that there is no relationship between the input and output. - - $$ - x = 0 - $$ - """ - - def __init__(self, stride): - """ - Initializes the zero operation. - """ - super(Zero, self).__init__() - self.stride = stride - - def forward(self, x: torch.Tensor) -> torch.Tensor: - """ - Forward pass of the zero operation. - - Arguments: - x: input tensor - """ - if self.stride == 1: - return x.mul(0.0) - return x[:, :, :: self.stride, :: self.stride].mul(0.0) - - -class Softplus(nn.Module): - r""" - A pytorch module implementing the softplus function: - - $$ - \operatorname{Softplus}(x) = \frac{1}{β} \operatorname{log} \left( 1 + e^{β x} \right) - $$ - """ - - # This docstring is a raw-string (it starts `r"""` rather than `"""`) - # so backslashes need not be escaped - - def __init__(self): - """ - Initializes the softplus function. - """ - super(Softplus, self).__init__() - # self.beta = nn.Linear(1, 1, bias=False) - self.beta = nn.Parameter(torch.ones(1)) - # elf.softplus = nn.Softplus(beta=self.beta) - - def forward(self, x: torch.Tensor) -> torch.Tensor: - """ - Forward pass of the softplus function. - - Arguments: - x: input tensor - """ - y = torch.log(1 + torch.exp(self.beta * x)) / self.beta - # y = self.softplus(x) - return y - - -class Softminus(nn.Module): - """ - A pytorch module implementing the softminus function: - - $$ - \\operatorname{Softminus}(x) = x - \\operatorname{log} \\left( 1 + e^{β x} \\right) - $$ - """ - - # This docstring is a normal string, so backslashes need to be escaped - - def __init__(self): - """ - Initializes the softminus function. - """ - super(Softminus, self).__init__() - # self.beta = nn.Linear(1, 1, bias=False) - self.beta = nn.Parameter(torch.ones(1)) - - def forward(self, x: torch.Tensor) -> torch.Tensor: - """ - Forward pass of the softminus function. - - Arguments: - x: input tensor - """ - y = x - torch.log(1 + torch.exp(self.beta * x)) / self.beta - return y - - -# defines all the operations. affine is turned off for cuda (optimization prposes) - - -def operation_factory(name): - - if name == "none": - return Zero(1) - elif name == "add": - return nn.Sequential(Identity()) - elif name == "subtract": - return nn.Sequential(NegIdentity()) - elif name == "mult": - return nn.Sequential( - nn.Linear(1, 1, bias=False), - ) - elif name == "linear": - return nn.Sequential(nn.Linear(1, 1, bias=True)) - elif name == "relu": - return nn.Sequential( - nn.ReLU(inplace=False), - ) - elif name == "linear_relu": - return nn.Sequential( - nn.Linear(1, 1, bias=True), - nn.ReLU(inplace=False), - ) - elif name == "logistic": - return nn.Sequential( - nn.Sigmoid(), - ) - elif name == "linear_logistic": - return nn.Sequential( - nn.Linear(1, 1, bias=True), - nn.Sigmoid(), - ) - elif name == "exp": - return nn.Sequential( - Exponential(), - ) - elif name == "linear_exp": - return nn.Sequential( - nn.Linear(1, 1, bias=True), - Exponential(), - ) - elif name == "cos": - return nn.Sequential( - Cosine(), - ) - elif name == "linear_cos": - return nn.Sequential( - nn.Linear(1, 1, bias=True), - Cosine(), - ) - elif name == "sin": - return nn.Sequential( - Sine(), - ) - elif name == "linear_sin": - return nn.Sequential( - nn.Linear(1, 1, bias=True), - Sine(), - ) - elif name == "tanh": - return nn.Sequential( - Tangens_Hyperbolicus(), - ) - elif name == "linear_tanh": - return nn.Sequential( - nn.Linear(1, 1, bias=True), - Tangens_Hyperbolicus(), - ) - elif name == "reciprocal": - return nn.Sequential( - MultInverse(), - ) - elif name == "linear_reciprocal": - return nn.Sequential( - nn.Linear(1, 1, bias=False), - MultInverse(), - ) - elif name == "ln": - return nn.Sequential( - NatLogarithm(), - ) - elif name == "linear_ln": - return nn.Sequential( - nn.Linear(1, 1, bias=False), - NatLogarithm(), - ) - elif name == "softplus": - return nn.Sequential( - Softplus(), - ) - elif name == "linear_softplus": - return nn.Sequential( - nn.Linear(1, 1, bias=False), - Softplus(), - ) - elif name == "softminus": - return nn.Sequential( - Softminus(), - ) - elif name == "linear_softminus": - return nn.Sequential( - nn.Linear(1, 1, bias=False), - Softminus(), - ) - else: - raise NotImplementedError(f"operation {name=} it not implemented") - - -# this is the list of primitives actually used, -# and it should be a set of names contained in the OPS dictionary -PRIMITIVES = ( - "none", - "add", - "subtract", - "linear", - "linear_logistic", - "mult", - "linear_relu", -) - -# make sure that every primitive is in the OPS dictionary -for name in PRIMITIVES: - assert operation_factory(name) is not None diff --git a/autora/theorist/darts/utils.py b/autora/theorist/darts/utils.py deleted file mode 100755 index 79d6affbc..000000000 --- a/autora/theorist/darts/utils.py +++ /dev/null @@ -1,491 +0,0 @@ -import csv -import glob -import os -import shutil -from typing import Callable, List, Optional, Tuple - -import numpy as np -import torch -from torch import nn as nn - -from autora.theorist.darts.model_search import Network -from autora.variable import ValueType - - -def create_output_file_name( - file_prefix: str, - log_version: Optional[int] = None, - weight_decay: Optional[float] = None, - k: Optional[int] = None, - seed: Optional[int] = None, - theorist: Optional[str] = None, -) -> str: - """ - Creates a file name for the output file of a theorist study. - - Arguments: - file_prefix: prefix of the file name - log_version: log version of the theorist run - weight_decay: weight decay of the model - k: number of nodes in the model - seed: seed of the model - theorist: name of the DARTS variant - """ - - output_str = file_prefix - - if theorist is not None: - output_str += "_" + str(theorist) - - if log_version is not None: - output_str += "_v_" + str(log_version) - - if weight_decay is not None: - output_str += "_wd_" + str(weight_decay) - - if k is not None: - output_str += "_k_" + str(k) - - if k is not None: - output_str += "_s_" + str(seed) - - return output_str - - -def assign_slurm_instance( - slurm_id: int, - arch_weight_decay_list: List, - num_node_list: List, - seed_list: List, -) -> Tuple: - """ - Determines the meta-search parameters based on the slum job id. - - Arguments: - slurm_id: slurm job id - arch_weight_decay_list: list of weight decay values - num_node_list: list of number of nodes - seed_list: list of seeds - """ - - seed_id = np.floor( - slurm_id / (len(num_node_list) * len(arch_weight_decay_list)) - ) % len(seed_list) - k_id = np.floor(slurm_id / (len(arch_weight_decay_list))) % len(num_node_list) - weight_decay_id = slurm_id % len(arch_weight_decay_list) - - return ( - arch_weight_decay_list[int(weight_decay_id)], - int(num_node_list[int(k_id)]), - int(seed_list[int(seed_id)]), - ) - - -def sigmid_mse(output: torch.Tensor, target: torch.Tensor) -> torch.Tensor: - """ - Returns the MSE loss for a sigmoid output. - - Arguments: - output: output of the model - target: target of the model - """ - m = nn.Sigmoid() - output = m(output) - loss = torch.mean((output - target) ** 2) - return loss - - -def compute_BIC( - output_type: ValueType, - model: torch.nn.Module, - input: torch.Tensor, - target: torch.Tensor, -) -> float: - """ - Returns the Bayesian information criterion for a DARTS model. - - Arguments: - output_type: output type of the dependent variable - model: model to compute the BIC for - input: input of the model - target: target of the model - """ - - # compute raw model output - classifier_output = model(input) - - # compute associated probability - m = get_output_format(output_type) - prediction = m(classifier_output).detach() - - k, _, _ = model.countParameters() # for most likely architecture - - if output_type == ValueType.CLASS: - target_flattened = torch.flatten(target.long()) - llik = 0 - for idx in range(len(target_flattened)): - lik = prediction[idx, target_flattened[idx]] - llik += np.log(lik) - n = len(target_flattened) # number of data points - - BIC = np.log(n) * k - 2 * llik - BIC = BIC - - elif output_type == ValueType.PROBABILITY_SAMPLE: - llik = 0 - for idx in range(len(target)): - - # fail safe if model doesn't produce probabilities - if prediction[idx] > 1: - prediction[idx] = 1 - elif prediction[idx] < 0: - prediction[idx] = 0 - - if target[idx] == 1: - lik = prediction[idx] - elif target[idx] == 0: - lik = 1 - prediction[idx] - else: - raise Exception("Target must contain either zeros or ones.") - llik += np.log(lik) - n = len(target) # number of data points - - BIC = np.log(n) * k - 2 * llik - BIC = BIC[0] - - else: - raise Exception( - "BIC computation not implemented for output type " - + str(ValueType.PROBABILITY) - + "." - ) - - return BIC - - # old - - -def compute_BIC_AIC( - soft_targets: np.array, soft_prediction: np.array, model: Network -) -> Tuple: - """ - Returns the Bayesian information criterion (BIC) as well as the - Aikaike information criterion (AIC) for a DARTS model. - - Arguments: - soft_targets: soft target of the model - soft_prediction: soft prediction of the model - model: model to compute the BIC and AIC for - """ - - lik = np.sum( - np.multiply(soft_prediction, soft_targets), axis=1 - ) # likelihood of data given model - llik = np.sum(np.log(lik)) # log likelihood - n = len(lik) # number of data points - k, _, _ = model.count_parameters() # for most likely architecture - - BIC = np.log(n) * k - 2 * llik - - AIC = 2 * k - 2 * llik - - return BIC, AIC - - -def cross_entropy(pred: torch.Tensor, soft_targets: torch.Tensor) -> torch.Tensor: - """ - Returns the cross entropy loss for a soft target. - - Arguments: - pred: prediction of the model - soft_targets: soft target of the model - """ - # assuming pred and soft_targets are both Variables with shape (batchsize, num_of_classes), - # each row of pred is predicted logits and each row of soft_targets is a discrete distribution. - logsoftmax = nn.LogSoftmax(dim=1) - return torch.mean(torch.sum(-soft_targets * logsoftmax(pred), 1)) - - -class AvgrageMeter(object): - """ - Computes and stores the average and current value. - """ - - def __init__(self): - """ - Initializes the average meter. - """ - self.reset() - - def reset(self): - """ - Resets the average meter. - """ - self.avg = 0 - self.sum = 0 - self.cnt = 0 - - def update(self, val: float, n: int = 1): - """ - Updates the average meter. - - Arguments: - val: value to update the average meter with - n: number of times to update the average meter - """ - self.sum += val * n - self.cnt += n - self.avg = self.sum / self.cnt - - -def accuracy(output: torch.Tensor, target: torch.Tensor, topk: Tuple = (1,)) -> List: - """ - Computes the accuracy over the k top predictions for the specified values of k. - - Arguments: - output: output of the model - target: target of the model - topk: values of k to compute the accuracy at - """ - maxk = max(topk) - batch_size = target.size(0) - - _, pred = output.topk(maxk, 1, True, True) - pred = pred.t() - correct = pred.eq(target.view(1, -1).expand_as(pred)) - - res = [] - for k in topk: - correct_k = correct[:k].view(-1).float().sum(0) - res.append(correct_k.mul_(100.0 / batch_size)) - return res - - -def count_parameters_in_MB(model: Network) -> int: - """ - Returns the number of parameters for a model. - - Arguments: - model: model to count the parameters for - """ - return ( - np.sum( - np.prod(v.size()) - for name, v in model.named_parameters() - if "auxiliary" not in name - ) - / 1e6 - ) - - -def save(model: torch.nn.Module, model_path: str, exp_folder: Optional[str] = None): - """ - Saves a model to a file. - - Arguments: - model: model to save - model_path: path to save the model to - exp_folder: general experiment directory to save the model to - """ - if exp_folder is not None: - os.chdir("exps") # Edit SM 10/23/19: use local experiment directory - torch.save(model.state_dict(), model_path) - if exp_folder is not None: - os.chdir("..") # Edit SM 10/23/19: use local experiment directory - - -def load(model: torch.nn.Module, model_path: str): - """ - Loads a model from a file. - """ - model.load_state_dict(torch.load(model_path)) - - -def create_exp_dir( - path: str, - scripts_to_save: Optional[List] = None, - parent_folder: str = "exps", - results_folder: Optional[str] = None, -): - """ - Creates an experiment directory and saves all necessary scripts and files. - - Arguments: - path: path to save the experiment directory to - scripts_to_save: list of scripts to save - parent_folder: parent folder for the experiment directory - results_folder: folder for the results of the experiment - """ - os.chdir(parent_folder) # Edit SM 10/23/19: use local experiment directory - if not os.path.exists(path): - os.mkdir(path) - print("Experiment dir : {}".format(path)) - - if results_folder is not None: - try: - os.mkdir(os.path.join(path, results_folder)) - except OSError: - pass - - if scripts_to_save is not None: - try: - os.mkdir(os.path.join(path, "scripts")) - except OSError: - pass - os.chdir("..") # Edit SM 10/23/19: use local experiment directory - for script in scripts_to_save: - dst_file = os.path.join( - parent_folder, path, "scripts", os.path.basename(script) - ) - shutil.copyfile(script, dst_file) - - -def read_log_files(results_path: str, winning_architecture_only: bool = False) -> Tuple: - """ - Reads the log files from an experiment directory and returns the results. - - Arguments: - results_path: path to the experiment results directory - winning_architecture_only: if True, only the winning architecture is returned - """ - - current_wd = os.getcwd() - - os.chdir(results_path) - filelist = glob.glob("*.{}".format("csv")) - - model_name_list = list() - loss_list = list() - BIC_list = list() - AIC_list = list() - - # READ LOG FILES - - print("Reading log files... ") - for file in filelist: - - with open(file) as csvfile: - readCSV = csv.reader(csvfile, delimiter=",") - for row in readCSV: - if winning_architecture_only is False or "sample0" in row[0]: - model_name_list.append(row[0]) - loss_list.append(float(row[1])) - BIC_list.append(float(row[2].replace("[", "").replace("]", ""))) - AIC_list.append(float(row[3].replace("[", "").replace("]", ""))) - - os.chdir(current_wd) - - return (model_name_list, loss_list, BIC_list, AIC_list) - - -def get_best_fitting_models( - model_name_list: List, - loss_list: List, - BIC_list: List, - topk: int, -) -> Tuple: - """ - Returns the topk best fitting models. - - Arguments: - model_name_list: list of model names - loss_list: list of loss values - BIC_list: list of BIC values - topk: number of topk models to return - """ - - topk_losses = sorted(zip(loss_list, model_name_list), reverse=False)[:topk] - res = list(zip(*topk_losses)) - topk_losses_names = res[1] - - topk_BICs = sorted(zip(BIC_list, model_name_list), reverse=False)[:topk] - res = list(zip(*topk_BICs)) - topk_BICs_names = res[1] - - return (topk_losses_names, topk_BICs_names) - - -def format_input_target( - input: torch.tensor, target: torch.tensor, criterion: Callable -) -> Tuple[torch.tensor, torch.tensor]: - """ - Formats the input and target for the model. - - Args: - input: input to the model - target: target of the model - criterion: criterion to use for the model - - Returns: - input: formatted input and target for the model - - """ - - if isinstance(criterion, nn.CrossEntropyLoss): - target = target.squeeze() - - return (input, target) - - -LOSS_FUNCTION_MAPPING = { - ValueType.REAL: nn.MSELoss(), - ValueType.PROBABILITY: sigmid_mse, - ValueType.PROBABILITY_SAMPLE: sigmid_mse, - ValueType.PROBABILITY_DISTRIBUTION: cross_entropy, - ValueType.CLASS: nn.CrossEntropyLoss(), - ValueType.SIGMOID: sigmid_mse, -} - - -def get_loss_function(outputType: ValueType): - """ - Returns the loss function for the given output type of a dependent variable. - - Arguments: - outputType: output type of the dependent variable - """ - - return LOSS_FUNCTION_MAPPING.get(outputType, nn.MSELoss()) - - -OUTPUT_FORMAT_MAPPING = { - ValueType.REAL: nn.Identity(), - ValueType.PROBABILITY: nn.Sigmoid(), - ValueType.PROBABILITY_SAMPLE: nn.Sigmoid(), - ValueType.PROBABILITY_DISTRIBUTION: nn.Softmax(dim=1), - ValueType.CLASS: nn.Softmax(dim=1), - ValueType.SIGMOID: nn.Sigmoid(), -} - - -def get_output_format(outputType: ValueType): - """ - Returns the output format (activation function of the final output layer) - for the given output type of a dependent variable. - - Arguments: - outputType: output type of the dependent variable - """ - - return OUTPUT_FORMAT_MAPPING.get(outputType, nn.MSELoss()) - - -OUTPUT_STR_MAPPING = { - ValueType.REAL: "", - ValueType.PROBABILITY: "Sigmoid", - ValueType.PROBABILITY_SAMPLE: "Sigmoid", - ValueType.PROBABILITY_DISTRIBUTION: "Softmax", - ValueType.CLASS: "Softmax", - ValueType.SIGMOID: "Sigmoid", -} - - -def get_output_str(outputType: ValueType) -> str: - """ - Returns the output string for the given output type of a dependent variable. - - Arguments: - outputType: output type of the dependent variable - """ - - return OUTPUT_STR_MAPPING.get(outputType, "") diff --git a/autora/theorist/darts/visualize.py b/autora/theorist/darts/visualize.py deleted file mode 100755 index bf3055332..000000000 --- a/autora/theorist/darts/visualize.py +++ /dev/null @@ -1,201 +0,0 @@ -import logging -import typing -from typing import Optional - -from graphviz import Digraph - -from autora.theorist.darts.operations import Genotype, get_operation_label - -_logger = logging.getLogger(__name__) - - -def plot( - genotype: Genotype, - filename: str, - file_format: str = "pdf", - view_file: Optional[bool] = None, - full_label: bool = False, - param_list: typing.Tuple = (), - input_labels: typing.Tuple = (), - out_dim: Optional[int] = None, - out_fnc: Optional[str] = None, -): - """ - Generates a graphviz plot for a DARTS model based on the genotype of the model. - - Arguments: - genotype: the genotype of the model - filename: the filename of the output file - file_format: the format of the output file - view_file: if True, the plot will be displayed in a window - full_label: if True, the labels of the nodes will be the full name of the operation - (including the coefficients) - param_list: a list of parameters to be included in the labels of the nodes - input_labels: a list of labels to be included in the input nodes - out_dim: the number of output nodes of the model - out_fnc: the (activation) function to be used for the output nodes - """ - - g = darts_model_plot( - genotype=genotype, - full_label=full_label, - param_list=param_list, - input_labels=input_labels, - out_dim=out_dim, - out_fnc=out_fnc, - ) - - if view_file is None: - if file_format == "pdf": - view_file = True - else: - view_file = False - - g.render(filename, view=view_file, format=file_format) - - -def darts_model_plot( - genotype: Genotype, - full_label: bool = False, - param_list: typing.Sequence = (), - input_labels: typing.Sequence = (), - out_dim: Optional[int] = None, - out_fnc: Optional[str] = None, - decimals_to_display: int = 2, -) -> Digraph: - """ - Generates a graphviz plot for a DARTS model based on the genotype of the model. - - Arguments: - genotype: the genotype of the model - full_label: if True, the labels of the nodes will be the full name of the operation - (including the coefficients) - param_list: a list of parameters to be included in the labels of the nodes - input_labels: a list of labels to be included in the input nodes - out_dim: the number of output nodes of the model - out_fnc: the (activation) function to be used for the output nodes - decimals_to_display: number of decimals to include in parameter values on plot - """ - - format_string = "{:." + "{:.0f}".format(decimals_to_display) + "f}" - - graph = Digraph( - edge_attr=dict(fontsize="20", fontname="times"), - node_attr=dict( - style="filled", - shape="rect", - align="center", - fontsize="20", - height="0.5", - width="0.5", - penwidth="2", - fontname="times", - ), - engine="dot", - ) - graph.body.extend(["rankdir=LR"]) - - for input_node in input_labels: - graph.node(input_node, fillcolor="#F1EDB9") # fillcolor='darkseagreen2' - # assert len(genotype) % 2 == 0 - - # determine number of steps (intermediate nodes) - steps = 0 - for op, j in genotype: - if j == 0: - steps += 1 - - for i in range(steps): - graph.node("k" + str(i + 1), fillcolor="#BBCCF9") # fillcolor='lightblue' - - params_counter = 0 - n = len(input_labels) - start = 0 - for i in range(steps): - end = start + n - _logger.debug(start, end) - # for k in [2*i, 2*i + 1]: - for k in range( - start, end - ): # adapted this iteration from get_genotype() in model_search.py - _logger.debug(genotype, k) - op, j = genotype[k] - if j < len(input_labels): - u = input_labels[j] - else: - u = "k" + str(j - len(input_labels) + 1) - v = "k" + str(i + 1) - params_counter = k - if op != "none": - op_label = op - if full_label: - params = param_list[ - start + j - ] # note: genotype order and param list order don't align - op_label = get_operation_label( - op, params, decimals=decimals_to_display - ) - graph.edge(u, v, label=op_label, fillcolor="gray") - else: - graph.edge( - u, - v, - label="(" + str(j + start) + ") " + op_label, - fillcolor="gray", - ) # '(' + str(k) + ') ' - start = end - n += 1 - - # determine output nodes - - out_nodes = list() - if out_dim is None: - out_nodes.append("out") - else: - biases = None - if full_label: - params = param_list[params_counter + 1] - if len(params) > 1: - biases = params[1] # first node contains biases - - for idx in range(out_dim): - out_str = "" - # specify node ID - if out_fnc is not None: - out_str = out_str + out_fnc + "(r_" + str(idx) - else: - out_str = "(r_" + str(idx) - - if out_dim == 1: - if out_fnc is not None: - out_str = "P(detected) = " + out_fnc + "(x" - else: - # out_str = 'dx_1 = (x' - out_str = "P_n = (x" - - # if available, add bias - if biases is not None: - out_str = out_str + " + " + format_string.format(biases[idx]) + ")" - else: - out_str = out_str + ")" - - # add node - graph.node(out_str, fillcolor="#CBE7C7") # fillcolor='palegoldenrod' - out_nodes.append(out_str) - - for i in range(steps): - u = "k" + str(i + 1) - if full_label: - params_org = param_list[params_counter + 1 + i] # count from k - for out_idx, out_str in enumerate(out_nodes): - params = list() - params.append(params_org[0][out_idx]) - op_label = get_operation_label( - "classifier", params, decimals=decimals_to_display - ) - graph.edge(u, out_str, label=op_label, fillcolor="gray") - else: - for out_idx, out_str in enumerate(out_nodes): - graph.edge(u, out_str, label="linear", fillcolor="gray") - - return graph diff --git a/autora/utils/__init__.py b/autora/utils/__init__.py deleted file mode 100644 index 6fda29471..000000000 --- a/autora/utils/__init__.py +++ /dev/null @@ -1 +0,0 @@ -from . import dictionary diff --git a/autora/utils/dictionary.py b/autora/utils/dictionary.py deleted file mode 100644 index b45b5b927..000000000 --- a/autora/utils/dictionary.py +++ /dev/null @@ -1,18 +0,0 @@ -from typing import Mapping - - -class LazyDict(Mapping): - """Inspired by https://gist.github.com/gyli/9b50bb8537069b4e154fec41a4b5995a""" - - def __init__(self, *args, **kw): - self._raw_dict = dict(*args, **kw) - - def __getitem__(self, key): - func = self._raw_dict.__getitem__(key) - return func() - - def __iter__(self): - return iter(self._raw_dict) - - def __len__(self): - return len(self._raw_dict) diff --git a/autora/variable/__init__.py b/autora/variable/__init__.py deleted file mode 100644 index 4cdd8ff99..000000000 --- a/autora/variable/__init__.py +++ /dev/null @@ -1,70 +0,0 @@ -from dataclasses import dataclass, field -from enum import Enum -from typing import Any, Optional, Sequence, Tuple - - -class ValueType(str, Enum): - """Specifies supported value types supported by Variables.""" - - REAL = "real" - SIGMOID = "sigmoid" - PROBABILITY = "probability" # single probability - PROBABILITY_SAMPLE = "probability_sample" # sample from single probability - PROBABILITY_DISTRIBUTION = ( - "probability_distribution" # probability distribution over classes - ) - CLASS = "class" # sample from probability distribution over classes - - -@dataclass -class Variable: - """Describes an experimental variable: name, type, range, units, and value of a variable.""" - - name: str = "" - value_range: Optional[Tuple[Any, Any]] = None - allowed_values: Optional[Sequence] = None - units: str = "" - type: ValueType = ValueType.REAL - variable_label: str = "" - rescale: float = 1 - is_covariate: bool = False - - -@dataclass -class IV(Variable): - """Independent variable.""" - - name: str = "IV" - variable_label: str = "Independent Variable" - - -@dataclass -class DV(Variable): - """Dependent variable.""" - - name: str = "DV" - variable_label: str = "Dependent Variable" - - -@dataclass(frozen=True) -class VariableCollection: - """Immutable metadata about dependent / independent variables and covariates.""" - - independent_variables: Sequence[Variable] = field(default_factory=list) - dependent_variables: Sequence[Variable] = field(default_factory=list) - covariates: Sequence[Variable] = field(default_factory=list) - - -@dataclass -class IVTrial(IV): - """ - Experiment trial as independent variable. - """ - - name: str = "trial" - UID: str = "" - variable_label: str = "Trial" - units: str = "trials" - priority: int = 0 - value_range: Tuple[Any, Any] = (0, 10000000) - value: float = 0 diff --git a/autora/variable/time.py b/autora/variable/time.py deleted file mode 100644 index a2ad641a9..000000000 --- a/autora/variable/time.py +++ /dev/null @@ -1,103 +0,0 @@ -import time - -from autora.variable import DV, IV - - -class VTime: - """ - A class representing time as a general experimental variable. - """ - - _t0 = 0 - - def __init__(self): - """ - Initializes the time. - """ - self._t0 = time.time() - - # Resets reference time. - def reset(self): - """ - Resets the time. - """ - self._t0 = time.time() - - -class IVTime(IV, VTime): - """ - A class representing time as an independent variable. - """ - - _name = "time_IV" - _UID = "" - _variable_label = "Time" - _units = "s" - _priority = 0 - _value_range = (0, 3600) - _value = 0 - - # Initializes reference time. - # The reference time usually denotes the beginning of an experiment trial. - def __init__(self, *args, **kwargs): - """ - Initializes the time as independent variable. - - For arguments, see [autora.variable.Variable][autora.variable.Variable.__init__] - """ - super(IVTime, self).__init__(*args, **kwargs) - - # Waits until specified time has passed relative to reference time - def manipulate(self): - """ - Waits for the specified time to pass. - """ - - t_wait = self.get_value() - (time.time() - self._t0) - if t_wait <= 0: - return - else: - time.sleep(t_wait) - - def disconnect(self): - """ - Disconnects the time. - """ - pass - - -class DVTime(DV, VTime): - """ - A class representing time as a dependent variable. - """ - - _name = "time_DV" - _UID = "" - _variable_label = "Time" - _units = "s" - _priority = 0 - _value_range = (0, 604800) # don't record more than a week - _value = 0 - - _is_covariate = True - - # Initializes reference time. - # The reference time usually denotes the beginning of an experiment trial. - def __init__(self, *args, **kwargs): - """ - Initializes the time as dependent variable. The reference time usually denotes - the beginning of an experiment trial. - - For arguments, see [autora.variable.Variable][autora.variable.Variable.__init__] - """ - print(self._variable_label) - super(DVTime, self).__init__(*args, **kwargs) - print(self._variable_label) - - # Measure number of seconds relative to reference time - def measure(self): - """ - Measures the time in seconds relative to the reference time. - """ - value = time.time() - self._t0 - self.set_value(value) diff --git a/autora/variable/tinkerforge.py b/autora/variable/tinkerforge.py deleted file mode 100644 index bd5518ae6..000000000 --- a/autora/variable/tinkerforge.py +++ /dev/null @@ -1,347 +0,0 @@ -from abc import abstractmethod -from typing import Any, Tuple - -from tinkerforge.bricklet_industrial_analog_out_v2 import BrickletIndustrialAnalogOutV2 -from tinkerforge.bricklet_industrial_dual_0_20ma_v2 import BrickletIndustrialDual020mAV2 -from tinkerforge.bricklet_industrial_dual_analog_in_v2 import ( - BrickletIndustrialDualAnalogInV2, -) -from tinkerforge.ip_connection import IPConnection -from variable import ValueType - -from autora.variable import DV, IV, Variable - - -class TinkerforgeVariable(Variable): - """ - A representation of a variable used in the Tinkerforge environment. - """ - - _variable_label = "" - _UID = "" - _priority = 0 - - def __init__( - self, - variable_label: str = "", - UID: str = "", - name: str = "", - units: str = "", - priority: int = 0, - value_range: Tuple[Any, Any] = (0, 1), - type: ValueType = float, - ): - """ - Initializes a Tinkerforge variable. - Args: - variable_label: the label of the variable - UID: the user identification of the variable - name: the name of the variable - units: the units of the variable - priority: the priority of the variable - value_range: the value range of the variable - type: the type of the variable - """ - - super().__init__( - name=name, - value_range=value_range, - units=units, - type=type, - variable_label=variable_label, - ) - - self._UID = UID - self._priority = priority - - def __get_priority__(self) -> int: - """ - Get priority of variable. The priority is used to determine the sequence of variables - to be measured or manipulated. - - Returns: - The priority of the variable. - """ - return self._priority - - def __set_priority__(self, priority: int = 0): - """ - Set priority of variable. - The priority is used to determine the sequence of variables to be measured or manipulated. - - Arguments: - priority: The priority of the variable. - """ - self._priority = priority - - @abstractmethod - def clean_up(self): - """Clean up measurement device.""" - pass - - @abstractmethod - def disconnect(self): - """Disconnect from up measurement device.""" - pass - - -class IVTF(IV, TinkerforgeVariable): - """ - A representation of an independent variable used in the Tinkerforge environment. - """ - - def __init__(self, *args, **kwargs): - """ - Initializes an independent variable used in the Tinkerforge environment. - - For arguments, see [autora.variable.tinkerforge.TinkerforgeVariable] - [autora.variable.tinkerforge.TinkerforgeVariable.__init__] - """ - IV.__init__(self, *args, **kwargs) - TinkerforgeVariable.__init__(self, *args, **kwargs) - - -class DVTF(DV, TinkerforgeVariable): - """ - A representation of a dependent variable used in the Tinkerforge environment. - """ - - def __init__(self, *args, **kwargs): - """ - Initializes a dependent variable used in the Tinkerforge environment. - - For arguments, see [autora.variable.tinkerforge.TinkerforgeVariable] - [autora.variable.tinkerforge.TinkerforgeVariable.__init__] - """ - DV.__init__(self, *args, **kwargs) - TinkerforgeVariable.__init__(self, *args, **kwargs) - - -class IVCurrent(IVTF): - """ - An independent tinkerforge variable representing the current. - """ - - _name = "source_current" - _UID = "MST" - _variable_label = "Source Current" - _units = "µA" - _priority = 0 - _value_range = (0, 20000) - _value = 0 - - _HOST = "localhost" - _PORT = 4223 - - def __init__(self, *args, **kwargs): - """ - Initializes Industrial Analog Out 2.0 device. - - For arguments, see [autora.variable.tinkerforge.TinkerforgeVariable] - [autora.variable.tinkerforge.TinkerforgeVariable.__init__] - """ - - self._ipcon = IPConnection() # Create IP connection - self._iao = BrickletIndustrialAnalogOutV2( - self._UID, self._ipcon - ) # Create device object - - self._ipcon.connect(self._HOST, self._PORT) # Connect to brickd - - super(IVCurrent, self).__init__(*args, **kwargs) - - def disconnect(self): - """ - Disconnect from up measurement device. - """ - - self._iao.set_enabled(False) - - self._ipcon.disconnect() - - def stop(self): - """ - Disable current output - """ - - self._iao.set_enabled(False) - - def manipulate(self): - """ - Sets the current output to the specified value. - """ - self._iao.set_current(self.get_value()) - self._iao.set_enabled(True) - - def clean_up(self): - """ - Clean up measurement device. - """ - self.stop() - - -class IVVoltage(IVTF): - """ - An independent tinkerforge variable representing the voltage. - """ - - _variable_label = "Source Voltage" - _UID = "MST" - _name = "source_voltage" - _units = "mV" - _priority = 0 - _value_range = (0, 5000) - _value = 0 - - _HOST = "localhost" - _PORT = 4223 - - def __init__(self, *args, **kwargs): - """ - Initializes Industrial Analog Out 2.0 device. - """ - - self._ipcon = IPConnection() # Create IP connection - self._iao = BrickletIndustrialAnalogOutV2( - self._UID, self._ipcon - ) # Create device object - - self._ipcon.connect(self._HOST, self._PORT) # Connect to brickd - - super(IVVoltage, self).__init__(*args, **kwargs) - - def disconnect(self): - """ - Disconnect from up measurement device. - """ - - self._iao.set_enabled(False) - - self._ipcon.disconnect() - - def stop(self): - """ - Disable voltage output - """ - self._iao.set_enabled(False) - - def manipulate(self): - """ - Sets the voltage output to the specified value. - """ - self._iao.set_voltage(self.get_value()) - self._iao.set_enabled(True) - - def clean_up(self): - """ - Clean up measurement device. - """ - self.stop() - - -class DVCurrent(DVTF): - """ - A dependent tinkerforge variable representing the current. - """ - - _name = "current0" - _UID = "Hfg" - _variable_label = "Current 0" - _units = "mA" - _priority = 0 - _value_range = (0, 2000) - _value = 0 - - _HOST = "localhost" - _PORT = 4223 - channel = 0 - - def __init__(self, *args, **kwargs): - """ - Initializes Industrial Analog Out 2.0 device. - - For arguments, see [autora.variable.tinkerforge.TinkerforgeVariable] - [autora.variable.tinkerforge.TinkerforgeVariable.__init__] - """ - - super(DVCurrent, self).__init__(*args, **kwargs) - - self._ipcon = IPConnection() # Create IP connection - self._id020 = BrickletIndustrialDual020mAV2( - self._UID, self._ipcon - ) # Create device object - - self._ipcon.connect(self._HOST, self._PORT) # Connect to brickd - - if self._name == "current1": - self.channel = 1 - else: - self.channel = 0 - - def disconnect(self): - """ - Disconnect from up measurement device. - """ - - self._ipcon.disconnect() - - def measure(self): - """ - Measures the current. - """ - current = self._id020.get_current(self.channel) - self.set_value(current / 1000000.0) - - -class DVVoltage(DVTF): - """ - A dependent tinkerforge variable representing the voltage. - """ - - _name = "voltage0" - _UID = "MjY" - _variable_label = "Voltage 0" - _units = "mV" - _priority = 0 - _value_range = (-3500, 3500) - _value = 0 - - _HOST = "localhost" - _PORT = 4223 - - channel = 0 - - def __init__(self, *args, **kwargs): - """ - Initializes Industrial Analog Out 2.0 device. - - For arguments, see [autora.variable.tinkerforge.TinkerforgeVariable] - [autora.variable.tinkerforge.TinkerforgeVariable.__init__] - """ - - super(DVVoltage, self).__init__(*args, **kwargs) - - self._ipcon = IPConnection() # Create IP connection - self._idai = BrickletIndustrialDualAnalogInV2( - self._UID, self._ipcon - ) # Create device object - - self._ipcon.connect(self._HOST, self._PORT) # Connect to brickd - - if self._name == "voltage1": - self.channel = 1 - else: - self.channel = 0 - - def disconnect(self): - """ - Disconnect from up measurement device. - """ - self._ipcon.disconnect() - - def measure(self): - """ - Measures the voltage. - """ - value = self._idai.get_voltage(self.channel) - self.set_value(value) diff --git a/conda/autora/meta.yaml b/conda/autora/meta.yaml deleted file mode 100644 index 652861a61..000000000 --- a/conda/autora/meta.yaml +++ /dev/null @@ -1,74 +0,0 @@ -{% set name = "autora" %} -{% set version = "0.0.0" %} - -package: - name: "{{ name|lower }}" - version: "{{ version }}" - -source: - path: ../../ - -build: - number: 0 - noarch: python - script: "{{ PYTHON }} -m pip install . -vv" - -requirements: - host: - - python - - pip - - poetry - run: - - imageio >=2.9.0,<3.0.0 - - matplotlib >=3.2.1,<4.0.0 - - numpy >=1.22.1,<2.0.0 - - pandas >=1.4.2,<2.0.0 - - pytorch =2.0.0 - - python-graphviz >=0.14.1,<0.21.0 - - scikit-learn >=1.1.1,<2.0.0 - - scipy >=1.9.3,<2.0.0 - - seaborn >=0.11.1,<0.13.0 - - sympy >=1.10.1,<2.0.0 - - tqdm >=4.64.0,<5.0.0 - -test: - requires: - - pytest - source_files: - - tests - imports: - - autora - - autora.cycle - - autora.cycle.plot_utils - - autora.cycle.simple - - autora.experimentalist - - autora.experimentalist.sampler - - autora.experimentalist.filter - - autora.experimentalist.pipeline - - autora.experimentalist.pooler - - autora.skl - - autora.skl.darts - - autora.skl.bms - - autora.skl.bsr - - autora.synthetic - - autora.synthetic.inventory - - autora.theorist - - autora.theorist.darts - - autora.theorist.bms - - autora.theorist.bsr - - autora.variable - -about: - home: "https://musslick.github.io/AER_website/Research.html" - license: UNKNOWN - license_family: OTHER - license_file: LICENSE.md - summary: "Autonomous Research Assistant (AutoRA) is a framework for automating steps of the empirical research process. This framework implements tools for autonomously and iteratively generating 1) new theories to describe real-world data, and 2) experiments to invalidate those theories and seed a new cycle of theory-making. The experiments will be run online via crowd-sourcing platforms (MTurk, Prolific)." - doc_url: https://autoresearch.github.io/autora/ - dev_url: https://github.com/AutoResearch/autora - -extra: - recipe-maintainers: - - musslick - - hollandjg - - benwandrew diff --git a/conda/autora/run_test.sh b/conda/autora/run_test.sh deleted file mode 100644 index e47c0bba2..000000000 --- a/conda/autora/run_test.sh +++ /dev/null @@ -1,3 +0,0 @@ -#!/bin/zsh - -pytest tests/ diff --git a/docs/CODEOWNERS b/docs/CODEOWNERS deleted file mode 100644 index 3e42d47ec..000000000 --- a/docs/CODEOWNERS +++ /dev/null @@ -1 +0,0 @@ -* @musslick \ No newline at end of file diff --git a/docs/contribute/core.md b/docs/contribute/core.md new file mode 100644 index 000000000..0a0cbc887 --- /dev/null +++ b/docs/contribute/core.md @@ -0,0 +1,29 @@ +# Contribute to the Core + +Core contributions are changes to AutoRA which aren't experimentalists, (synthetic) experiment runners and theorists. +The primary purpose of the core is to provide utilities for: + +- describing experiments (in the [`autora-core` package](https://github.com/autoresearch/autora-core)) +- handle workflows for automated experiments + (currently in the [`autora-workflow` package](https://github.com/autoresearch/autora-workflow)) + +Suggested changes to the core should be submitted as follows, depending on their content: + +- For fixes or new features closely associated with existing core functionality: pull request to the existing + core package +- For new features which don't fit into the current module structure, or which are experimental and could lead to + instability for users: as new namespace packages. + +!!! success + Reach out to the core team about new core contributions to discuss how best to incorporate them by posting your + idea on the [discussions page](https://github.com/orgs/AutoResearch/discussions/categories/ideas). + +Core packages should as a minimum: + +- Follow standard python coding guidelines including PEP8 +- Run under all minor versions of python (e.g. 3.8, 3.9) allowed in + [`autora-core`](https://github.com/autoresearch/autora-core) +- Be compatible with all current AutoRA packages +- Have comprehensive test suites +- Use the linters and checkers defined in the `autora-core` + [.pre-commit-config.yaml](https://github.com/AutoResearch/autora-core/blob/main/.pre-commit-config.yaml) diff --git a/docs/contribute/index.md b/docs/contribute/index.md new file mode 100644 index 000000000..cec202889 --- /dev/null +++ b/docs/contribute/index.md @@ -0,0 +1,17 @@ +# Contributor Guide + +Contributions to AutoRA are organized into one "parent" and many "child" packages. + +[`autora`](https://github.com/autoresearch/autora) is the "parent" package which end users are expected to install. +It includes vetted "child" packages as optional dependencies which users can choose to install. + +Each experimentalist, experiment runner or theorist is a "child" package. +For details on how to submit child packages for inclusion in `autora`, see +[the module contributor guide here](./module.md). + +[`autora-core`](https://github.com/autoresearch/autora-core), is the "core" package which includes fundamental utilities +and building blocks for all the other packages. This is always installed when a user installs `autora` and can be +a dependency of other "child" packages. For more details, see [the core contributor guide here](./core.md). + +It's possible to set up your python environment in many different ways. +One setup which works for us is described in [the setup guide](./setup.md). diff --git a/docs/contribute/module.md b/docs/contribute/module.md new file mode 100644 index 000000000..2477d61d1 --- /dev/null +++ b/docs/contribute/module.md @@ -0,0 +1,151 @@ +# Contribute an Experimentalist, Experiment Runner, or Theorist + +Each experimentalist, experiment runner or theorist is a "child" package based on either + +- the [cookiecutter template (recommended)](https://github.com/AutoResearch/autora-template-cookiecutter), or +- the [unguided template](https://github.com/AutoResearch/autora-template). + +!!! hint + The easiest way to contribute a new child package for an experimentalist, experiment runner or theorist, + start from the [cookiecutter template](https://github.com/AutoResearch/autora-template-cookiecutter). + +!!! success + New **synthetic** experiment runners may be submitted as pull requests to the + [`autora-synthetic`](https://github.com/autoresearch/autora-synthetic/CONTRIBUTING.md) package, providing they + require no additional dependencies. This is meant to simplify small contributions. + However, if your contribution requires additional dependencies, you can submit it as a full package following + this guide. + +Once your package is working, and you've published it on PyPI, you can **make a pull request** on +[`autora`](https://github.com/autoresearch/autora) to have it vetted and added to the "parent" package. + +The following demonstrates how to add a package published under autora-theorist-example in PyPI in the GitHub +repository example-contributor/contributor-theorist + +## Creating a new child package + +### Install the "parent" package in development mode + +Install this in an environment using your chosen package manager. In this example, we use pip and virtualenv. + +First, install: + +- python: https://www.python.org/downloads/ +- virtualenv: https://virtualenv.pypa.io/en/latest/installation.html + +Create a new virtual environment: +```shell +virtualenv venv +``` + +Activate it: +```shell +source venv/bin/activate +``` + +Use `pip install` to install the current project (`"."`) in editable mode (`-e`) with dev-dependencies (`[dev]`): +```shell +pip install -e ".[dev]" +``` + +Check that the documentation builds correctly by running: +```shell +mkdocs serve +``` + +... then viewing the documentation using the link in your terminal. + + +### Add the package as optional dependency +In the `pyorject.toml` file add an optional dependency for the package in the `[project.optional-dependencies]` section: + +```toml +example-theorist = ["autora-theorist-example==1.0.0"] +``` + +!!! success + Ensure you include the version number. + +Add the example-theorist to be part of the all-theorists dependency: +```toml +all-theorists = [ + ... + "autora[example-theorist]", + ... +] +``` + +Update the environment: + +```shell +pip install -U -e ".[dev]" +``` + +... and check that your package is still importable and works as expected. + +### Import documentation from the package repository +Import the documentation in the `mkdocs.yml` file: +```yml +- User Guide: + - Theorists: + - Overview: 'theorist/overview.md' + ... + - Example Theorist: '!import https://github.com/example-contributor/contributor-theorist/?branch=v1.0.0&extra_imports=["mkdocs/base.yml"]' + ... +``` + +!!! success + Ensure you include the version number in the `!import` string after `?branch=`. Ensure that the commit you want + to submit has a tag with the correct version number in the correct format. + +Check that the documentation builds correctly by running: +```shell +mkdocs serve +``` + +... then view the documentation using the link in your terminal. Check that your new documentation is included in +the right place and renders correctly. + +## Updating a child package + +!!! warning + Please note, that packages need to be vetted each time they are updated. + +Update the version number in the `pyproject.toml` file, in the [project.optional-dependencies] +section: +```toml +example-theorist = ["autora-theorist-example==1.1.0"] +``` + +Update the version number in the `mkdocs.yml`: +```yml +- User Guide: + - Theorists: + ... + - Example Theorist: '!import https://github.com/example-contributor/contributor-theorist/?branch=v1.1.0&extra_imports=["mkdocs/base.yml"]' + ... +``` + +Update the environment: +```shell +pip install -U -e ".[dev]" +``` + +... and check that your package is still importable and works as expected. + +Check that the documentation builds correctly by running: +```shell +mkdocs serve +``` + +... then view the documentation using the link in your terminal. Check that your new documentation is included in +the right place and renders correctly. + + +Once everything is working locally, make a new PR on [github.com](https://github.com/autoresearch/autora) with your +changes. Include: + +- a description of the changes to the package, and +- a link to your release notes. + +Request a review from someone in the core team and wait for their feedback! diff --git a/docs/contribute/pre-commit-hooks.md b/docs/contribute/pre-commit-hooks.md new file mode 100644 index 000000000..4e8827f1e --- /dev/null +++ b/docs/contribute/pre-commit-hooks.md @@ -0,0 +1,53 @@ +# Pre-Commit Hooks + +We use [`pre-commit`](https://pre-commit.com) to manage pre-commit hooks. + +Pre-commit hooks are programs which run before each git commit, and can read and potentially modify the files which are to be committed. + +We use pre-commit hooks to: +- enforce coding guidelines, including the `python` style-guide [PEP8](https://peps.python.org/pep-0008/) (`black` and `flake8`), +- to check the order of `import` statements (`isort`), +- to check the types of `python` objects (`mypy`). + +The hooks and their settings are specified in the `.pre-commit-config.yaml` in each repository. + +## Handling Pre-Commit Hook Errors + +If your `git commit` fails because of the pre-commit hook, then you should: + +1. Run the pre-commit hooks on the files which you have staged, by running the following command in your terminal: + ```zsh + $ pre-commit run + ``` + +2. Inspect the output. It might look like this: + ``` + $ pre-commit run + black....................Passed + isort....................Passed + flake8...................Passed + mypy.....................Failed + - hook id: mypy + - exit code: 1 + + example.py:33: error: Need type annotation for "data" (hint: "data: Dict[, ] = ...") + Found 1 errors in 1 files (checked 10 source files) + ``` +3. Fix any errors which are reported. + **Important: Once you've changed the code, re-stage the files it to Git. + This might mean un-staging changes and then adding them again.** +4. If you have trouble: + - Do a web-search to see if someone else had a similar error in the past. + - Check that the tests you've written work correctly. + - Check that there aren't any other obvious errors with the code. + - If you've done all of that, and you still can't fix the problem, get help from someone else on the team. +5. Repeat 1-4 until all hooks return "passed", e.g. + ``` + $ pre-commit run + black....................Passed + isort....................Passed + flake8...................Passed + mypy.....................Passed + ``` + +It's easiest to solve these kinds of problems if you make small commits, often. diff --git a/docs/contribute/setup.md b/docs/contribute/setup.md new file mode 100644 index 000000000..d30244df0 --- /dev/null +++ b/docs/contribute/setup.md @@ -0,0 +1,206 @@ +# Setup Guide + +It's possible to set up your python environment in many different ways. + +To use the AutoRA package you need: + +- `python` and +- packages as specified in the `pyproject.toml` file. + +To develop the AutoRA package, you also need: + +- `git`, the source control tool, +- `pre-commit` which is used for handling git pre-commit hooks. + +You should also consider using an IDE. We recommend: + +- PyCharm. This is a `python`-specific integrated development environment which comes with useful tools + for changing the structure of `python` code, running tests, etc. +- Visual Studio Code. This is a powerful general text editor with plugins to support `python` development. + +The following sections describe how to install and configure the recommended setup for developing AutoRA. + +!!! tip + It is helpful to be familiar with the command line for your operating system. The topics required are covered in: + + - **macOS**: Joe Kissell. [*Take Control of the Mac Command Line with Terminal, 3rd Edition*](https://bruknow.library.brown.edu/permalink/01BU_INST/528fgv/cdi_safari_books_v2_9781947282513). Take Control Books, 2022. Chapters *Read Me First* through *Bring the Command Line Into The Real World*. + - **Linux**: William E. Shotts. [*The Linux Command Line: a Complete Introduction. 2nd edition.*](https://bruknow.library.brown.edu/permalink/01BU_INST/9mvq88/alma991043239704906966). No Starch Press, 2019. Parts *I: Learning the Shell* and *II: Configuration and the Environment*. + +## Development Setup + +### Clone the Repository + +The easiest way to clone the repo is to go to [the repository page on GitHub](https://github.com/AutoResearch/autora) +and click the "<> Code" button and follow the prompts. + +!!! hint + We recommend using: + + - the [GitHub Desktop Application](https://desktop.github.com) on macOS or Windows, or + - the [GitHub command line utility](https://cli.github.com) on Linux. + +### Install `python` + +!!! success + All contributions to the AutoRA core packages should work under **python 3.8**, so we recommend using that version + for development. + + +You can install python: + +- Using the instructions at [python.org](https://www.python.org), or +- Using a package manager, e.g. + [homebrew](https://docs.brew.sh/Homebrew-and-Python), + [pyenv](https://github.com/pyenv/pyenv), + [asdf](https://github.com/asdf-community/asdf-python), + [rtx](https://github.com/jdxcode/rtx/blob/main/docs/python.md), + [winget](https://winstall.app/apps/Python.Python.3.8). + +If successful, you should be able to run python in your terminal emulator like this: +```shell +python +``` + +...and see some output like this: +``` +Python 3.11.3 (main, Apr 7 2023, 20:13:31) [Clang 14.0.0 (clang-1400.0.29.202)] on darwin +Type "help", "copyright", "credits" or "license" for more information. +``` + +#### Create a virtual environment + +!!! success + We recommend setting up your development environment using a manager like `venv`, which creates isolated python + environments. Other environment managers, like + [virtualenv](https://virtualenv.pypa.io/en/latest/), + [pipenv](https://pipenv.pypa.io/en/latest/), + [virtualenvwrapper](https://virtualenvwrapper.readthedocs.io/en/latest/), + [hatch](https://hatch.pypa.io/latest/), + [poetry](https://python-poetry.org), + are available and will likely work, but will have different syntax to the syntax shown here. + + Our packages are set up using `virtualenv` with `pip` + +In the ``, run the following command to create a new virtual environment in the `.venv` directory + +```shell +python3 -m "venv" ".venv" +``` + +Activate it by running +```shell +source ".venv/bin/activate" +``` + +#### Install dependencies + +Upgrade pip: +```shell +pip install --upgrade pip +``` + +Install the current project development dependencies: +```shell +pip install --upgrade --editable ".[dev]" +``` + +Your IDE may have special support for python environments. For IDE-specific setup, see: + +- [PyCharm Documentation](https://www.jetbrains.com/help/pycharm/configuring-python-interpreter.html) +- [VSCode Documentation](https://code.visualstudio.com/docs/python/environments) + + +### Activating and using the environment + +To run interactive commands, you can activate the virtualenv environment. From the `` +directory, run: + +```shell +source ".venv/bin/activate" +``` + +This spawns a new shell where you have access to the `python` and all the packages installed using `pip install`. You +should see the prompt change: + +``` +% source .venv/bin/activate +(.venv) % +``` + + +If you execute `python` and then `import numpy`, you should be able to see that `numpy` has been imported from the +`.venv` environment: + +``` +(.venv) % python +Python 3.8.16 (default, Dec 15 2022, 14:31:45) +[Clang 14.0.0 (clang-1400.0.29.202)] on darwin +Type "help", "copyright", "credits" or "license" for more information. +>>> import numpy +>>> numpy + +>>> exit() +(.venv) % +``` + +You should be able to check that the current project works by running the tests: +```shell +pytest +``` + +It should return something like: + +``` +% pytest +. +-------------------------------- +Ran 1 test in 0.000s + +OK +``` + + +!!! hint + To deactivate the `virtualenv` environment, `deactivate` it. This should return you to your original prompt, + as follows: + ``` + (venv) % deactivate + % + ``` + + +### Running code non-interactively + +You can run python programs without activating the environment, by using `/path/to/python run {command}`. For example, +to run unittests tests, execute: + +```shell +.venv/bin/python -m pytest +``` + +It should return something like: + +``` +% .venv/bin/python -m pytest +. +-------------------------------- +Ran 1 test in 0.000s + +OK +``` + +### Pre-commit hooks + +If you wish to commit to the repository, you should install and activate `pre-commit` as follows. +```shell +pip install pre-commit +pre-commit install +``` + +You can run the pre-commit hooks manually by calling: +```shell +pre-commit run --all-files +``` + +For more information on pre-commit hooks, see [Pre-Commit-Hooks](./pre-commit-hooks.md) + diff --git a/docs/cycle/cycle_results_plots.ipynb b/docs/cycle/cycle_results_plots.ipynb deleted file mode 100644 index d01f36ef0..000000000 --- a/docs/cycle/cycle_results_plots.ipynb +++ /dev/null @@ -1,643 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "source": [ - " # Examples of using cycle results plotting functions" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": [ - "# Uncomment the following line when running on Google Colab\n", - "# !pip install autora" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "from autora.variable import VariableCollection, Variable\n", - "from autora.cycle import Cycle, plot_results_panel_2d, plot_results_panel_3d\n", - "from autora.experimentalist.pipeline import Pipeline\n", - "from autora.experimentalist.pooler.general_pool import grid_pool\n", - "from autora.experimentalist.sampler import random_sampler\n", - "from sklearn.linear_model import LinearRegression\n", - "import numpy as np\n", - "import random\n", - "%matplotlib inline" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "outputs": [ - { - "data": { - "text/plain": "" - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Simple linear regression cycle\n", - "random.seed(1)\n", - "\n", - "def ground_truth(xs):\n", - " return xs + 1.0\n", - "\n", - "# Variable Metadata\n", - "study_metadata = VariableCollection(\n", - " independent_variables=[\n", - " Variable(name=\"x1\", allowed_values=np.linspace(0, 1, 100))\n", - " ],\n", - " dependent_variables=[Variable(name=\"y\", value_range=(-20, 20))],\n", - ")\n", - "\n", - "# Theorist\n", - "lm = LinearRegression()\n", - "\n", - "# Experimentalist\n", - "example_experimentalist = Pipeline(\n", - " [\n", - " (\"pool\", grid_pool),\n", - " (\"sampler\", random_sampler),\n", - " (\"transform\", lambda x: [s[0] for s in x]),\n", - " ],\n", - " params={\n", - " \"pool\": {\"ivs\": study_metadata.independent_variables},\n", - " \"sampler\": {\"n\": 5},\n", - " },\n", - ")\n", - "\n", - "# Experiment Runner\n", - "def get_example_synthetic_experiment_runner():\n", - " rng = np.random.default_rng(seed=180)\n", - "\n", - " def runner(xs):\n", - " return ground_truth(xs) + rng.normal(0, 0.1, xs.shape)\n", - "\n", - " return runner\n", - "\n", - "example_synthetic_experiment_runner = get_example_synthetic_experiment_runner()\n", - "\n", - "# Initialize Cycle\n", - "cycle = Cycle(\n", - " metadata=study_metadata,\n", - " theorist=lm,\n", - " experimentalist=example_experimentalist,\n", - " experiment_runner=example_synthetic_experiment_runner,\n", - ")\n", - "cycle.run(5)" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "markdown", - "source": [ - "## Plotting 2D\n", - "The plotter will create a panel for each cycle.\n", - "* Default shows black points for previous data and orange points for new data to the cycle.\n", - "* The theory is plotted as a blue line.\n", - "* Default panel configuration is 4 plots to a row." - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": 3, - "outputs": [ - { - "data": { - "text/plain": "
", - "image/png": "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\n" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Plot cycle results with each cycle as one panel\n", - "plot_results_panel_2d(cycle); # Add semicolon to supress creating two figures in jupyter notebook" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "markdown", - "source": [ - "### Default parameters can be changed by passing in keywords" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": 4, - "outputs": [ - { - "data": { - "text/plain": "
", - "image/png": "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\n" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Change wrap to 3 and Adjust dimensions\n", - "plot_results_panel_2d(cycle,\n", - " wrap=3,\n", - " subplot_kw=dict(figsize=(9,4.5))\n", - " );" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "markdown", - "source": [ - "Above the wrap is changed to 3 panels per row and the dimensions of the figure are adjusted.\n", - "\n", - "* Keyword arguments can be supplied to the underlying matplotlib plotting functions as dictionaries.\n", - " * The above example supplies figure dimensions to the [subplot](https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.subplot.html) function using the keyword `subplot_kw`. The subplot function controls the layout and configuration of the entire figure of panels.\n", - " * Below shows ways to specify the parameters of the [scatter](https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.scatter.html) points and theory [line](https://matplotlib.org/stable/api/_as_gen/matplotlib.axes.Axes.plot.html)." - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": 5, - "outputs": [ - { - "data": { - "text/plain": "
", - "image/png": "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\n" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Change wrap to 3, Adjust dimensions, adjust scatter plot and line colors, shapes, and sizes\n", - "fig = plot_results_panel_2d(cycle,\n", - " wrap=3,\n", - " subplot_kw=dict(figsize=(10,5)), # Panel configurations\n", - " scatter_previous_kw=dict(color='rebeccapurple', marker='o', s=10), # Previous data point\n", - " scatter_current_kw=dict(color='limegreen', marker='^', s=50, alpha=1), # Current cycle data\n", - " plot_theory_kw=dict(color='magenta', ls='--', lw=2, zorder=0), # Theory line\n", - " );" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "markdown", - "source": [ - "Saving the figure to an object (above) will allow you to cycle through the axes to make panel-specific edits." - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": 6, - "outputs": [ - { - "data": { - "text/plain": "
", - "image/png": "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\n" - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Loop by the axes to draw annotations\n", - "for i,ax in enumerate(fig.axes[:-1]):\n", - " ax.axvline(x=.5, c='cyan', ls=':') # Vertical line at .5\n", - " if i == 2: # label on panel 3\n", - " ax.text(.47, .8, 'Label', c='red', fontweight='bold', ha='right', transform=ax.transAxes)\n", - "fig\n" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "markdown", - "source": [ - "### Querying\n", - "You can query which cycles you wish to plot by using the `query` keyword. `query` accepts two types of inputs:\n", - "1. **List index**: A list of index values\n", - "2. **Slice**: Constructed with `slice()` or `np.s_[]`" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": 7, - "outputs": [ - { - "data": { - "text/plain": "Text(0.5, 0.98, 'Last Cycle')" - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": "
", - "image/png": "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\n" - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": "
", - "image/png": "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\n" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Querying using indexing\n", - "fig = plot_results_panel_2d(cycle,\n", - " query=[0, 2, 4],\n", - " subplot_kw=dict(figsize=(8,3), gridspec_kw={\"bottom\": 0.25})\n", - " );\n", - "fig.supxlabel('x1', y=0.1)\n", - "fig.suptitle('Cycles 0, 2, 4')\n", - "\n", - "# Last Cycle\n", - "fig = plot_results_panel_2d(cycle,\n", - " query=[-1],\n", - " subplot_kw=dict(figsize=(4,4), gridspec_kw={\"bottom\": 0.25})\n", - " );\n", - "fig.supxlabel('x1', y=0.1)\n", - "fig.supylabel('y', y=0.55, x='-.05')\n", - "fig.suptitle('Last Cycle')" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": 8, - "outputs": [ - { - "data": { - "text/plain": "Text(0.5, 0.1, 'x1')" - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": "
", - "image/png": "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\n" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Querying using slicing with the slice() function\n", - "fig = plot_results_panel_2d(cycle,\n", - " query=slice(0,5,2), # (Start, Stop, Step)\n", - " subplot_kw=dict(figsize=(8,3), gridspec_kw={\"bottom\": 0.25})\n", - " );\n", - "fig.supxlabel('x1', y=0.1)" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": 9, - "outputs": [ - { - "data": { - "text/plain": "Text(0.5, 0.98, 'Last 2 Cycles')" - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": "
", - "image/png": "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\n" - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": "
", - "image/png": "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\n" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Querying using slicing with np.s_[]\n", - "fig = plot_results_panel_2d(cycle,\n", - " query=np.s_[0:5:2], # [Start:Stop:Step]\n", - " subplot_kw=dict(figsize=(8,3), gridspec_kw={\"bottom\": 0.25})\n", - " );\n", - "fig.supxlabel('x1', y=0.1)\n", - "fig.suptitle('Cycles 0, 2, 4')\n", - "\n", - "# Last 2 Cycles\n", - "fig2 = plot_results_panel_2d(cycle,\n", - " query=np.s_[-2:], # You can use other list slicing conventions\n", - " subplot_kw=dict(figsize=(8,3), gridspec_kw={\"bottom\": 0.25})\n", - " );\n", - "fig2.supxlabel('x1', y=0.1)\n", - "fig2.suptitle('Last 2 Cycles')" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "markdown", - "source": [ - "## Plotting 3D\n", - "The 3D plotter has similar functionality as the 2D plotter but will only work with problem spaces where there are exactly 2 independent variable values. Only one dependent value can be plotted at a time." - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": 10, - "outputs": [ - { - "data": { - "text/plain": "" - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Simple multiple linear regression cycle\n", - "random.seed(1)\n", - "\n", - "def ground_truth(X):\n", - " return X[:, 0] + (0.5 * X[:, 1]) + 1.0\n", - "\n", - "# Variable Metadata\n", - "study_metadata = VariableCollection(\n", - " independent_variables=[\n", - " Variable(name=\"x\", allowed_values=np.linspace(0, 1, 10)),\n", - " Variable(name=\"y\", allowed_values=np.linspace(0, 1, 10)),\n", - " ],\n", - " dependent_variables=[Variable(name=\"z\", value_range=(-20, 20))],\n", - ")\n", - "\n", - "# Theorist\n", - "lm = LinearRegression()\n", - "\n", - "# Experimentalist\n", - "example_experimentalist = Pipeline(\n", - " [\n", - " (\"pool\", grid_pool),\n", - " (\"sampler\", random_sampler),\n", - " (\"transform\", lambda x: np.array(x)),\n", - " ],\n", - " params={\n", - " \"pool\": {\"ivs\": study_metadata.independent_variables},\n", - " \"sampler\": {\"n\": 10},\n", - " },\n", - ")\n", - "\n", - "# Experiment Runner\n", - "def get_example_synthetic_experiment_runner():\n", - " rng = np.random.default_rng(seed=180)\n", - "\n", - " def runner(xs):\n", - " return ground_truth(xs) + rng.normal(0, 0.25, xs.shape[0])\n", - "\n", - " return runner\n", - "\n", - "example_synthetic_experiment_runner = get_example_synthetic_experiment_runner()\n", - "\n", - "# Initialize Cycle\n", - "cycle_mlr = Cycle(\n", - " metadata=study_metadata,\n", - " theorist=lm,\n", - " experimentalist=example_experimentalist,\n", - " experiment_runner=example_synthetic_experiment_runner,\n", - ")\n", - "cycle_mlr.run(5)" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": 11, - "outputs": [ - { - "data": { - "text/plain": "
", - "image/png": "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\n" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Plot cycle results with each cycle as one panel using defaults\n", - "fig = plot_results_panel_3d(cycle_mlr); # Add semicolon to supress creating two figures in jupyter notebook" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": 12, - "outputs": [ - { - "data": { - "text/plain": "
", - "image/png": "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\n" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Change wrap to 3 and Adjust dimensions\n", - "plot_results_panel_3d(cycle_mlr,\n", - " wrap=3,\n", - " subplot_kw=dict(figsize=(12,6))\n", - " );" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": 13, - "outputs": [ - { - "data": { - "text/plain": "
", - "image/png": "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\n" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Change wrap to 3, Adjust dimensions, adjust scatter plot and line colors, shapes, and sizes\n", - "fig = plot_results_panel_3d(cycle_mlr,\n", - " wrap=3,\n", - " subplot_kw=dict(figsize=(12,6)), # Panel configurations\n", - " scatter_previous_kw=dict(color='rebeccapurple', marker='o', s=10), # Previous data point\n", - " scatter_current_kw=dict(color='limegreen', marker='^', s=10, alpha=1), # Current cycle data\n", - " surface_kw=dict(color='orange'), # Theory surface\n", - " );\n" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "markdown", - "source": [ - "### Change the Viewing Angle\n", - "* You can change the viewing angle by supplying the `view` keyword with a tuple of elevation and azimuth degrees.\n", - "* Azimuth is in reference to the XY plane.\n", - "* Note that the default viewing angle is not a (0,0) elevation, azimuth. In the case above it is (30,-60).\n", - "
\n", - "\n", - "
\n" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": 14, - "outputs": [ - { - "data": { - "text/plain": "
", - "image/png": "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\n" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Change the viewing angle to 0 elevation, 0 azimuth.\n", - "fig = plot_results_panel_3d(cycle_mlr,\n", - " wrap=3,\n", - " subplot_kw=dict(figsize=(12,6)), # Panel configurations\n", - " scatter_previous_kw=dict(color='rebeccapurple', marker='o', s=10), # Previous data point\n", - " scatter_current_kw=dict(color='limegreen', marker='^', s=10, alpha=1), # Current cycle data\n", - " surface_kw=dict(color='orange'), # Theory surface\n", - " view=(0, 0), # Degrees (elevation, azimuth)\n", - " );" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": 15, - "outputs": [ - { - "data": { - "text/plain": "
", - "image/png": "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\n" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Change the viewing angle to +20 elevation, +60 azimuth\n", - "fig = plot_results_panel_3d(cycle_mlr,\n", - " wrap=3,\n", - " subplot_kw=dict(figsize=(12,6)), # Panel configurations\n", - " scatter_previous_kw=dict(color='rebeccapurple', marker='o', s=10), # Previous data point\n", - " scatter_current_kw=dict(color='limegreen', marker='^', s=10, alpha=1), # Current cycle data\n", - " surface_kw=dict(color='orange'), # Theory surface\n", - " view=(20, 60), # Degrees (elevation, azimuth)\n", - " );\n" - ], - "metadata": { - "collapsed": false - } - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 2 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython2", - "version": "2.7.6" - } - }, - "nbformat": 4, - "nbformat_minor": 0 -} diff --git a/docs/cycle/cycle_scoring.ipynb b/docs/cycle/cycle_scoring.ipynb deleted file mode 100644 index ee048bd39..000000000 --- a/docs/cycle/cycle_scoring.ipynb +++ /dev/null @@ -1,420 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "source": [ - "# Scoring\n", - "This notebook shows how to use autora.cycle scoring tools.\n", - "\n", - "We'll be using the [Iris toy dataset](https://scikit-learn.org/stable/datasets/toy_dataset.html#iris-plants-dataset) from sklearn to create a simple logistic regression cycle. This model will classify samples into different species of irises based on flower measurements. The dataset will be split between a training set and test set; the test set will be withheld for the scoring metrics." - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": [ - "# Uncomment the following line when running on Google Colab\n", - "# !pip install autora" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "import random\n", - "import numpy as np\n", - "from sklearn.linear_model import LogisticRegression\n", - "from sklearn.model_selection import train_test_split\n", - "import sklearn.pipeline as skp\n", - "from sklearn.preprocessing import StandardScaler\n", - "from sklearn.metrics import f1_score, accuracy_score, precision_score, recall_score, roc_auc_score\n", - "from sklearn.datasets import load_iris\n", - "from functools import partial\n", - "\n", - "from autora.variable import VariableCollection, Variable\n", - "from autora.experimentalist.sampler import random_sampler\n", - "from autora.experimentalist.pipeline import Pipeline\n", - "from autora.cycle import Cycle, cycle_default_score, cycle_specified_score, plot_cycle_score" - ] - }, - { - "cell_type": "markdown", - "source": [ - "### Importing Data\n", - "Data is split where 33% is reserved for testing." - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": 2, - "outputs": [], - "source": [ - "# Import and split data\n", - "X, y = load_iris(return_X_y=True)\n", - "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=.33, random_state=1)" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "markdown", - "source": [ - "### Cycle Setup\n", - "1. **Theorist** - Uses sklearn's `Pipeline` to create a logistic regression estimator with a scaling pre-processing step.\n", - "2. **Experimentalist** - Uses autora's `Pipeline` to create a random sampling experimentalist with the training dataset's independent variables (`X_train`) as the condition pool.\n", - "3. **Experiment Runner** - Creates an oracle that uses the full dataset to match experimental independent variables (flower measurements) and returns the dependent variable (species)." - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": 3, - "outputs": [ - { - "data": { - "text/plain": "" - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Set up cycle and run\n", - "# Variable Metadata\n", - "random.seed(1)\n", - "study_metadata = VariableCollection(\n", - " independent_variables=[\n", - " Variable(name='sepal length', units='cm', value_range=(4.3, 7.9)),\n", - " Variable(name='sepal width', units='cm', value_range=(2.0, 4.4)),\n", - " Variable(name='petal length', units='cm', value_range=(1.0, 6.9)),\n", - " Variable(name='petal width', units='cm', value_range=(0.1, 2.5)),\n", - " ],\n", - " dependent_variables=[Variable(name=\"species\", allowed_values=[0,1,2])],\n", - ")\n", - "\n", - "# Theorist\n", - "clf = skp.Pipeline([('scaler', StandardScaler()), ('lr', LogisticRegression())])\n", - "\n", - "# Experimentalist\n", - "# Note that the pool is only the training split\n", - "experimentalist = Pipeline(\n", - " [\n", - " (\"pool\", X_train),\n", - " (\"sampler\", random_sampler),\n", - " ],\n", - " params={\n", - " \"sampler\": {\"n\": 5},\n", - " },\n", - " )\n", - "\n", - "# Experiment Runner\n", - "def oracle(xs, X_truth, y_truth):\n", - " l_idx = []\n", - "\n", - " for condition in xs:\n", - " l_idx.append(np.where((X_truth[:,0] == condition[0]) &\n", - " (X_truth[:,1] == condition[1]) &\n", - " (X_truth[:,2] == condition[2]) &\n", - " (X_truth[:,3] == condition[3]))[0][0]\n", - " )\n", - "\n", - " l_return = y_truth[l_idx].ravel()\n", - " return l_return\n", - "\n", - "experiment_runner = partial(oracle, X_truth=X, y_truth=y)\n", - "\n", - "cycle = Cycle(\n", - " metadata=study_metadata,\n", - " theorist=clf,\n", - " experimentalist=experimentalist,\n", - " experiment_runner=experiment_runner\n", - ")\n", - "\n", - "# Run cycle 20 times\n", - "cycle.run(20)" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "markdown", - "source": [ - "### Scoring Metrics\n", - "We can score the models in two ways:\n", - "1. Estimator's default scoring metric - Sklearn estimators have a default scoring method.\n", - " -`LogisticRegression()` default is [accuracy_score](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.accuracy_score.html#sklearn.metrics.accuracy_score)\n", - "2. Scoring functions - Sklearn has many available [scoring functions](https://scikit-learn.org/stable/modules/model_evaluation.html#the-scoring-parameter-defining-model-evaluation-rules). It is up to the user to determine what is compatible with their model.\n", - "\n", - "Autora has two functions to return scoring metrics of each cycle:\n", - "1. `cycle_default_score` - Uses the estimator's default\n", - "2. `cycle_specified_score` - Uses the one of Sklearn's scoring functions\n", - "\n" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": 4, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Default scorer - accuracy: [0.74, 0.8, 0.84, 0.86, 0.88, 0.84, 0.84, 0.84, 0.92, 0.94, 0.9, 0.92, 0.96, 0.96, 0.96, 0.96, 0.96, 0.98, 0.96, 0.96]\n", - "\n", - "Specified scorer - accuracy: [0.74, 0.8, 0.84, 0.86, 0.88, 0.84, 0.84, 0.84, 0.92, 0.94, 0.9, 0.92, 0.96, 0.96, 0.96, 0.96, 0.96, 0.98, 0.96, 0.96]\n", - "\n", - "Specified scorer - precision: [0.77, 0.82, 0.85, 0.87, 0.9, 0.87, 0.87, 0.86, 0.93, 0.94, 0.91, 0.93, 0.96, 0.96, 0.96, 0.96, 0.96, 0.98, 0.96, 0.96]\n" - ] - } - ], - "source": [ - "results_default = cycle_default_score(cycle, X_test, y_test)\n", - "print(f'Default scorer - accuracy: {results_default}\\n')\n", - "\n", - "results_specified_accuracy = cycle_specified_score(accuracy_score, cycle, X_test, y_test)\n", - "print(f'Specified scorer - accuracy: {results_specified_accuracy}\\n')\n", - "\n", - "results_specified_precision = cycle_specified_score(precision_score, cycle, X_test, y_test, average='weighted', zero_division=0)\n", - "print(f'Specified scorer - precision: {np.around(results_specified_precision, 2).tolist()}')" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "markdown", - "source": [ - "Note that the \"default scorer\" and \"specified scorer 1\" results should be the same because the `LogisticRegression` estimator's default is the `accuracy_score` function." - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "markdown", - "source": [ - "### Plotting\n", - "These scores can be plotted using autora's `plot_cycle_score`.\n", - "* The plotter will use the estimator's default scorer unless a `scorer` keyword is supplied with a sklearn scoring function.\n", - "* Additional parameters for scoring functions are supplied with the `scorer_kw` as a dictionary.\n", - "\n", - "Below are several examples." - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": 5, - "outputs": [ - { - "data": { - "text/plain": "
", - "image/png": "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\n" - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": "
", - "image/png": "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\n" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Default\n", - "plot_cycle_score(cycle, X_test, y_test,\n", - " figsize=(5,3));\n", - "# Specifying Scorer - Plots should be the identical.\n", - "plot_cycle_score(cycle, X_test, y_test,\n", - " scorer=accuracy_score,\n", - " figsize=(5,3));" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": 6, - "outputs": [ - { - "data": { - "text/plain": "
", - "image/png": "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\n" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Precision\n", - "plot_cycle_score(cycle, X_test, y_test,\n", - " scorer=precision_score,\n", - " figsize=(5,3),\n", - " scorer_kw=dict(average='weighted', zero_division=0));" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": 7, - "outputs": [ - { - "data": { - "text/plain": "
", - "image/png": "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\n" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Recall\n", - "plot_cycle_score(cycle, X_test, y_test,\n", - " scorer=recall_score,\n", - " figsize=(5,3),\n", - " scorer_kw=dict(average='weighted'));" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": 8, - "outputs": [ - { - "data": { - "text/plain": "
", - "image/png": "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\n" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# F1\n", - "plot_cycle_score(cycle, X_test, y_test,\n", - " scorer=f1_score,\n", - " figsize=(5,3),\n", - " scorer_kw=dict(average='weighted'));" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": 9, - "outputs": [ - { - "data": { - "text/plain": "
", - "image/png": "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\n" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# ROC Area Under Curve\n", - "plot_cycle_score(cycle, X_test, y_test,\n", - " scorer=roc_auc_score,\n", - " figsize=(5,3),\n", - " scorer_kw=dict(average='weighted', multi_class='ovr'));" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": 10, - "outputs": [ - { - "data": { - "text/plain": "Text(0.5, 1.0, 'Accuracy Over 20 Cycles')" - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": "
", - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAdMAAAE8CAYAAACb7Fv6AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAABhvElEQVR4nO3deVhU1f8H8PfMMAub7IsguwqiiIqKa+5RGi6poZkLlpVfSY3S1FwzsyzNMstv5VZfzX3NRJHcF1AREcEFAVFkV2SHYeb8/uDHhXEGZGBgBvi8nofn8Z67zHtG4MO995xzeYwxBkIIIYTUGV/bAQghhJCmjoopIYQQUk9UTAkhhJB6omJKCCGE1BMVU0IIIaSeqJgSQggh9UTFlBBCCKknKqaEEEJIPVExJYQQQuqJiikhhDSQpKQk8Hg8bNu2TdtRSAOjYkp0ys8//wwejwdfX19tR2mSkpOT8eGHH8LZ2RlisRjW1tYYPXo0Ll68qO1oSrKzs/Htt9/ilVdegZWVFUxNTdGrVy/s3r1b5fYlJSX47LPPYGdnB319ffj6+iI0NFSt1zxz5gzefPNN2NraQiQSwdraGv7+/jhw4IAm3hJpwaiYEp2yY8cOODs7IyIiAvHx8dqO06RcvHgRXl5e+OuvvzB27Fj8/PPPmDNnDm7fvo3+/ftjw4YN2o6o4PLly/j8889hbm6OxYsXY9WqVTAwMMCECROwbNkype2nTZuGdevWYdKkSfjhhx8gEAgwfPhwXLhwoVavt2zZMgwaNAgxMTH44IMPsGnTJsybNw/5+fkYO3Ysdu7cqem3SFoSRoiOSEhIYADYgQMHmJWVFVu+fLm2I1UrPz9f2xEUPH36lNna2jIbGxsWHx+vsK6wsJD179+f8fl8dvHixUbNVVRUxGQymcp1CQkJLCkpSaFNLpezwYMHM7FYrPAZh4eHMwDs22+/VTi2m5sb692790tz7N27lwFg48aNY6WlpUrrQ0JC2NGjR2v7tmotMTGRAWBbt27V+LGJbqFiSnTGypUrmZmZGSspKWEzZ85k7dq1U7nds2fP2Ny5c5mTkxMTiUTM3t6eTZ48mWVmZnLbFBUVsWXLlrF27doxsVjMbG1t2ZgxY7hCc/r0aQaAnT59WuHYqn75TZ06lRkaGrL4+Hj2+uuvMyMjIzZq1CjGGGPnzp1j48aNYw4ODkwkErE2bdqwuXPnssLCQqXccXFxbPz48czS0pJJJBLWvn17tmjRIsYYY//++y/3h8SLduzYwQCwS5cuVfvZrV69mgFgf/zxh8r1CQkJTCAQMD8/P8YYY1evXmUA2LZt25S2DQkJYQAUisvjx49ZYGAgs7a2ZiKRiHl6erLNmzcr7Ffxmf7111/s888/Z3Z2dozH47Fnz55Vm1uVH3/8kQFg0dHRXNu8efOYQCBgz58/V9j2q6++YgBYcnJyjcf08PBg5ubmLDc3t8bt8vLymIGBAZs9e7bSukePHjE+n8+++uorru1l34vVFdO4uDg2duxYZmZmxsRiMfPx8WGHDx9W2Ka0tJQtX76ctW3blonFYmZubs769u3LTp48WeN7INqhp4WTYUJU2rFjB958802IRCJMnDgRv/zyC65evYoePXpw2+Tn56N///6Ii4vD9OnT0a1bN2RlZeHIkSN4/PgxLC0tIZPJ8MYbbyAsLAwTJkzAnDlzkJeXh9DQUMTExMDNzU3tbGVlZfDz80O/fv3w3XffwcDAAACwd+9eFBYWYubMmbCwsEBERAQ2bNiAx48fY+/evdz+0dHR6N+/P4RCId5//304OzvjwYMHOHr0KFatWoWBAwfCwcEBO3bswJgxY5Q+Fzc3N/Tu3bvafEePHoVEIsFbb72lcr2Liwv69euHf//9F0VFRejevTtcXV2xZ88eTJ06VWHb3bt3w8zMDH5+fgCA9PR09OrVCzweD0FBQbCyssLx48fx7rvvIjc3F3PnzlXYf+XKlRCJRPj0009RUlICkUhU688ZANLS0gAAlpaWXNuNGzfQvn17tGrVSmHbnj17AgCioqLg4OCg8nj379/HnTt3MH36dBgbG9f42kZGRhgzZgx2796NdevWQSAQcOv++usvMMYwadIkALX7XlTl9u3b6Nu3L+zt7bFgwQIYGhpiz549GD16NPbv38/9/y9fvhyrV6/Ge++9h549eyI3NxfXrl1DZGQkhg0bVuP7IFqg7WpOCGOMXbt2jQFgoaGhjLHyy31t2rRhc+bMUdhu6dKl1Z7ByeVyxhhjW7ZsYQDYunXrqt1G3TNTAGzBggVKx1N1Brp69WrG4/HYw4cPubZXXnmFGRsbK7RVzcMYYwsXLmRisZjl5ORwbRkZGUxPT48tW7ZM6XWqMjU1Zd7e3jVuM3v2bIUzvoULFzKhUMiePn3KbVNSUsJMTU3Z9OnTubZ3332XtW7dmmVlZSkcb8KECczExIT7DCo+U1dXV5WfS21kZ2cza2tr1r9/f4X2jh07ssGDByttf/v2bQaAbdq0qdpjHj58mAFg33//fa0ynDhxggFgx48fV2jv3LkzGzBgALdcm+9FVd9PQ4YMYV5eXqy4uFhh+z59+ihcjfH29mYjRoyoVWaifdQBieiEHTt2wMbGBoMGDQIA8Hg8BAQEYNeuXZDJZNx2+/fvh7e3t9LZW8U+FdtYWlrio48+qnabupg5c6ZSm76+PvfvgoICZGVloU+fPmCM4caNGwCAzMxMnDt3DtOnT4ejo2O1eaZMmYKSkhLs27ePa9u9ezfKysrwzjvv1JgtLy/vpWddFetzc3MBAAEBAZBKpQo9WU+ePImcnBwEBAQAABhj2L9/P/z9/cEYQ1ZWFvfl5+eH58+fIzIyUuF1pk6dqvC51JZcLsekSZOQk5Oj1FmqqKgIYrFYaR+JRMKtr07F+33Z51Nh6NChsLOzw44dO7i2mJgYREdHK/w/1OZ78UVPnz7Fv//+i7feegt5eXncZ5mdnQ0/Pz/cv38fKSkpAABTU1Pcvn0b9+/fr1Vuol1UTInWyWQy7Nq1C4MGDUJiYiLi4+MRHx8PX19fpKenIywsjNv2wYMH6NSpU43He/DgAdzd3aGnp7m7GHp6emjTpo1Se3JyMqZNmwZzc3MYGRnBysoKAwYMAAA8f/4cAJCQkAAAL83t4eGBHj16KPwS37FjB3r16oW2bdvWuK+xsTHy8vJq3KZifUVR8fb2hoeHh8JQlN27d8PS0hKDBw8GUP6HQE5ODn799VdYWVkpfAUGBgIAMjIyFF7HxcWlxhzV+eijjxASEoLff/8d3t7eCuv09fVRUlKitE9xcTG3vjoVl4Zf9vlU4PP5mDRpEg4dOoTCwkIA5f8PEokE48eP57arzffii+Lj48EYw5IlS5Q+z4oezBWf5xdffIGcnBy0b98eXl5emDdvHqKjo9V6PdJ46J4p0bp///0Xqamp2LVrF3bt2qW0fseOHXj11Vc1+prVnTlUPQuuSiwWg8/nK207bNgwPH36FJ999hk8PDxgaGiIlJQUTJs2DXK5XO1cU6ZMwZw5c/D48WOUlJTgypUr+Omnn166X4cOHXDjxg2UlJSoPIMDyu/bCoVCtGvXjmsLCAjAqlWrkJWVBWNjYxw5cgQTJ07k/hCpeA/vvPOO0r3VCp07d1ZYrstZ6YoVK/Dzzz/j66+/xuTJk5XWt27dmjtjqyo1NRUAYGdnV+2xPTw8AAC3bt2qdZ4pU6bg22+/xaFDhzBx4kTs3LkTb7zxBkxMTGp9DFUqPs9PP/2Uuyf9ooo/nF555RU8ePAAhw8fxsmTJ/H777/j+++/x6ZNm/Dee+/VKwfRPCqmROt27NgBa2trbNy4UWndgQMHcPDgQWzatAn6+vpwc3NDTExMjcdzc3NDeHg4pFIphEKhym3MzMwAADk5OQrtDx8+rHXuW7du4d69e9i+fTumTJnCtb84kYCrqysAvDQ3AEyYMAHBwcH466+/UFRUBKFQyF1yrckbb7yBy5cvY+/evSovCSclJeH8+fMYOnSoQrELCAjAihUrsH//ftjY2CA3NxcTJkzg1ltZWcHY2BgymQxDhw59aY662LhxI5YvX465c+fis88+U7lNly5dcPr0aeTm5ip0QgoPD+fWV6d9+/Zwd3fH4cOH8cMPP8DIyOilmTp16oSuXbtix44daNOmDZKTk5UuPdfme/FFFd8LQqGwVp+nubk5AgMDERgYiPz8fLzyyitYvnw5FVNdpN1btqSlKywsZMbGxgodXqq6ePEiA8B27drFGNNcB6ScnBwmEAjYxx9/rLB+7Nix1Q6NeVF0dLTS8BK5XM5GjBihdIzadECqMHLkSNa5c2fWvn175u/vr7RelaysLGZtbc1sbW3ZgwcPFNYVFRWxgQMHVjvO1MvLiw0aNIhNmDCBtW7dWmlc6LRp05hIJGK3bt1S2jcjI4P7d0UHpL1799YqM2OM7dq1i/H5fDZp0iSVn0WFK1euKI0zLS4uZm3btmW+vr61eh0ALCAggEmlUqX1J06cUBpnum7dOqanp8fGjBnDLCwslMan1rUD0sCBA5m5uTl78uSJ0n5VP88XO3wxxrihVUT30Jkp0aojR44gLy8PI0eOVLm+V69esLKywo4dOxAQEIB58+Zh3759GD9+PKZPnw4fHx88ffoUR44cwaZNm+Dt7Y0pU6bgjz/+QHBwMCIiItC/f38UFBTg1KlT+M9//oNRo0bBxMQE48ePx4YNG8Dj8eDm5oa///5b6f5fTTw8PODm5oZPP/0UKSkpaNWqFfbv349nz54pbfvjjz+iX79+6NatG95//324uLggKSkJx44dQ1RUlMK2U6ZMwbhx4wCUDzOpDQsLC+zbtw8jRoxAt27d8N5778HT0xNpaWnYtm0b4uPj8cMPP6BPnz5K+wYEBGDp0qWQSCR49913lS5nf/311zh9+jR8fX0xY8YMeHp64unTp4iMjMSpU6fw9OnTWn5iiiIiIjBlyhRYWFhgyJAhCveKAaBPnz7cmZyvry/Gjx+PhQsXIiMjA23btsX27duRlJSEzZs3v/S1AgICcOvWLaxatQo3btzAxIkT4eTkhOzsbISEhCAsLExpBqS3334b8+fPx8GDBzFz5kylqxy1+V5UZePGjejXrx+8vLwwY8YMuLq6Ij09HZcvX8bjx49x8+ZNAICnpycGDhwIHx8fmJub49q1a9i3bx+CgoJq/RmTRqTtak5aNn9/fyaRSFhBQUG120ybNo0JhULuL/Xs7GwWFBTE7O3tuYkSpk6dqvCXfGFhIfv888+Zi4sLEwqFzNbWlo0bN07hrC0zM5ONHTuWGRgYMDMzM/bBBx+wmJiYWp+ZMsZYbGwsGzp0KDMyMmKWlpZsxowZ7ObNmyoH6sfExLAxY8YwU1NTJpFImLu7O1uyZInSMUtKSpiZmRkzMTFhRUVFtfkYOYmJiWzGjBnM0dGRCYVCZmlpyUaOHMnOnz9f7T73799nABgAduHCBZXbpKens1mzZjEHBwfu8xwyZAj79ddfuW3UPTPdunUr97qqvl78/IqKitinn37KbG1tmVgsZj169GAhISG1eq0KYWFhbNSoUcza2prp6ekxKysr5u/vrzRhQoXhw4fXOGHGy74Xq5u04cGDB2zKlCnM1taWCYVCZm9vz9544w22b98+bpsvv/yS9ezZk5mamjJ9fX3m4eHBVq1apXIGJ6J9PMYY00YRJ4SoVlZWBjs7O/j7+9fqrIs0nDFjxuDWrVs0TzR5KRoaQ4iOOXToEDIzMxU6NZHGl5qaimPHjqnsXUzIi+jMlBAdER4ejujoaKxcuRKWlpZKkyGQxpGYmIiLFy/i999/x9WrV/HgwQPY2tpqOxbRcXRmSoiO+OWXXzBz5kxYW1vjjz/+0HacFuvs2bOYPHkyEhMTsX37diqkpFa0WkzPnTsHf39/2NnZgcfj4dChQy/d58yZM+jWrRvEYjHatm2r8gn2GzduhLOzMyQSCXx9fREREaH58IRo2LZt21BWVoZr166pPbMO0Zxp06aBMYaHDx9yvaoJeRmtFtOCggJ4e3urHKyvSmJiIkaMGIFBgwYhKioKc+fOxXvvvYcTJ05w2+zevRvBwcFYtmwZIiMj4e3tDT8/P7WGPBBCCCHq0Jl7pjweDwcPHsTo0aOr3eazzz7DsWPHFGYdmTBhAnJychASEgKgfDxajx49uCnY5HI5HBwc8NFHH2HBggUN+h4IIYS0TE3qnunly5eVpuDy8/PD5cuXAQClpaW4fv26wjZ8Ph9Dhw7ltlGlpKQEubm53Nfz58+RmZkJHfk7gxBCiI5rUjMgpaWlwcbGRqGtYj7RoqIiPHv2DDKZTOU2d+7cqfa4q1evxooVK5Tad+7cyT0EmhBCSMs0atSol27TpIppQ1m4cCGCg4O55dzcXDg4OGDQoEGwsLDQYrLqSaVShIaGYtiwYdVO5q5tup5R1/MBlFFTKGP96Xo+QLsZm1QxtbW1RXp6ukJbeno6WrVqBX19fQgEAggEApXb1NS9XSwWq3xslVAo1NlvmgqUsf50PR9AGTWFMtafrucDtJOxSd0z7d27t8KDooHyx1317t0bACASieDj46OwjVwuR1hYGLcNIYQQomlaLab5+fmIiorinpqRmJiIqKgoJCcnAyi//Fp1SrUPP/wQCQkJmD9/Pu7cuYOff/4Ze/bswccff8xtExwcjN9++w3bt29HXFwcZs6ciYKCAgQGBjbqeyOEENJyaPUy77Vr1zBo0CBuueK+5dSpU7Ft2zakpqZyhRUAXFxccOzYMXz88cf44Ycf0KZNG/z+++8KT6wPCAhAZmYmli5dirS0NHTp0gUhISFKnZIIIYQQTdFqMR04cGCNw09UzW40cOBA3Lhxo8bjBgUF0TP/CCGENJomdc+UEEII0UVUTAkhhJB6omJKCCGE1BMVU0IIIaSeqJgSQggh9UTFlBBCCKknKqaEEEJIPVExJYQQQuqJiikhhBCteJ5ZhDKpTNsxNKJJPTWGEEJI01daXIbQLbFIis6C2EAPQwM94exlqe1Y9UJnpoQQQhpN/rMSHPguEknRWQCAksIy/PNzNGLOpWg5Wf3QmSkhhJBGkfU4H8c23kT+sxKFdsaAszvvIjerCL1Hu4HH52kpYd1RMSWEENLgkmOzEfJrDKTFlfdI9cQClJVULt84mYy8p8UYMrUD9IQCbcSsM7rMSwghpEHFXnyCYz9FKxRSC3sjTFrui95j3BS2jb+WgSM/RKE4X9rYMeuFiikhhJAGwRhD+JEEnP7zDuTyysdtOnQww5ufdoORmQTd/Jzw6nsdIdCrLEep8c+x/9vreJ5ZqI3YdULFlBBCiMbJyuQ4tS0W1/5JUmjv0Kc1RgR5Q6RfeZexXXcbjJzbBWLDyrac9ELsX3MdaQnPGytyvVAxJYQQolHFBVIc/TEK98LTFdp9R7pg0GQPCATKpceurSnGze+OVpYSrq0oT4pD399Awo3MBs9cX1RMCSGEaExuVhEOfHsdKfdyuDa+gIehgZ7oPtwFPF71PXVNbQwwdn532Li04tpkUjmO/3oLN8MeNWTseqNiSgghRCMyHuZi35rreJZWea9TpK8H/9ld4O5rW6tjGLQSYdTHXeHaxaqykQEX9t7H+d33FO696hIqpoQQQuotKToLB9dGoii3lGszNpdg7DwftHE3U+tYQpEAfu93gvdgB4X26NOPEfLfW5CW6t4UhFRMCSGE1EvM2cf455dolJXKuTYrR2OM/cwH5naGdTomn89Dv7faod9b7YAqV4YTb2bh0LobKKxStHUBFVNCCCF1wuQMF/fH4+xf98CqXH119rLA6OCuMDQR1/s1vAc74PUPvKAnrCxXGUm52L/mGp6lFdT7+JpCxZQQQojayqQynPj9NqJCkxXaO71ij9c/9IJIorkJ9ly7WGFUcFfoGwu5ttysYuxfcx1P7udo7HXqg4opIYQQtRTll+Lw91F4EJmh0N77TTe8MrE9+CqGvtSXrYsJxs7vDlMbA66tpLAMh3+4gftX02vYs3FQMSWEEFJrzzOLlCZTEOjx8ep7HdHtVacah77Ul4mVPsbO90HrtiZcm7yM4eTm27gekgTGtNfTl4opIYSQWil5xsfhdVF4nlHEtUkMhRg1twvadbdplAwSQyFGzumCdt2tFdqvHErA+d3xYPJqdmxg9NQYQkizVlJUhjtXUpH7QIQbJ5LBF+jm00jkMplOZywpkiIzwgCQl3FtrSwl8P+oi8Kl18agJxRg2PSOMLbQR+SJh1z7nYtpEFvo44ZQs59h99edX55JY69GCCE6hskZjm28idT45wDEuHrv4Uv30S5dz1h5CdfGpRVG/Kcz9I1F2knC56H3GDcYW0hw7q+7XG/ikmw9XP1bs58hFVNCSIt250rq/xdSokmuXa0wLNATeiLtn0F3esUeRmZinPj9tsKzURsb3TMlhDRLpcVluHIoQdsxmhW+UI5urzvCb0YnnSikFZy9LPHmJ91g69bq5Rs3EDozJYQ0S9ePP1SYJadVuxJMmD0UQqGwhr20RyqV4p9//sHw4cN1MmNFvu7DncDnN1yP3bqycjTGyLneWvsM6cyUENLsPM8sQlRY5WQCRuZiGLvo1vRzpHmhYkoIaXYuH4iHvKxyzGGv0S7g6c5VSdIMab2Ybty4Ec7OzpBIJPD19UVERES120qlUnzxxRdwc3ODRCKBt7c3QkJCFLZZvnw5eDyewpeHh0dDvw1CiI5IufcMD6o8TLp1WxO4dLHUYiLSEmi1mO7evRvBwcFYtmwZIiMj4e3tDT8/P2RkZKjcfvHixfjvf/+LDRs2IDY2Fh9++CHGjBmDGzduKGzXsWNHpKamcl8XLlxojLdDCNEyuZzh/J77lQ08oP9b7Rt0Vh5CAC0X03Xr1mHGjBkIDAyEp6cnNm3aBAMDA2zZskXl9n/++ScWLVqE4cOHw9XVFTNnzsTw4cOxdu1ahe309PRga2vLfVla0l+lhLQEcRefIPtxPrfcoU9rWDkaazERaSm01pu3tLQU169fx8KFC7k2Pp+PoUOH4vLlyyr3KSkpgUQiUWjT19dXOvO8f/8+7OzsIJFI0Lt3b6xevRqOjo7VZikpKUFJSQm3nJubC6D8srJUKlX7vTWGily6mg/Q/Yy6ng+gjOooLSrDlcOVQ2GEEgF8hjsq/BxrO2NNdD2jrucDGi5jbXoG85iWZgZ+8uQJ7O3tcenSJfTu3Ztrnz9/Ps6ePYvw8HClfd5++23cvHkThw4dgpubG8LCwjBq1CjIZDKuGB4/fhz5+flwd3dHamoqVqxYgZSUFMTExMDYWPVfqMuXL8eKFSuU2nfu3AkDg8adJosQUjc5d8TIT6ycjadV+xK0cqMevKT+Ro0a9dJtmlQxzczMxIwZM3D06FHweDy4ublh6NCh2LJlC4qKipS2B4CcnBw4OTlh3bp1ePfdd1Vuo+rM1MHBAampqbCwsKjnO20YUqkUoaGhGDZsmE6OSQN0P6Ou5wMoY209zyjC3q+uQy4r/3VmbCnBW4t8IPj/B0rrQsaX0fWMup4PaLiMtTmW1i7zWlpaQiAQID1d8Tl06enpsLW1VbmPlZUVDh06hOLiYmRnZ8POzg4LFiyAq6trta9jamqK9u3bIz4+vtptxGIxxGLlJ8ILhUKd/aapQBnrT9fzAZTxZcIPx3GFFAD6jW0HiQH9TDcEXc8HaCej1jogiUQi+Pj4ICwsjGuTy+UICwtTOFNVRSKRwN7eHmVlZdi/f3+Np+D5+fl48OABWrdurbHshBDd8SjuKZKis7hle3dTGgpDGp1We/MGBwfjt99+w/bt2xEXF4eZM2eioKAAgYGBAIApU6YodFAKDw/HgQMHkJCQgPPnz+O1116DXC7H/PnzuW0+/fRTnD17FklJSbh06RLGjBkDgUCAiRMnNvr7I4Q0LLlMjgt7K4fC8HhAv/E0FIY0Pq3OzRsQEIDMzEwsXboUaWlp6NKlC0JCQmBjU/6Q2eTkZPD5lfW+uLgYixcvRkJCAoyMjDB8+HD8+eefMDU15bZ5/PgxJk6ciOzsbFhZWaFfv364cuUKrKysGvvtEUIa2O3zT/D0SQG37NnPDpZtjLSYiLRUWp/oPigoCEFBQSrXnTlzRmF5wIABiI2NrfF4u3bt0lQ0QogOKy6QIuJoIrcs0teD78jq+08Q0pC0Pp0gIaTxJMdm49S2WNy/mv7yjXXctWNJKC6oHE/YY4Sz1h5UTYjWz0wJIQ2PMYYbJ5Nx+eADAMDdK2kQG+jBsaNuDv16mWdpBbh15jG3bGpjAK+BbbSYiLR0dGZKSDMnl8lx9q97XCGtcGHvfchkci2lqp+L++Ihl1cOhek7ti0EevTrjGgPffcR0oyVFpfhn19u4fa5FKV1z9IKVbbruoe3s/EwJptbdvA0h5NX0zzDJs0HFVNCmqmCnBIcXBupUHh4fB70xJUP9ow4mojifN2da/VFMpkcF6sOheHz0HdcWxoKQ7SOiikhzVD2k3zs++Yash5VPkFFTyzAiP90Rq8qPV5LCssQ8XeiqkPopJizKXiWVsgtd+pvBws7GgpDtI+KKSHNzOM7T3Hg20jkP6ucb9rARIQ3P+kGp04W6DTQHqY2lQ9wiDmXguwn+aoOpVOK86W4WqXwiw300NOfhsIQ3UDFlJBm5M6VVBzdcBOlRWVcm7mdIcZ91p17rqdAwEffcW259UzOcHFfPLT0zItaiziagJLCyvfV4w0XSIx0e45Y0nJQMSWkGWCM4eqxRIRtU5zwvY2HGd6c5wNjc8XnADt7WcKxozm3/Cj2KR7eyoauyn6Sj5jzT7hlM1sDdBpgr8VEhCiiYkpIEycrk+PfP+IUZgMCAI9etngjyBtifdXDyfuOawcev7LjzoV99yEr072hMowxXNx7H6zqUJjx7SAQ0K8vojvou5GQJqykqAx//3QTdy6nKbT3eMMFg6d2qHHspXlrQ3hVObt7nlGkMBGCrki6lY1Hcc+4ZadOFnBqopNNkOaLiikhTVTe02Ic+PY6Ht+pLDR8Pg+Dp3RAzzdcajVcpMcbLhAbVp65Xj2WhKK80gbJWxeyMjku7qscCsP//6EwhOiaehXT4uJiTeUghKghMzkP+765pvDEFJFEgDc+8kaHPrV/dq/EUAjfKj1iS4vKEH5Ud4bK3DrzGM8zirhlr4FtYGZrqMVEhKimdjGVy+VYuXIl7O3tYWRkhISEBADAkiVLsHnzZo0HJIQoehiTjYNrI1H4vPIM0shMjDfn+cChg3kNe6rWsb8dzO0qC1Ts+RRkPdb+UJmivFJcPZbELUsMheg+wllreQipidrF9Msvv8S2bduwZs0aiESVT2jo1KkTfv/9d42GI4Qoun0+Bcd+joa0RMa1WToYYdxn3WFhX7fJC/gCPvqNa8ctM1Y+b6+2h8qEH0lQGOLT098FEkMaCkN0k9rF9I8//sCvv/6KSZMmQSConJbM29sbd+7c0Wg4Qkg5Jme4fOgBzuy4q9Cr1bGjOcZ80g2GpuJ6Hd/B0xzOnS255ZS7z5B4M6tex6yPrMf5iL1QORTG3M4QHfvbaS0PIS+jdjFNSUlB27bKHQDkcjmk0qYzxychTQWTAf/+cReRIQ8V2j3722HEfzpDJNHMkxT7jm0LvqCy09LF/fGQSRt/qAxjDBf23kPVE+N+49uBT0NhiA5T+7vT09MT58+fV2rft28funbtqpFQhJByxQVSZF7Vx4PrmQrtvUa7YuDb7hotMKY2Bug8qPKZoLmZRbj57yONHb+2EqOykHI3h1t27mxZp3vBhDQmtf+kXbp0KaZOnYqUlBTI5XIcOHAAd+/exR9//IG///67ITIS0iKVFEpx5PubKH1W+WPK1+NhyNQOaN/DtkFes/sIF9wNT0NRXvlVpmvHk+DRuzUMWolesqdmlBSV4eL+KkNhBDz0HUtDYYjuU/vP2lGjRuHo0aM4deoUDA0NsXTpUsTFxeHo0aMYNmxYQ2QkpEW6cTIZOemVw0LEBnoYNadLgxVSABDrK04eLy2W4crhBzXsoTl5T4tx8LvryM2qHHLXebCDwqT8hOgqtc5My8rK8NVXX2H69OkIDQ1tqEyEEACJ0ZUdgAxMRBj9cddGGWPp2c8OMWdTkJ1SPjwm7lIqvAa04SbKbwiZj/Jw7KebKKgy3MfARITuw50b7DUJ0SS1zkz19PSwZs0alJWVvXxjQkid5T0tVpiQwaO3baNNVsDn89DvrcqhMmDA+T33GmyozMPb2Tj4XaRCITUyE2Pk7C7VzitMiK5R+zLvkCFDcPbs2YbIQgj5f8m3FZ/g4uBp1qiv38bdDK5drLjl1PjneBCZWcMedXP7fAqObVQcN2vRxghj59d93Cwh2qD2n32vv/46FixYgFu3bsHHxweGhop/LY8cOVJj4QhpqR7GVBZTvlAOK6eGu8RanT5j2yIpJgvysvIz0ksH4uHc2QJ6QsFL9nw5xhjCDyfg+gvDfRw7msNvRieNDfchpLGo/R37n//8BwCwbt06pXU8Hg8ymUypnRBSezKpXGHyerGlDHz+yyet1zQTK310GeKAyBPJAIC87GJEnXqE7q871+u4MqkcYX/E4f7VdIV2z352eGVie3q0GmmS6jQ3b3VfVEgJqb8nD3IULnvqW2mvj4LP687QrzIs5nrIQxTklNT5eMUFUhz5MUqpkPYa7YqBk9ypkJImi75zCdExyVUu8YIHiK2090eqSKKHXqMqh8qUlchw5VDdhsrkZhXhwLfX8eR+DtfG1+Nh2HRP+LzmXKtHxhGiq+pUTM+ePQt/f3+0bdsWbdu2xciRI1XOikQIUV/V+6XWTsYQiLQ74XyH3q0VhsXcuZKG9KRctY6RnpSLfd9cw7O0Qq5NbKCHkbO7oH3Phhs3S0hjUbuY/u9//8PQoUNhYGCA2bNnY/bs2dDX18eQIUOwc+fOhshISIuRm12kUHAcOjRuL15VeHwe+o1vp9B2YU/tnyqTEJWJQ2sjuVmVAMDYQoI35/nAvr323x8hmqB2B6RVq1ZhzZo1+Pjjj7m22bNnY926dVi5ciXefvttjQYkpCVJvv1UYdmhoznSb2spTBV27UzR1sca8dczAABpCc9x/1r6S2djij79GOf33AOq1F1rJ2OMmOXdaFMUEtIY1D4zTUhIgL+/v1L7yJEjkZiYqJFQhLRUVS/x6hsLYeWgO2Mte49xg0Cv8lfG5QMPIC1VfT+XyRku7LuP87sVC6lzZ0uMDu5GhZQ0O2oXUwcHB4SFhSm1nzp1Cg4ODhoJRUhLVD4kpvLM1MHTHDwtDImpTitLfXQZVvkznv+sBDdOJittV1Yqw4nfYnDzlOITZ7wGtsHrH3pBKK7/OFVCdI3al3k/+eQTzJ49G1FRUejTpw8A4OLFi9i2bRt++OEHjQckpKV4cj8HZaWVzw916mShxTSqdfNzQtylVBT+/9R/N048RLuelTMlFeWV4p9fopGWUKWDEq/8WaneQxyoxy5pttQupjNnzoStrS3Wrl2LPXv2AAA6dOiA3bt3Y9SoURoPSEhL8bDKFII8HuDYQfeKqUiih95j3BC2LQ4AUCaVI+JIImAFPM8owvFNt5GbWfmkG4GQj2GBnnDrZq2tyIQ0ijoNjRkzZgwuXLiA7OxsZGdn48KFC3UupBs3boSzszMkEgl8fX0RERFR7bZSqRRffPEF3NzcIJFI4O3tjZCQkHodkxBdUfV+qY1LK0iMhFpMUz33nrawdm7FLcdfy0RekhCH1kUpFFKJkRCjP+5KhZS0CGoX06tXryI8PFypPTw8HNeuXVPrWLt370ZwcDCWLVuGyMhIeHt7w8/PDxkZGSq3X7x4Mf773/9iw4YNiI2NxYcffogxY8bgxo0bdT4mIbrgeWYRctIrh8Q4dtS9s9IKPD4P/d9SHCrzPE6CkoLKmZpMrPQxdr4PbF1NGjseIVqhdjGdNWsWHj16pNSekpKCWbNmqXWsdevWYcaMGQgMDISnpyc2bdoEAwMDbNmyReX2f/75JxYtWoThw4fD1dUVM2fOxPDhw7F27do6H5MQXfDiU2J08X5pVbauJmjXw6badWM/84GpNT3Um7Qcat8zjY2NRbdu3ZTau3btitjY2Fofp7S0FNevX8fChQu5Nj6fj6FDh+Ly5csq9ykpKYFEIlFo09fXx4ULF+p8zIrjlpRUzjeam1veeUIqlUIqlVa3m1ZV5NLVfIDuZ9SlfEm3Kh8Erm8shKmtROH7TxcyvqiHvxMSojIhk1Z2mnLpYolBk9tDT8TTqcy6/DlW0PWMup4PaLiMQuHLb7moXUzFYjHS09Ph6uqq0J6amgo9vdofLisrCzKZDDY2in/d2tjY4M6dOyr38fPzw7p16/DKK6/Azc0NYWFhOHDgADfBfl2OCQCrV6/GihUrlNpPnz4NAwPd/us6NDRU2xFeStczajsfkwFP4owAlPd05bUqxPGQ4wrbaDtjdYzbCZETW/4HrpFLKUptE3HylO6ON9fVz7EqXc+o6/kAzWesTZ8gtYvpq6++ioULF+Lw4cMwMSm/H5KTk4NFixZh2LBh6qdUww8//IAZM2bAw8MDPB4Pbm5uCAwMrPcl3IULFyI4OJhbzs3NhYODAwYNGgQLC9283CaVShEaGophw4bV6q8mbdD1jLqS71HcM6ScjOGWew/zgptP+XATXclYk8zHubh0+SKGjx6qsxmbwueo6xl1PR+g3YxqF9PvvvsOr7zyCpycnNC1a1cAQFRUFGxsbPDnn3/W+jiWlpYQCARIT1d8FFN6ejpsbVVPUWZlZYVDhw6huLgY2dnZsLOzw4IFC7iz5LocEyg/2xaLxUrtQqFQZ79pKlDG+tN2vpQ7Ody/eTzA2ctKKY+2M9bEqk0rCA2ZTmesQBnrT9fzAdrJqHYHJHt7e0RHR2PNmjXw9PSEj48PfvjhB9y6dUutGZBEIhF8fHwUZlOSy+UICwtD7969a9xXIpHA3t4eZWVl2L9/P3cKXp9jEqItVYfE2LqaQGKo27+oCCHK1D4zBQBDQ0O8//779X7x4OBgTJ06Fd27d0fPnj2xfv16FBQUIDAwEAAwZcoU2NvbY/Xq1QDKh9+kpKSgS5cuSElJwfLlyyGXyzF//vxaH5MQXZKTUYjnGZVjM3V5SAwhpHq1Lqb37t1DTk4OevbsybWFhYXhyy+/REFBAUaPHo1Fixap9eIBAQHIzMzE0qVLkZaWhi5duiAkJITrQJScnAw+v/Lkubi4GIsXL0ZCQgKMjIwwfPhw/PnnnzA1Na31MQnRJU1tSAwhRLVaF9PPPvsMXl5eXDFNTEyEv78/+vfvj86dO2P16tUwMDDA3Llz1QoQFBSEoKAglevOnDmjsDxgwIBaDb+p6ZiE6JKHMZUT2xu0EsFSh54SQwipvVoX02vXrilcTt2xYwfat2+PEydOAAA6d+6MDRs2qF1MCWmpykplSLn3jFt27GRBE8ET0kTVugNSVlYW2rRpwy2fPn1a4bmmAwcORFJSkkbDEdKcpdzLUZjwwInulxLSZNW6mJqbmyM1NRVAeQ/Za9euoVevXtz60tJSMMaq250Q8gKFp8TweXDoYKbFNISQ+qh1MR04cCBWrlyJR48eYf369ZDL5Rg4cCC3PjY2Fs7Ozg0QkZDmSXFITCuIDWhIDCFNVa3vma5atQrDhg2Dk5MTBAIBfvzxRxgaGnLr//zzTwwePLhBQhLS3OSkFyo8rox68RLStNW6mDo7OyMuLg63b9+GlZUV7OzsFNavWLFC4Z4qIaR6Vc9KASqmhDR1ak3aoKenB29vb5XrqmsnhCirOr7U0EQEC3saEkNIU6b2dIKEkPqRlsqQci+HW6YhMYQ0fXWaTpCQlyktKkNiTBbKiqhIvCjl7jPIymhIDCHNCRVTonGZj/Jw7KebKHheCp7QEDn9C2Flb6LtWDqj6v1SPp+HNh3MtZiGEKIJdJmXaNTD29k4+F0kCp6XAgCYlIcrB3T3YdGNjTGmcL/U1s0EYn36m5aQpk7tYurs7IwvvvgCycnJDZGHNGG3z6fg2MZoSEtkCu3Jt58qTejeUuWkFyI3q5hbpl68hDQPahfTuXPn4sCBA3B1dcWwYcOwa9culJSUNEQ20kQwOcPlQw9wZsddMLnqWbAu7L0PmUyucl1LQkNiCGme6lRMo6KiEBERgQ4dOuCjjz5C69atERQUhMjIyIbISHSYTCpH6NZYRIY8VGj37GcHj7623PKztELcPpfS2PF0TtUzdCMzMcztDGvYmhDSVNT5nmm3bt3w448/4smTJ1i2bBl+//139OjRA126dMGWLVtont4WoLhAiiM/RuH+1XSF9l6jXTFwkjt6vuEMnl7l90HE0UQU50sbO6bOKC0uQ8r9HG7ZsSMNiSGkuahzMZVKpdizZw9GjhyJTz75BN27d8fvv/+OsWPHYtGiRZg0aZImcxIdk5tVhAPfXseTKsWBr8fDsOme8HnNGTweDxIjIVq1rbwFUFJYhohjLbczUsq9HMjLKv+4oEu8hDQfancjjIyMxNatW/HXX3+Bz+djypQp+P777+Hh4cFtM2bMGPTo0UOjQYnuSE/KxbGNN1GUV3mWKTbQw/CZXrBrp/jkEyMnKfDUDM8zyuehjTmbgk797Vvk5U2FITECHtp40FNiCGku1D4z7dGjB+7fv49ffvkFKSkp+O677xQKKQC4uLhgwoQJGgtJdEdCVCYOrY1UKKTGFhKMne+jVEgBgMcHer/pyi0zOcPFffdb3G0AxhiSqxTT1m1NIZLQkBhCmgu1f5oTEhLg5ORU4zaGhobYunVrnUMR3RR9+hHO77kPVKmD1k7GGDHLGwatRNXu59jRHI4dzZF8+ykAIDn2KR7GZMPZy7KhI+uMZ6mFyHtaZUgMzXpESLOi9plpRkYGwsPDldrDw8Nx7do1jYQiuoXJGS7su4/zuxULqXNnS4wO7lZjIa3Qd1w78PiVnW0u7otXmFKvuXt4m4bEENKcqV1MZ82ahUePHim1p6SkYNasWRoJRXRHWakMJ36Lwc1Tiv/nXoPa4PUPvSAUC2p1HPPWhvAaYM8t56QX4taZxxrNqssUhsSYi2HW2kCLaQghmqZ2MY2NjUW3bt2U2rt27YrY2FiNhCK6oSivFIfX38CDG5mVjTyg77i26P9WO/D56g3r6PGGC8SGlXcWrh5LQlFeqabi6qzS4jKFXs9ONCSGkGZH7WIqFouRnp6u1J6amgo9PepQ0VzkpBdi35rrSEvI5doEQj5em9EJXYY61qkYSAyF8PWv7IxUWlSG8KPNf6jM4zvPIJfRkBhCmjO1i+mrr76KhQsX4vnz51xbTk4OFi1ahGHDhmk0HNGO1Pgc7F9zHbmZRVybxEiI0R93hVs363odu2N/O4VhMbHnU5D1OL9ex9R1Ve+X8vV4sHenITGENDdqF9PvvvsOjx49gpOTEwYNGoRBgwbBxcUFaWlpWLt2bUNkJI0o/noGDq+PQnFB5dAXE2t9jJ3vA1vX+j9GjS/go9+4dtwyY+Xz9jbXoTIvDomxoyExhDRLav9U29vbIzo6Gjt27MDNmzehr6+PwMBATJw4EUKhsCEykkbAGENU6CNcOhCv0G7raoLh//GCvtHLe+zWloOnOZy9LJB0q7zIpNx9hsSbWXDtYqWx19AVT58UIP9Z5SxQdImXkOapTn8iGxoa4v3339d0FqIlcpkcF/bcx62zihPRu3WzxtBpHaAnql2PXXX0HdcOybFPuXuJF/fHw6mjBQTC5vWIXRoSQ0jLUOfrTbGxsUhOTkZpqWJvzJEjR9Y7FGk80hIZTv4ew50lVug6zBG9x7gpjA3VJFMbA3gNasMNucnNLMLN04/Q7dWaJwRpaqpe4jW2kMDUhobEENIc1WkGpDFjxuDWrVvg8Xjcva6K3p0ymaym3YkOKXhegmMbo5GZnMe18XhA/4D28BrYpsFfv8dwZ9y9ksY9SebaP0nw6NW6VpNANAWlRWVIja/sqOfUiYbEENJcqX1Nbc6cOXBxcUFGRgYMDAxw+/ZtnDt3Dt27d8eZM2caICJpCE+fFGD/N9cVCqmeiI/XZ3ZulEIKAGIDIXxHVg6VkRbLEH74QaO8dmN4fOcZ5FUelk5TCBLSfKldTC9fvowvvvgClpaW4PP54PP56NevH1avXo3Zs2c3REaiYSl3n2H/t9cV5orVbyXCmE+6waVz486X69nPDhb2Rtxy7KVUhQLflD2MyeL+LdDj05AYQpoxtYupTCaDsbExAMDS0hJPnjwBADg5OeHu3buaTUc07m54Go78GIXSojKuzczWAOPm+8DaqVWj5+Hzeej3VuVQGTSToTKMMTz8/4n9AcCuvWmtp14khDQ9at8z7dSpE27evAkXFxf4+vpizZo1EIlE+PXXX+Hq6vryAxCtYIzh+vEkhB9RnHHIvr0pXvvACxJD7Q1rauNuBtcuVkiIKp+28Mn9HDyIzERbn/pNEKFN2SkFKMipMiSGLvES0qypfWa6ePFiyOXlT/v44osvkJiYiP79++Off/7Bjz/+qHaAjRs3wtnZGRKJBL6+voiIiKhx+/Xr18Pd3R36+vpwcHDAxx9/jOLiysuVy5cvB4/HU/h68XmrLY1MJsfp/91RKqTtfW3g/1EXrRbSCn3GtgVfr7JzzqUD8SiTNt3ObMk0JIaQFkXtM1M/Pz/u323btsWdO3fw9OlTmJmZqd1Tcffu3QgODsamTZvg6+uL9evXw8/PD3fv3oW1tfJZyc6dO7FgwQJs2bIFffr0wb179zBt2jTweDysW7eO265jx444depU5ZtswXMGlxaVIeS3GDyKfarQ3n24M3r6u+hM71ITK310GeKAyBPJAIC87GJEnXqE7q87azdYHT2sMiSmlaUEJtb6WkxDCGloap2ZSqVS6OnpISYmRqHd3Ny8Tr+U161bhxkzZiAwMBCenp7YtGkTDAwMsGXLFpXbX7p0CX379sXbb78NZ2dnvPrqq5g4caLS2ayenh5sbW25L0vLlvMQ6qrynxXjwHeRCoWUx+dh0GQP+I501ZlCWsHndWfoVxkWcz3kocKl0qaipKgMqQ+qDomx1LnPmhCiWWqdsgmFQjg6OmpkLGlpaSmuX7+OhQsXcm18Ph9Dhw7F5cuXVe7Tp08f/O9//0NERAR69uyJhIQE/PPPP5g8ebLCdvfv34ednR0kEgl69+6N1atXw9HRsdosJSUlKCmp/KWdm1v+pBSpVAqpVFrdblpVkau6fNmP8xHy39soyKmcVEMoEWDY9A5o08GsUd7XyzK+iCcAerzhhHM77wMAykpkuHQwHgPfaa8T+Wor6VYmWJUhMfYeJnV+jYbKqEmUUTN0PaOu5wMaLmNtpsrlMTW7TW7evBkHDhzAn3/+CXNz8zqHe/LkCezt7XHp0iX07t2ba58/fz7Onj2L8PBwlfv9+OOP+PTTT8EYQ1lZGT788EP88ssv3Prjx48jPz8f7u7uSE1NxYoVK5CSkoKYmBiuF/KLli9fjhUrVii179y5EwYGTW/GmuJMAbJv6IPJKs+GBGI5LLoXQdRKrsVkL8cYkHHJANLcyp6v1n0KIDLR7dxVPb0lRuHj/z/D5jPYDc0HnzryEtJkjRo16qXbqF1Mu3btivj4eEilUjg5OcHQ0FBhfWRkZK2OU5dieubMGUyYMAFffvklfH19ER8fjzlz5mDGjBlYsmSJytfJycmBk5MT1q1bh3fffVflNqrOTB0cHJCamgoLC93sOCKVShEaGophw4Yp/NV053Iazu+6D1al9pjbGeK1DzvCyEysExlfJjX+OY7+EM0t27i2wsi5nTV+qbSu+WrCGMOOxREozC2/IuDQwQyv/6eTTmXUNMqoGbqeUdfzAQ2XsTbHUrtnzujRo+uSRYmlpSUEAoHSg8bT09Nha2urcp8lS5Zg8uTJeO+99wAAXl5eKCgowPvvv4/PP/8cfL7yLWBTU1O0b98e8fHxSusqiMViiMXKhUYoFOrsN02FioyMMYQfScD14w8V1jt4muO1GZ0g0tdeJyx1P0fHDpZo62ON+OsZAID0hFw8vPkM7XrY6ES+mmQ+yuMKKQA4d7bUyLGb0veiLqOM9afr+QDtZFT7N+yyZcs08sIikQg+Pj4ICwvjCrRcLkdYWBiCgoJU7lNYWKhUMAWC8utn1Z1g5+fn48GDB0r3VZsTmVSOf/+Mw70IxT9MOvRpjQGT3CEQNL0nsfQe44bEm1mQlZWfYl86EA9nb0sIG+AJNpr04pAYRxpfSkiLoNXfssHBwfjtt9+wfft2xMXFYebMmSgoKEBgYCAAYMqUKQodlPz9/fHLL79g165dSExMRGhoKJYsWQJ/f3+uqH766ac4e/YskpKScOnSJYwZMwYCgQATJ07UyntsaCWFUhzdEKVUSH1HumDQZI8mWUgBoJWlProMc+CW85+VICo0WYuJaqfqkBgTa32YWje9e+6EEPWpfWbK5/NrvHelTk/fgIAAZGZmYunSpUhLS0OXLl0QEhICG5vyy3nJyckKZ6KLFy8Gj8fD4sWLkZKSAisrK/j7+2PVqlXcNo8fP8bEiRORnZ0NKysr9OvXD1euXIGVVfN78HRZIQ+Hv7+JnLQiro0v4GHwlA5w91V9qbwp6ebnhLhLqSh8Xn7ZNPLEQ3To0xpGZhItJ1OtuECKtIRcbplmPSKk5VC7mB48eFBhWSqV4saNG9i+fbvKHrEvExQUVO1l3RefQqOnp4dly5bVeKl5165damdoijKT85Bx2QDy0spCKtLXw+sfeqFNM5lQXSTRQ+8xbgjbFgcAKCuV4/LBBxg2vaOWk6n2KO6pwpAYR5r1iJAWQ+1iqqqL8Lhx49CxY0fs3r272h6zRHMexT3FP79EQ15aedZubC7BG0HeMLczrGHPpse9py1unUlBRlL5Gd+9iHSkJTwvf/BqfTGGgkJD7Lp6VSPHKymoHNumJ+TDvp1pvY9JCGkaNNbFs1evXnj//fc1dThSjZKiMoRuuY2y0sqxL1aOxhgxqzMMTRp36Etj4PF56P9WO+xfc51ry80qrmEPdfGRW6jJ45WzdzeDno53liKEaI5GeqcUFRXhxx9/hL29vSYOR2pw7VgiivIqz4AcO5ljdHDXZllIK9i6msC9V9O6B9zU8hJC6kftM9MXJ7RnjCEvLw8GBgb43//+p9FwRFFOeiGiTz/mlgUGcgyb3gEiSfOfyH/gJHeY2RrgeUbRyzeuJblcjkePH8GhjYPKMcp1weMBdu3NmvTj4wgh6lP7t/D333+vUEz5fD6srKzg6+sLM7Pm0fFFV13cHw+5rLKDi6lHCQTCpjn0RV16QgF8XnPW6DGlUin++SceA4a31/lB6IQQ3aZ2MZ02bVoDxCAv8yjuKZKis7hlu3Ym4FnnaTERIYSQCmqf1mzduhV79+5Vat+7dy+2b9+ukVBEkVwmx4W997llHg/oPdZNIx1aCSGE1J/axXT16tUqnw9qbW2Nr776SiOhiKLb55/g6ZMCbtmznx0s7JvXEBhCCGnK1C6mycnJcHFxUWp3cnJCcrLuT/fW1BQXSBFxNJFbFunrwXekqxYTEUIIeZHaxdTa2hrR0dFK7Tdv3tTZx5U1ZVePJaK4ymQAPUY4Q99YpMVEhBBCXqR2MZ04cSJmz56N06dPQyaTQSaT4d9//8WcOXMwYcKEhsjYYj1LK0DMmRRu2dTGAF4D22gxESGEEFXU7s27cuVKJCUlYciQIdDTK99dLpdjypQpdM9Uwy7sjYe8ylyvfce2hUCvZQyFIYSQpkTtYioSibB79258+eWXiIqKgr6+Pry8vODk5NQQ+VqshzHZCs/GdPA0h5MXXUYnhBBdVOepc9q1a4d27dppMgv5fzKZHBf3VRkKw+eh37h2NT76jhBCiPaofc1w7Nix+Oabb5Ta16xZg/Hjx2skVEsXcyYFz9IKueVOr9g3u6fBEEJIc6J2MT137hyGDx+u1P7666/j3LlzGgnVkhXnS3H1WOVQGLGBHnq+oTwUiRBCiO5Qu5jm5+dDJFIemiEUCpGbm6uRUC1ZxNEElBSWccs9/V0gMaJ5YwkhRJepXUy9vLywe/dupfZdu3bB09NTI6Faquwn+Yg5/4RbNrM1QMdX6LF2hBCi69TugLRkyRK8+eabePDgAQYPHgwACAsLw19//aVyzl5SO4wxXNx7H6zqUJjx7SAQ0FAYQgjRdWoXU39/fxw6dAhfffUV9u3bB319fXTu3BmnTp3CgAEDGiJji5B0KxuP4p5xy06dLODUkYbCEEJIU1CnoTEjRozAiBEjlNpjYmLQqVOneodqaWRlikNh+Hwe+o5rq8VEhBBC1FHva4h5eXn49ddf0bNnT3h7e2siU4sTffoxnmcUccteA9vAzJaGwhBCSFNR52J67tw5TJkyBa1bt8Z3332HwYMH48qVK5rM1iIU5pbiWpWhMBJDIbqPcNZeIEIIIWpT6zJvWloatm3bhs2bNyM3NxdvvfUWSkpKcOjQIerJW0fhRxNQWizjln1HukBiSENhCCGkKan1mam/vz/c3d0RHR2N9evX48mTJ9iwYUNDZmv2sh7nIe5C5VAYcztDePaz02IiQgghdVHrM9Pjx49j9uzZmDlzJs3JqwGMMVzYcx+sciQM+r3VDnwaCkMIIU1OrX9zX7hwAXl5efDx8YGvry9++uknZGVlNWS2Zi0xKgsp93K4ZRdvSzh4mGsvECGEkDqrdTHt1asXfvvtN6SmpuKDDz7Arl27YGdnB7lcjtDQUOTl5TVkzmZFJpXj4v4qQ2EEPPQZS0NhCCGkqVL7mqKhoSGmT5+OCxcu4NatW/jkk0/w9ddfw9raGiNHjmyIjM3OzX8fITermFv2HuwAU2sDLSYihBBSH/W6Qefu7o41a9bg8ePH+OuvvzSVqVkreF6Ca/8kccv6xkJ0H+6stTyEEELqTyO9XQQCAUaPHo0jR45o4nDNWvjhBEhLKofC9BrlBpF+nZ/RTgghRAdQ19FGlJmch7jLqdyypYMRPPq01mIiQgghmkDFtJEwxnB+zz2g6lCY8e3A5/O0F4oQQohGUDFtJPHXM5Aa/5xbdutqBfv2ZlpMRAghRFO0Xkw3btwIZ2dnSCQS+Pr6IiIiosbt169fD3d3d+jr68PBwQEff/wxiouLFbZR95gNraxUhksH4rllgR6fhsIQQkgzotViunv3bgQHB2PZsmWIjIyEt7c3/Pz8kJGRoXL7nTt3YsGCBVi2bBni4uKwefNm7N69G4sWLarzMRtD1Klk5D8t4Za9hzqglaW+1vIQQgjRLK12I123bh1mzJiBwMBAAMCmTZtw7NgxbNmyBQsWLFDa/tKlS+jbty/efvttAICzszMmTpyI8PDwOh8TAEpKSlBSUlnscnNzAQBSqRRSqbRe77EwtxTXQx5yy/qthOg8xK7ex63Yv77HaUi6nlHX8wGUUVMoY/3pej6g4TIKhS9/+AiPsaqzwzae0tJSGBgYYN++fRg9ejTXPnXqVOTk5ODw4cNK++zcuRP/+c9/cPLkSfTs2RMJCQkYMWIEJk+ejEWLFtXpmACwfPlyrFixQuXrGRjUbzKF3Aci5N4Tc8tmXkUwbFNWr2MSQghpPKNGjXrpNlo7M83KyoJMJoONjY1Cu42NDe7cuaNyn7fffhtZWVno168fGGMoKyvDhx9+yF3mrcsxAWDhwoUIDg7mlnNzc+Hg4IBBgwbBwsKirm8RjDHsXnkNQPk9XWNLCca91w88DfTglUqlCA0NxbBhw2r1V5M26HpGXc8HUEZNoYz1p+v5AO1mbFKzBZw5cwZfffUVfv75Z/j6+iI+Ph5z5szBypUrsWTJkjofVywWQywWK7ULhcJ6/Yc8uZ+D3MzKzlGefewgEovqfDxV6puxMeh6Rl3PB1BGTaGM9afr+QDtZNRaMbW0tIRAIEB6erpCe3p6OmxtbVXus2TJEkyePBnvvfceAMDLywsFBQV4//338fnnn9fpmA0p7lLls0rBAzx6N34GQgghDU9rvXlFIhF8fHwQFhbGtcnlcoSFhaF3794q9yksLASfrxhZIBAAKL+kWpdjNpTS4jLEX6/sQezoaQ4jM0mjZiCEENI4tHqZNzg4GFOnTkX37t3Rs2dPrF+/HgUFBVxP3ClTpsDe3h6rV68GAPj7+2PdunXo2rUrd5l3yZIl8Pf354rqy47ZWOKvZ6CsVM4td+hj16ivTwghpPFotZgGBAQgMzMTS5cuRVpaGrp06YKQkBCuA1FycrLCmejixYvB4/GwePFipKSkwMrKCv7+/li1alWtj9lY7lyqnINXbKgHl86Wjfr6hBBCGo/WOyAFBQUhKChI5bozZ84oLOvp6WHZsmVYtmxZnY/ZGJ6lFSD1QeXUge172kIg1PpkU4QQQhoI/YZvAHeqPBkGADrQk2EIIaRZo2KqYXKZHHcup3HLlg5GsHIw1mIiQgghDY2KqYYl336KwtxSbpk6HhFCSPNHxVTD4qp0POLr8dC+Z+N2fCKEENL4qJhqUGFuKZKis7hl1y5WkBjq9kwhhBBC6o+KqQbdi0iDXF753ADqeEQIIS0DFVMNYYwh9mLlJV4jMzHaeJhrMREhhJDGQsVUQzKS8vAstYBb9ujdGnwNPB2GEEKI7qNiqiEKk9qjvJgSQghpGaiYaoC0VIb7VyufVGPvbgoTK30tJiKEENKYqJhqQMKNTJQWy7hlGltKCCEtCxVTDah6iVckEcC1q5UW0xBCCGlsVEzrKTerCCl3c7jldj1sIBQJtBeIEEJIo6NiWk9xSpPa0yVeQghpaaiY1oNczhSeW2rW2hDWzjSpPSGEtDRUTOsh5c4z5D8r4ZY79GkNHo/GlhJCSEtDxbQeqnY84vN5cPe11WIaQggh2kLFtI6KC6RIiKqc1N7JywIGrURaTEQIIURbqJjW0f2r6ZCVybnlDn2p4xEhhLRUVEzrqOpzSw1aieDUkSa1J4SQloqKaR1kPspDZnIet+zeyxZ8AX2UhBDSUlEFqIOqw2EAem4pIYS0dFRM1SSTynE3Io1btnU1gZmtoRYTEUII0TYqpmpKjM5CSUEZt9yhL52VEkJIS0fFVE1Vx5bqifho62OtxTSEEEJ0ARVTNeQ9LUZy7FNuua2PNUQSPS0mIoQQoguomKrh7pU0gFUu06T2hBBCACqmtcYYU3hCjImVPlq3NdFiIkIIIbqCimktpcbnIDeziFvu0JcmtSeEEFKOimktxV2sPCvl8QB3X+rFSwghpBwV01ooLSpDfGQGt+zgaQEjM7EWExFCCNElVExrIf56BspKq0xqTzMeEUIIqYKKaS1UHVsqMRTCpbOlFtMQQgjRNTpRTDdu3AhnZ2dIJBL4+voiIiKi2m0HDhwIHo+n9DVixAhum2nTpimtf+211+qU7WlqAdIScrnl9r42EAh14mMjhBCiI7Q+48Du3bsRHByMTZs2wdfXF+vXr4efnx/u3r0La2vl2YUOHDiA0tJSbjk7Oxve3t4YP368wnavvfYatm7dyi2LxXW7x0mT2hNCCHkZrZ9irVu3DjNmzEBgYCA8PT2xadMmGBgYYMuWLSq3Nzc3h62tLfcVGhoKAwMDpWIqFosVtjMzM1M7m1wmx53wykntrRyNYdnGWO3jEEIIad60emZaWlqK69evY+HChVwbn8/H0KFDcfny5VodY/PmzZgwYQIMDRWf3HLmzBlYW1vDzMwMgwcPxpdffgkLCwuVxygpKUFJSQm3nJtbfln3YUwWinIrz4Lb+1pDKpXW+v01pIocupJHFV3PqOv5AMqoKZSx/nQ9H9BwGYVC4Uu34THG2Eu3aiBPnjyBvb09Ll26hN69e3Pt8+fPx9mzZxEeHl7j/hEREfD19UV4eDh69uzJte/atQsGBgZwcXHBgwcPsGjRIhgZGeHy5csQCARKx1m+fDlWrFih1L5h/n7wnpuWL/AZ7Abng//yz5QQQkgzMmrUqJduo/V7pvWxefNmeHl5KRRSAJgwYQL3by8vL3Tu3Blubm44c+YMhgwZonSchQsXIjg4mFvOzc2Fg4MDSrKFqJjH3q2rNYaMeqVh3kgdSKVShIaGYtiwYbX6q0kbdD2jrucDKKOmUMb60/V8gHYzarWYWlpaQiAQID09XaE9PT0dtra2Ne5bUFCAXbt24Ysvvnjp67i6usLS0hLx8fEqi6lYLFbZQYlVDi1Fx372OvkNJBQKdTJXVbqeUdfzAZRRUyhj/el6PkA7GbXaAUkkEsHHxwdhYWFcm1wuR1hYmMJlX1X27t2LkpISvPPOOy99ncePHyM7OxutW9etJ66RuRht3NXvwEQIIaRl0Hpv3uDgYPz222/Yvn074uLiMHPmTBQUFCAwMBAAMGXKFIUOShU2b96M0aNHK3Uqys/Px7x583DlyhUkJSUhLCwMo0aNQtu2beHn51enjB16twaPT5PaE0IIUU3r90wDAgKQmZmJpUuXIi0tDV26dEFISAhsbGwAAMnJyeDzFWv+3bt3ceHCBZw8eVLpeAKBANHR0di+fTtycnJgZ2eHV199FStXrqzzWFOP3jS2lBBCSPW0XkwBICgoCEFBQSrXnTlzRqnN3d0d1XVC1tfXx4kTJzSWrY2HGVpZ6mvseIQQQpofrV/m1XU04xEhhJCX0YkzU11TcdYr55fA0lXMTeKgS6RSKQoLC5Gbm6uzPet0PaOu5wMoo6ZQxvrT9XxAw2Y0NjYGj1d93xmtTtqgqxISEuDm5qbtGIQQQnTE8+fP0apVq2rX05mpCubm5gDKOz+ZmJhoOY1qFRNLPHr0qMb/YG3S9Yy6ng+gjJpCGetP1/MBDZvR2LjmedmpmKpQ0XvYxMREZ79pKrRq1Yoy1pOu5wMoo6ZQxvrT9XyAdjJSByRCCCGknqiYEkIIIfVExVQFsViMZcuW1XmSh8ZAGetP1/MBlFFTKGP96Xo+QLsZqTcvIYQQUk90ZkoIIYTUExVTQgghpJ6omBJCCCH1RMWUEEIIqScqpips3LgRzs7OkEgk8PX1RUREhLYjAQBWr16NHj16wNjYGNbW1hg9ejTu3r2r7Vg1+vrrr8Hj8TB37lxtR1GQkpKCd955BxYWFtDX14eXlxeuXbum7VgcmUyGJUuWwMXFBfr6+nBzc8PKlSurfVpSYzh37hz8/f1hZ2cHHo+HQ4cOKaxnjGHp0qVo3bo19PX1MXToUNy/f19nMkqlUnz22Wfw8vKCoaEh7OzsMGXKFDx58kQn8r3oww8/BI/Hw/r16xstH1C7jHFxcRg5ciRMTExgaGiIHj16IDk5WWcy5ufnIygoCG3atIG+vj48PT2xadOmBs1ExfQFu3fvRnBwMJYtW4bIyEh4e3vDz88PGRkZ2o6Gs2fPYtasWbhy5QpCQ0MhlUrx6quvoqCgQNvRVLp69Sr++9//onPnztqOouDZs2fo27cvhEIhjh8/jtjYWKxduxZmZmbajsb55ptv8Msvv+Cnn35CXFwcvvnmG6xZswYbNmzQWqaCggJ4e3tj48aNKtevWbMGP/74IzZt2oTw8HAYGhrCz88PxcXFOpGxsLAQkZGRWLJkCSIjI3HgwAHcvXsXI0eO1Il8VR08eBBXrlyBnZ1dIyWr9LKMDx48QL9+/eDh4YEzZ84gOjoaS5YsgUQi0ZmMwcHBCAkJwf/+9z/ExcVh7ty5CAoKwpEjRxouFCMKevbsyWbNmsUty2QyZmdnx1avXq3FVKplZGQwAOzs2bPajqIkLy+PtWvXjoWGhrIBAwawOXPmaDsS57PPPmP9+vXTdowajRgxgk2fPl2h7c0332STJk3SUiJFANjBgwe5Zblczmxtbdm3337LteXk5DCxWMz++usvLSRUzqhKREQEA8AePnzYOKGqqC7f48ePmb29PYuJiWFOTk7s+++/b/RsFVRlDAgIYO+88452AqmgKmPHjh3ZF198odDWrVs39vnnnzdYDjozraK0tBTXr1/H0KFDuTY+n4+hQ4fi8uXLWkym2vPnzwFUTsyvS2bNmoURI0YofJa64siRI+jevTvGjx8Pa2trdO3aFb/99pu2Yyno06cPwsLCcO/ePQDAzZs3ceHCBbz++utaTqZaYmIi0tLSFP6/TUxM4Ovrq5M/OxWeP38OHo8HU1NTbUcBAMjlckyePBnz5s1Dx44dtR1HiVwux7Fjx9C+fXv4+fnB2toavr6+NV6u1oY+ffrgyJEjSElJAWMMp0+fxr179/Dqq6822GtSMa0iKysLMpkMNjY2Cu02NjZIS0vTUirV5HI55s6di759+6JTp07ajqNg165diIyMxOrVq7UdRaWEhAT88ssvaNeuHU6cOIGZM2di9uzZ2L59u7ajcRYsWIAJEybAw8MDQqEQXbt2xdy5czFp0iRtR1Op4uejKfzsVCguLsZnn32GiRMn6szE7d988w309PQwe/ZsbUdRKSMjA/n5+fj666/x2muv4eTJkxgzZgzefPNNnD17VtvxOBs2bICnpyfatGkDkUiE1157DRs3bsQrr7zSYK9JT41pombNmoWYmBhcuHBB21EUPHr0CHPmzEFoaGij3kNRh1wuR/fu3fHVV18BALp27YqYmBhs2rQJU6dO1XK6cnv27MGOHTuwc+dOdOzYEVFRUZg7dy7s7Ox0JmNTJpVK8dZbb4Exhl9++UXbcQAA169fxw8//IDIyMgaH0KtTXK5HAAwatQofPzxxwCALl264NKlS9i0aRMGDBigzXicDRs24MqVKzhy5AicnJxw7tw5zJo1C3Z2dg12tYzOTKuwtLSEQCBAenq6Qnt6ejpsbW21lEpZUFAQ/v77b5w+fRpt2rTRdhwF169fR0ZGBrp16wY9PT3o6enh7Nmz+PHHH6GnpweZTKbtiGjdujU8PT0V2jp06NCovRFfZt68edzZqZeXFyZPnoyPP/5YZ8/2K34+dP1nB6gspA8fPkRoaKjOnJWeP38eGRkZcHR05H52Hj58iE8++QTOzs7ajgeg/Heknp6eTv/8FBUVYdGiRVi3bh38/f3RuXNnBAUFISAgAN99912DvS4V0ypEIhF8fHwQFhbGtcnlcoSFhaF3795aTFaOMYagoCAcPHgQ//77L1xcXLQdScmQIUNw69YtREVFcV/du3fHpEmTEBUVBYFAoO2I6Nu3r9KQonv37sHJyUlLiZQVFhZyz9WtIBAIuDMDXePi4gJbW1uFn53c3FyEh4frxM9OhYpCev/+fZw6dQoWFhbajsSZPHkyoqOjFX527OzsMG/ePJw4cULb8QCU/47s0aOHTv/8SKVSSKXSRv/5ocu8LwgODsbUqVPRvXt39OzZE+vXr0dBQQECAwO1HQ2zZs3Czp07cfjwYRgbG3P3okxMTKCvr6/ldOWMjY2V7uEaGhrCwsJCZ+7tfvzxx+jTpw+++uorvPXWW4iIiMCvv/6KX3/9VdvROP7+/li1ahUcHR3RsWNH3LhxA+vWrcP06dO1lik/Px/x8fHccmJiIqKiomBubg5HR0fMnTsXX375Jdq1awcXFxcsWbIEdnZ2GD16tE5kbN26NcaNG4fIyEj8/fffkMlk3M+Qubk5RCKRVvM5OjoqFXehUAhbW1u4u7s3eLbaZpw3bx4CAgLwyiuvYNCgQQgJCcHRo0dx5swZnck4YMAAzJs3D/r6+nBycsLZs2fxxx9/YN26dQ0XqsH6CTdhGzZsYI6OjkwkErGePXuyK1euaDsSY6y8C7iqr61bt2o7Wo10bWgMY4wdPXqUderUiYnFYubh4cF+/fVXbUdSkJuby+bMmcMcHR2ZRCJhrq6u7PPPP2clJSVay3T69GmV339Tp05ljJUPj1myZAmzsbFhYrGYDRkyhN29e1dnMiYmJlb7M3T69Gmt51NFG0NjapNx8+bNrG3btkwikTBvb2926NAhncqYmprKpk2bxuzs7JhEImHu7u5s7dq1TC6XN1gmegQbIYQQUk90z5QQQgipJyqmhBBCSD1RMSWEEELqiYopIYQQUk9UTAkhhJB6omJKCCGE1BMVU0IIIaSeqJgSQggh9UTFlBDSJPF4PK0/RzMpKQk8Hg9RUVFazUG0j4opaZYuX74MgUCAESNG1Gn/5cuXo0uXLpoNpabMzEzMnDkTjo6OEIvFsLW1hZ+fHy5evKjVXC+TlpaGjz76CK6urhCLxXBwcIC/v7/CJPgtMQtp3miie9Isbd68GR999BE2b96MJ0+ewM7OTis5SktL6zyB+tixY1FaWort27fD1dUV6enpCAsLQ3Z2toZTqq+695WUlIS+ffvC1NQU3377Lby8vCCVSnHixAnMmjULd+7cabSMupSFtAANNusvIVqSl5fHjIyM2J07d1hAQABbtWqVwvqtW7cyExMThbaDBw+yih+HrVu3VvswgYcPH7KRI0cyQ0NDZmxszMaPH8/S0tK44yxbtox5e3uz3377jTk7OzMej8cYY+z48eOsb9++zMTEhJmbm7MRI0aw+Pj4at/Ds2fPGAB25syZarepmLj9xo0bSvtVTNxeMSH433//zby8vJhYLGa+vr7s1q1bCsc6f/4869evH5NIJKxNmzbso48+Yvn5+dx6Jycn9sUXX7DJkyczY2Pjaidmf/3115m9vb3CvlWzVXjZ58gYYz///DNzdXVlQqGQtW/fnv3xxx8K6wGwgwcPVvv51CZLYGAgGzFihMK60tJSZmVlxX7//XfGGGMymYx98803zM3NjYlEIubg4MC+/PJLxpjq/4Nbt26x1157jRkaGjJra2v2zjvvsMzMzGpzkuaBLvOSZmfPnj3w8PCAu7s73nnnHWzZsgVMjec5BAQE4JNPPkHHjh2RmpqK1NRUBAQEQC6XY9SoUXj69CnOnj2L0NBQJCQkICAgQGH/+Ph47N+/HwcOHODupRUUFCA4OBjXrl1DWFgY+Hw+xowZU+3zFY2MjGBkZIRDhw6hpKSkzp9FhXnz5mHt2rW4evUqrKys4O/vD6lUCgB48OABXnvtNYwdOxbR0dHYvXs3Lly4gKCgIIVjfPfdd/D29saNGzewZMkSpdd4+vQpQkJCMGvWLBgaGiqtNzU1BYBafY4HDx7EnDlz8MknnyAmJgYffPABAgMDcfr06Vq939pmee+99xASEoLU1FRu3d9//43CwkIuz8KFC/H1119jyZIliI2Nxc6dO2FjY6PydXNycjB48GB07doV165dQ0hICNLT0/HWW2/VKjdpwrRdzQnRtD59+rD169czxhiTSqXM0tJS4RFbLzszZazyDLOqkydPMoFAwJKTk7m227dvMwAsIiKC208oFLKMjIwaM2ZmZjIASmeIVe3bt4+ZmZkxiUTC+vTpwxYuXMhu3rzJrVfnzHTXrl3cNtnZ2UxfX5/t3r2bMcbYu+++y95//32F1z5//jzj8/msqKiIMVZ+Zjp69Oga31N4eDgDwA4cOFDjdrX5HPv06cNmzJihsN/48ePZ8OHDuWXUcGZa2yyMMebp6cm++eYbbtnf359NmzaNMVb+KDyxWMx+++03lfu++H+wcuVK9uqrryps8+jRIwag0R9HRxoXnZmSZuXu3buIiIjAxIkTAQB6enoICAjA5s2b633suLg4ODg4wMHBgWvz9PSEqakp4uLiuDYnJydYWVkp7Hv//n1MnDgRrq6uaNWqFZydnQEAycnJ1b7e2LFj8eTJExw5cgSvvfYazpw5g27dumHbtm1qZ+/duzf3b3Nzc7i7u3OZb968iW3btnFnw0ZGRvDz84NcLkdiYiK3X/fu3Wt8DVbLs//afI5xcXHo27evwn59+/ZV+Jw1kQUoPzvdunUrACA9PR3Hjx/nHsIeFxeHkpISDBkypFbHunnzJk6fPq3wWXp4eAAovwJAmi/qgESalc2bN6OsrEyhwxFjDGKxGD/99BNMTEzA5/OVftlWXPLUBFWXFf39/eHk5ITffvsNdnZ2kMvl6NSpE0pLS2s8lkQiwbBhwzBs2DAsWbIE7733HpYtW4Zp06aBz+dz768+7yM/Px8ffPABZs+erbTO0dGxxvdVVbt27cDj8XSiY486WaZMmYIFCxbg8uXLuHTpElxcXNC/f38AgL6+vlqvm5+fD39/f3zzzTdK61q3bq3WsUjTQmempNkoKyvDH3/8gbVr1yIqKor7unnzJuzs7PDXX38BAKysrJCXl4eCggJu3xfHCYpEIshkMoW2Dh064NGjR3j06BHXFhsbi5ycHHh6elabKzs7G3fv3sXixYsxZMgQdOjQAc+ePavTe/T09ORyV5z9Vr3fV914xytXrnD/fvbsGe7du4cOHToAALp164bY2Fi0bdtW6Uudnsjm5ubw8/PDxo0bFT7bCjk5OQBq9zl26NBBaQjQxYsXa/yc65IFACwsLDB69Ghs3boV27ZtQ2BgILeuXbt20NfXr/VQmm7duuH27dtwdnZW+ixf9scIaeK0epGZEA06ePAgE4lELCcnR2nd/PnzWffu3Rlj5fcMDQ0N2ezZs1l8fDzbsWMHs7OzU7hnumPHDmZoaMhu3LjBMjMzWXFxMZPL5axLly6sf//+7Pr16yw8PJz5+PiwAQMGcPuputcqk8mYhYUFe+edd9j9+/dZWFgY69GjR433/LKystigQYPYn3/+yW7evMkSEhLYnj17mI2NDZs+fTq3Xa9evVj//v1ZbGwsO3PmDOvZs6fKe6YdO3Zkp06dYrdu3WIjR45kjo6OrKSkhDHG2M2bN5m+vj6bNWsWu3HjBrt37x47dOgQmzVrFvc6Tk5O7Pvvv3/p/8GDBw+Yra0t8/T0ZPv27WP37t1jsbGx7IcffmAeHh6MMVarz/HgwYNMKBSyn3/+md27d4+tXbuWCQQChXvfNX1+tc1S4eTJk0wkEjGBQMBSUlIU1i1fvpyZmZmx7du3s/j4eHb58mWup++L90xTUlKYlZUVGzduHIuIiGDx8fEsJCSETZs2jZWVlb308yNNFxVT0my88cYbCh1UqqrokFLRgefgwYOsbdu2TF9fn73xxhvs119/VSimxcXFbOzYsczU1LROQ2NeFBoayjp06MDEYjHr3LkzO3PmTI3FoLi4mC1YsIB169aNmZiYMAMDA+bu7s4WL17MCgsLue1iY2NZ7969mb6+PuvSpQs7efKkymJ69OhR1rFjRyYSiVjPnj0VOjIxxlhERAQbNmwYMzIyYoaGhqxz584KQ4pqW0wZY+zJkyds1qxZzMnJiYlEImZvb89GjhypUAgbY2hMbbMwVl7gnZycVH7/yGQy9uWXXzInJycmFAqZo6Mj++qrrxhjqjuB3bt3j40ZM4aZmpoyfX195uHhwebOncvkcvnLPzzSZPEYU+NOPSGkSTlz5gwGDRqEZ8+eccNBiLL8/HzY29tj69atePPNN7UdhzRB1AGJENJiyeVyZGVlYe3atTA1NcXIkSO1HYk0UVRMCSEtVnJyMlxcXNCmTRts27YNenr0K5HUDV3mJYQQQuqJhsYQQggh9UTFlBBCCKknKqaEEEJIPVExJYQQQuqJiikhhBBST1RMCSGEkHqiYkoIIYTUExVTQgghpJ7+DzBvqqhFd9RAAAAAAElFTkSuQmCC\n" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Customization\n", - "fig = plot_cycle_score(cycle, X_test, y_test,\n", - " x_label = 'Autora Super Cool Cycle',\n", - " y_label= 'Accuracy Score',\n", - " scorer=accuracy_score,\n", - " figsize=(5,3),\n", - " ylim=[.74, 1],\n", - " xlim=[0, 19],\n", - " plot_kw=dict(linewidth=2.5, color='tab:purple'),\n", - " );\n", - "fig.axes[0].grid()\n", - "fig.axes[0].set_title('Accuracy Over 20 Cycles')\n" - ], - "metadata": { - "collapsed": false - } - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 2 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython2", - "version": "2.7.6" - } - }, - "nbformat": 4, - "nbformat_minor": 0 -} diff --git a/docs/cycle/cycle_scoring_bms.ipynb b/docs/cycle/cycle_scoring_bms.ipynb deleted file mode 100644 index bb45b8878..000000000 --- a/docs/cycle/cycle_scoring_bms.ipynb +++ /dev/null @@ -1,360 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "source": [], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "markdown", - "source": [ - "# Simple Cycle Scoring Example with BMS and Random Sampling\n", - "The aim of this example notebook is to use the AutoRA `Cycle` to recover a ground truth theory from some noisy data using BSM and random sampling. We will evaluate the model with AutoRa's scoring and plotting functions." - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": [ - "# Uncomment the following line when running on Google Colab\n", - "# !pip install autora" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": 1, - "outputs": [], - "source": [ - "import matplotlib.pyplot as plt\n", - "import numpy as np\n", - "import logging\n", - "\n", - "from autora.cycle import Cycle, cycle_specified_score, plot_cycle_score, plot_results_panel_2d\n", - "from sklearn.metrics import r2_score\n", - "from autora.experimentalist.sampler import random_sampler, nearest_values_sampler\n", - "from autora.experimentalist.pipeline import make_pipeline\n", - "from autora.variable import VariableCollection, Variable\n", - "from autora.skl.bms import BMSRegressor" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "markdown", - "source": [ - "## Ground Truth and Problem Space\n", - "The ground truth we are trying to recover will be an oscillating function with a parabolic component.\n", - "The space of allowed x values is reals between -10 and 10 inclusive. We discretize them as we don't currently have a sampler which can sample from the uniform distribution." - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": 2, - "outputs": [ - { - "data": { - "text/plain": "" - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": "
", - "image/png": "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\n" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "def ground_truth(xs):\n", - " oscillating_component = np.sin((4. * xs) - 3.)\n", - " parabolic_component = (-0.1 * xs ** 2.) + (2.5 * xs) + 1.\n", - " ys = oscillating_component + parabolic_component\n", - " return ys\n", - "\n", - "study_metadata = VariableCollection(\n", - " independent_variables=[Variable(name=\"x1\", allowed_values=np.linspace(-10, 10, 500))],\n", - " dependent_variables=[Variable(name=\"y\")],\n", - " )\n", - "\n", - "plt.plot(study_metadata.independent_variables[0].allowed_values, ground_truth(study_metadata.independent_variables[0].allowed_values), c=\"black\", label=\"ground truth\")\n", - "plt.legend()" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "markdown", - "source": [], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "markdown", - "source": [ - "## Experiment Runner\n", - "We create a synthetic experiment that adds noise." - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": 3, - "outputs": [ - { - "data": { - "text/plain": "" - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": "
", - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAioAAAGdCAYAAAA8F1jjAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAABUIklEQVR4nO3dd1xV5R8H8M9lXUAZBsgolovcmqmB5cptqWmaWopmKoYTF7hwpKDi1sBcaJTlSE1NzUzzl+LWVHCigAvE2CAg9z6/P/h5fyJDwHs598Ln/XrdF9xznvOc7+EwvjznGTIhhAARERGRFtKTOgAiIiKiojBRISIiIq3FRIWIiIi0FhMVIiIi0lpMVIiIiEhrMVEhIiIircVEhYiIiLQWExUiIiLSWjqfqAghkJqaCs5bR0REVPHofKKSlpYGCwsLpKWlSR0KERERqZnOJypERERUcTFRISIiIq3FRIWIiIi0FhMVIiIi0lpMVIiIiEhrGUgdQHkQQiA3NxcKhULqUEjL6Ovrw8DAADKZTOpQiIioEBU+UcnJycGjR4+QmZkpdSikpUxNTWFvbw8jIyOpQyEiopdU6ERFqVTi7t270NfXh4ODA4yMjPifM6kIIZCTk4OEhATcvXsXtWvXhp4en4YSEWmTCp2o5OTkQKlUwtHREaamplKHQ1rIxMQEhoaGiImJQU5ODoyNjaUOiYiIXlAp/n3kf8lUHH5/EBFpL/6GJiIiIq3FRIVKbMiQIejVq5fUYRARUSXCRIWIiIi0FhMVIiIi0lpMVLTUjh070LBhQ5iYmMDKygodOnRARkYGzp49i44dO8La2hoWFhZo06YNLly4kO9YmUyGtWvX4qOPPoKpqSnq1q2L8PBw3L59G23btkWVKlXg4eGBqKgo1TGzZ89GkyZNsHbtWtUoqX79+iElJaXIGJVKJQICAuDq6goTExM0btwYO3bsUO1PSkrC559/DhsbG5iYmKB27drYtGmT+r9YRESEkBDAxSXvY0XCREULPXr0CAMGDMCXX36Ja9eu4dixY+jduzeEEEhLS4Onpyf+/vtvnDp1CrVr10a3bt2QlpaWr4558+Zh8ODBuHTpEt5++20MHDgQI0eOhJ+fH86dOwchBEaPHp3vmNu3b2Pbtm3Yu3cvDh48iIsXL+Lrr78uMs6AgABs2bIFISEhiIiIwIQJE/DFF1/gr7/+AgDMnDkTkZGROHDgAK5du4bg4GBYW1ur/wtGREQIDARiYvI+VihCx6WkpAgAIiUlpcC+p0+fisjISPH06VMJIiu78+fPCwAiOjr6lWUVCoUwMzMTe/fuVW0DIGbMmKF6Hx4eLgCIDRs2qLZt3bpVGBsbq977+/sLfX19cf/+fdW2AwcOCD09PfHo0SMhhBCenp6iZ8+eQgghsrKyhKmpqTh58mS+eIYNGyYGDBgghBDi448/FkOHDi3FlUtDV79PiIheFBwshLNz3seKhC0qWqhx48b48MMP0bBhQ/Tt2xfr1q1DUlISACA+Ph7Dhw9H7dq1YWFhAXNzc6SnpyM2NjZfHY0aNVJ9bmtrCwBo2LBhvm1ZWVlITU1VbXNycsKbb76peu/u7g6lUokbN24UiPH27dvIzMxEx44dUbVqVdVry5YtqkdKo0aNwk8//YQmTZpgypQpOHnypBq+OkREVBgvLyA6Ou8jUHEeBTFRKaHyvOH6+vo4fPgwDhw4gHr16mHVqlVwc3PD3bt34enpiUuXLmHFihU4efIkLl26BCsrK+Tk5OSrw9DQUPX582UDCtumVCrLFGN6ejoAYP/+/bh06ZLqFRkZqeqn0rVrV8TExGDChAl4+PAhPvzwQ0yaNKlM5yMioqIJIZCYmIinT5+qtlWUR0FMVEqovG+4TCZDq1atMGfOHFy8eBFGRkbYtWsXTpw4gbFjx6Jbt26oX78+5HI5njx5opZzxsbG4uHDh6r3p06dgp6eHtzc3AqUrVevHuRyOWJjY1GrVq18L0dHR1U5GxsbeHp6IiwsDMuXL8d3332nlliJiAi4ceMGhg4dCisrK1hZWcHU1BQNGjTAokWL4OOTCWdnwNdX6ihfT4Ve60edfH3zkpTyuOGnT5/GkSNH0KlTJ1SvXh2nT59GQkIC6tati9q1a+P777/Hu+++i9TUVEyePBkmJiZqOa+xsTE8PT0RFBSE1NRUjB07Fv369YOdnV2BsmZmZpg0aRImTJgApVKJ999/HykpKThx4gTMzc3h6emJWbNmoVmzZqhfvz6ys7Oxb98+1K1bVy2xEhFVZkIILFmyBNOmTcOzZ8/y7YuIiMDUqVNRs+Z3CA1dj7Zt20oTpJqwRaWEXn72p0nm5uY4fvw4unXrhjp16mDGjBlYsmQJunbtig0bNiApKQnvvPMOBg0ahLFjx6J69epqOW+tWrXQu3dvdOvWDZ06dUKjRo3w7bffFll+3rx5mDlzJgICAlC3bl106dIF+/fvh6urKwDAyMgIfn5+aNSoEVq3bg19fX389NNPaomViKiyUiqVaN9+HCZPnoxnz56hW7duOH78OLKyshAfH4/169fjrbfeQlRUFNq1a4egoCAIIaQOu8xkQpejB5CamgoLCwukpKTA3Nw8376srCzcvXsXrq6uXBX3FWbPno3du3fj0qVLUodS7vh9QkS6QgiBkSNHYt26dQCAatWW499/x6r6HT6XmpqKCRMmYOPGjQCA0aNHY8WKFTq5CKvuRUxERFRJLVmyBOvWrYNMpgcrqzAsWDCuQJIC5LXMr1+/HkuWLAEArF69GkOHDkVubm55h/zamKgQERFpuZAQwNb2N0yZMgUAsHz5Mjx58nmx3RFkMhl8fHzw448/Ql9fH1u2bMHnn39eoE+LtmOiQgDyHv1Uxsc+RES64JtvHuDx48GqRz9jxowp8bEDBgzA9u3bYWhoiG3btqFv377Izs4GUPjUGy9uE0Lg9OnT6r2YUmKiQkREpMUUCgWqVBkE4F84OjbFihUrCn3cU5xPPvkEu3fvhlwux549e9CzZ09kZmYWOvXG820BAUpMnDgR7733nqTrtDFRISIiKoP09HRcvXoVt2/fhkKh0Nh5Fi5ciJs3j6JKlSr444+fIJfLy1RPt27dsH//fpiamuLQoUN4//338eWXtwvMteLrCzg5PYODw5dYtmwZAOSbxby8MVEhIiIqhfDwcHTr1g2WlpZo2LAhateuDSsrK4waNQqPHj1S+7lmzZoFAFizZg3q1KnzWvV9+OGHOHToEKytrXHx4kUEBb0Db+/F6N8/GUDe0OfatY/AyqolTp3arOrbMm7cuNe9lDLj8GSq9Ph9QkQloVQq4efnh0WLFqm2VatWDVlZWaqp66tWrYo5c+Zg/Pjxrz0UODk5GU2aNEFMTAwGDhyIsLCwUj/yKcqDBw8wcOBAHD9+HEDe0i0uLi5ISkpCYmIigLxrCwsLQ7du3dRyzrJiiwoREdErKBQKfPnll6okxdPTEzdv3kRiYiLS0tJw5MgRtGzZEunp6Zg4cSI+/fRTpKWllajuwjq0CiEwfPhwxMTEoGbNmggODlZbkgIAb775Jv78809s3LgRDRo0gEKhQFRUFBITE2FmZoavv/4aERERkicpAACJVm1Wm5SUFAFApKSkFNj39OlTERkZKZ4+fSpBZKQr+H1CRMVRKpXC09NTABD6+voiLCxMCCFEcLAQzs55H4UQQqFQiODgYGFkZCQAiAYNGoj582PylSmMs7MQQN7H59auXSsACAMDA3HmzBkNXdn/xcbGiv/85z/i4sWLWve7kIkKqcWmTZuEhYWF1GEIT09P0bNnz1Idw+8TIirOokWLVEnDjh07VNsLSzCEECI8PFzY29v/L7GxE8D5AmVe9HLCc+LECSGXywUAsXjxYrVey8vn0gV89EPlIjo6GjKZTG1ztai7PiKiwvzxxx/w/d+QmJUrV6JPnz6qfb6+KHR14vfeew+nT5/+3yOVOMhkrdG9+74iz/HiWnJRUVHo2bMnsrOz0atXL/j4+Kj1egobjqztmKhUEDk5OVKHoBYV5TqISPc9efIEX3zxBZRKJYYOHQqvl6aBLW6xWkdHR/z999/o2LEjhMhASEhPrFmzptjzRUZGol27dnjy5AmaNWuGsLAwta/NU1Rypc2YqGihtLQ0fP7556hSpQrs7e2xbNkytG3bFuPHj1eVcXFxwbx58zB48GCYm5tjxIgRAICdO3eifv36kMvlcHFxUa3z8JxMJsPu3bvzbbO0tERoaCiA/7dU/PLLL2jXrh1MTU3RuHFjhIeH5zsmNDQUTk5OMDU1xSeffIJ///232Gt6vqJy06ZNIZPJVMuODxkyBL169cL8+fPh4OAANze3EsVZVH3PBQUFwd7eHlZWVvD29ta5KaOJSFrBwQLOzqMQHx+PevXqYc2aNaXuzGphYYH9+/dj2LBhUCqVGD16NPr06YMHDx4UKHvgwAG8//77uHfvHtzc3LB3715UqVJFXZejUlxypa0MpA6gPAkhkJmZKcm5TU1NS/xN7uPjgxMnTuDXX3+Fra0tZs2ahQsXLqBJkyb5ygUFBWHWrFnw9/cHAJw/fx79+vXD7Nmz8dlnn+HkyZP4+uuvYWVlhSFDhpQq3unTpyMoKAi1a9fG9OnTMWDAANy+fRsGBgY4ffo0hg0bhoCAAPTq1QsHDx5UxVCUM2fOoEWLFvjjjz9Qv359GBkZqfYdOXIE5ubmOHz4cInjK66+o0ePwt7eHkePHsXt27fx2WefoUmTJhg+fHipvgZEVHnNmrUVmZk7ABhgy5YtMDExKVM9hoaGWLduHWrVqoWZM2fil19+wcGDB9G3b1+0aNECmZmZ2LdvH/766y8AeY+N9u3bBysrKzVejY6TupPM6ypNZ9r09HQBQJJXenp6ia4nNTVVGBoaiu3bt6u2JScnC1NTUzFu3DjVNmdnZ9GrV698xw4cOFB07Ngx37bJkyeLevXqqd4DELt27cpXxsLCQmzatEkIIcTdu3cFALF+/XrV/oiICAFAXLt2TQghxIABA0S3bt3y1fHZZ58V25n2eb0XL17Mt93T01PY2tqK7OzsfNtLGmdh9Tk7O4vc3FzVtr59+4rPPvusyNjYmZaIXnT//n1hYmIpAIiPPpqjtnovX74s3N3dC/0bYWBgICZMmCAyMjLUdr6Kgo9+tMydO3fw7NkztGjRQrXNwsJC9UjkRe+++26+99euXUOrVq3ybWvVqhVu3bpV6umdGzVqpPrc3t4eAPD48WPVeVq2bJmvvLu7e6nqf1HDhg3ztYi8rvr160NfX1/13t7eXhU7EemGwuYW0cQxLxNC4KuvvsLTp8l499138csvfiWu+1VlGjZsiBMnTuD48eOYPHkyevXqhc8++wyBgYGIiorC0qVLYWpqWvbgK6hK9ejH1NQU6enpkp1b3cry/FImk0G8NBlxYf03DA0N8x0D5M3KqAmFXUdJ4yzMi7E/r0tTsRORZrw4OuXl/hS5ubmQyWT5/iF51TEltW7dOhw8eBByuRxbtmxR/T4pSd0lKbN2rQyBgR/A1/cDvDDBbT4hIXl1+PrqVl8STalULSoymQxVqlSR5FXS/ik1atSAoaEhzp49q9qWkpKCmzdvvvLYunXr4sSJE/m2nThxAnXq1FH9QNvY2ORbi+LWrVul7rdTt27dAst+nzp1qthjnreYlLRl51VxlrY+ItItL49OefToESZPnqz6HWlsbIwmTZpg4cKFqn9ACxvRUppWljt37qiGAy9YsAB169YtMp6SxFyYkgwP1sUhxJpUqRIVXWBmZgZPT09MnjwZR48eRUREBIYNGwY9Pb1XJjsTJ07EkSNHMG/ePNy8eRObN2/G6tWrMWnSJFWZ9u3bY/Xq1bh48SLOnTsHLy+vAi0QrzJ27FgcPHgQQUFBuHXrFlavXo2DBw8We0z16tVhYmKCgwcPIj4+HikpKcWWf1Wcpa2PiHTLi6NTwsLCUKOGG4KCgnD37l0Aea0q//zzD3x9fVGjRg2sX78eI0eKAiNaSvpHX6FQYOjQocjIyMAHH3xQYBG+koyWKUkZdSU8lQkTFS20dOlSuLu746OPPkKHDh3QqlUr1K1b95UL5r3zzjvYtm0bfvrpJzRo0ACzZs3C3Llz8434WbJkCRwdHfHBBx9g4MCBmDRpUqkfS7333ntYt24dVqxYgcaNG+P333/HjBkzij3GwMAAK1euxNq1a+Hg4ICePXsWW/5VcZa2PiLSPUIIzJs3D4MGDUJWVhqAFrCx2YX4+HjExMRg/fr1qFWrFhISEjB8+HD06dNHtaDecyX9oz937lwcP34cVapUwaZNmwo8VlIXdSU8lYq0fXlfX2WYQj89PV1YWFjkG4lD6lNRvk+IKpoVK1aoRsV06TJNODnlFpj6PScnRyxevFgYGhoKAMLFxUVcuHChVOfZt2+f6jybN29W4xWQOrBFRQtdvHgRW7duRVRUFC5cuIDPP/8cANhqQESVxsGDBzFhwgQAwPz583HgwHzExOgXaGUwNDTEpEmTcOrUKdSoUQPR0dHw8PBAWFhYic5z9uxZDBw4EAAwatQoDB48WK3XQa+PiYqWCgoKQuPGjdGhQwdkZGTgP//5D6ytraUOi4hI4+7du4f+/furpq738/N75THvvPMOzp07h65duyIrKwuDBg3C2LFj8fTp0yKPOX/+PDp16oTU1FS0bt0ay5YtU+dlkJowUdFCTZs2xfnz55Geno7ExEQcPnwYDRs2lDosIiKNE0Jg5MiRSElJQcuWLREcHFziUZPVqlXD3r17MXPmTADAqlWr0LBhQ+zfvz/fdAcKhQIhISFo3bo1kpOT4eHhgX379kEul2vkmuj1MFEhIqISUceEaq8SFhaGAwcOwMjICJs2bSo2eSgsHn19fcydOxf79u3Dm2++iaioKHz00UeoU6cOPD098cUXX8DV1RWjRo1CZmYmOnbsiAMHDsDMzExzF0WvRSbES7Nq6ZjU1FRYWFggJSUF5ubm+fZlZWXh7t27cHV1feWIGaq8+H1CVFBhk465uOQN9XV2zhuVom7PFwBMTEzE/PnzMW3atGLLvyqetLQ0zJ07F8HBwcjIyMi3T0/PCn36zMTWraM1NsKH1KNStKjoeC5GGsbvD6KCCpt/RFPzezxvGenWbTQSExPRpEkTTJ48+ZXHvSoeMzMzLF68GI8ePcKuXbsQEBCAwMBA2NjshVJ5H2fOjGOSogMqdIuKQqHAzZs3Ub16da5ESUX6999/8fjx43wz+BJVduU5jXtey8gvAPpAX18fZ8+eRdOmTTV2Pk5Rr1sqdKIC5E27nJycjOrVq8PU1LTEnbKo4hNCIDMzE48fP4alpaVq8UUiKl9LliRiypR6UCrjMW3aNMyfP1/qkEiLVPhFCe3s7ACAq+dSkSwtLVXfJ0RU/q5enQilMh5vv/22asQO0XMVPlGRyWSwt7dH9erVS7z6LlUehoaGfNxDVEYleYTyqjKHDh1CaGgoZDIZNm7cyA7tVECFf/RDRESaUZJRQMWVSUtLQ4MGDRAbG4tx48Zh+fLlGo23KOyzot0qxagfIiIqmzt37mDp0qUYMWIERo0ahdWrV+PBgwcAXn8l4AkTJiA2Nhaurq6S9ksp6QrLJA22qBARUQFJSUmYNGkSQkNDoVQq8+0zMDBA//79MWfOHNSoUaNM9e/YsQN9+/aFTCbD0aNH0aZNG3WEXSZsUdFuTFSIiCifW7duoWvXroiKigIAtG/fHh988AFyc3Nx9OhRnDx5EgBgYmKCuXPnYsKECaXq6xUVFYV3330XycnJ8PPzw4IFCzRyHVQxMFEhIiKV+/fvw8PDA/fu3YOzszN++OEHtGrVKl+Zc+fOYcqUKTh69CgAwMPDA1u2bEHNmjVfWf+TJ0/g4eGBW7duoUWLFvj7779haGiokWuhikGjfVSOHz+Ojz/+GA4ODpDJZNi9e3e+/UIIzJo1C/b29jAxMUGHDh1w69YtTYZERFTplHSNnuTkZHTp0gX37t2Dm5sbTp8+XSBJAYB3330XR44cwfr162FmZoaTJ0+icePGWLduXbEzPScnJ+Pjjz/GrVu34OzsjN27dzNJoVfSaKKSkZGBxo0bY82aNYXuX7RoEVauXImQkBCcPn0aVapUQefOnZGVlaXJsIiIKpWXO4sWlrgIITBs2DBERETAwcEBhw4dgq2tbZF1ymQyDBs2DJcvX0abNm2QkZGBESNGoH79LnBwuFggKbpw4QLc3d1x6tQpWFpa4sCBA5xkkUpGlBMAYteuXar3SqVS2NnZicWLF6u2JScnC7lcLrZu3VrielNSUgQAkZKSos5wiYgqjOBgIZyd8z4Kkfc5kPfxufXr1wsAwtDQUJw9e7ZU9SsUChEUFCSMjIwEAAFAGBu3F7NmzRLz5s0T3bp1EzKZTAAQDg4O4tKlS+q6NKoEJEtUoqKiBABx8eLFfOVat24txo4dW2Q9WVlZIiUlRfW6d+8eExUiolJ4OXGJiooSpqamAoBYuHBhmeu9efOmaNHicwHIVAnLi68BAwaIx48fq+ciqNKQbGbauLg4ACjQtGhra6vaV5iAgADMmTNHo7EREVVkXl7/H4YrhMCYMWOQmZmJtm3bYtKkSWWut3bt2jh9Ogx3787Dr7/+ioiICCgUCtSpUwe9evWCm5ubmq6AKhOdm0Lfz88PPj4+qvepqalwdHSUMCIiIt21e/du/PbbbzAyMsLatWuhp/f6XRddXV0xbtw4NURHJOHMtM8XgYuPj8+3PT4+vtgF4uRyOczNzfO9iIio9DIyMlQJRfv2k9GpU51XjgwiKm+SJSqurq6ws7PDkSNHVNtSU1Nx+vRpuLu7SxUWEVGlMW/ePNy7dw8uLi6IiJhWbtPIl3S4NBGg4UQlPT0dly5dwqVLlwAAd+/exaVLlxAbGwuZTIbx48fjm2++wa+//oorV65g8ODBcHBwQK9evTQZFhGR1invP96RkZFYsmQJAGDVqlWYNs30lev2qAvX1qHS0OjMtMeOHUO7du0KbPf09ERoaCiEEPD398d3332H5ORkvP/++/j2229Rp06dEp+DM9MSUUVQkpWI1UUIgfbt2+PYsWPo0aMH9uzZo9kTvoRr61BpcAp9IiItUJ5/vL///nsMHjwYJiYmiIyMhIuLi2ZPSPQamKgQEVUiiYmJePvtt5GQkIDAwEBMnTpV6pCIiiVZZ1oiIip/fn5+SEhIQL169TBhwgSpwyF6JSYqRESVRHh4OL777jsAQHBwMIyMjCSOiOjVmKgQEVUC6enp8PT0BAAMGTIErVu3ljgiopJhokJEpEUyMzOxfPlytGrVCtWqVUO1atXw3nvvYfHixcUuL/Iq48aNw61bt+Do6IilS5eqMWIizWJnWiIiLfHXX3/hiy++wP379wvdb2hoCG9vb8ycORNvvPFGievduHEjhg0bBplMhqNHj6JNmzbqCplI49iiQkSkBX788Ud06NAB9+/fh7OzM1avXg17+ysAruCNN9bivffew7Nnz7B8+XLUqlULISEhUCgUr6x33759GDFiBABg5syZTFJI5zBRISKS2O+//47BgwcjNzcX/fv3x9WrV+Ht7Y1ZsxrA2bkB5s8fgfDwcBw6dAgNGjRAUlISRo0ahRYtWuDUqVNF1rtr1y7069cPCoUCnp6emD17dvldFJGa8NEPEZGEIiIi4OHhgdTUVAwaNAihoaHFrmCcm5uL4OBgzJw5EykpKQCAXr16YcSIEWjbti02bZLjm2+uwMlpCU6f/h4A8PHHH2Pnzp0wNDQsl2siUicmKkREEsnKysI777yDa9euoXXr1vj9998hl8tLdOzjx4/h5+eHjRs3vrRHH8D/Hwn5+Phg4cKFMDAwUF/gROWIj36IiCQyY8YMXLt2DXZ2dti5c2eJkxQAqF69OjZs2IBZsyJgZjYO5uZ2/9ujgExmgiZNPsGpU6ewZMkSJimk09iiQkQkgRMnTuCDDz6AEAL79u1D9+7dy1TP88UMnZwEzp//F9nZ2bC1tWVyQhUGW1SIiMqZQqGAt7c3hBD48ssvy5ykAHmLGDo7A35+MlhbW+PNN99kkkIVChMVIqJytn79evzzzz+oVq0aFi1aVOLjQkLyWlBCQv6/zcsLiI7W/IrLRFJhokJEVI6SkpIwffr0/72bg+3brUp8bGBg3mOewEDNxEakjZioEBGVo7lz5+Lff/+FoWE9JCV5lSrpeP6Yx9dXc/ERaRsmKkREpVDY45eSunbtGlavXg0AGDVqOZydDUuVdPAxD1VGHPVDRFQKz0fZODvnJQ0lJYRA165dcejQIfTo0QN79uzRVIhEFQpbVIiISqGsj1/279+PQ4cOwdDQEEuWLNFMcEQVEFtUiIg0LCcnB/Xr18ft27cxZcoULFy4UOqQiHQGW1SIiIrwOv1RXrRy5Urcvn0btra2L4z4IaKSYIsKEVERytof5UXx8fGoXbs20tLSsHHjRgwdOlSdIRJVeGxRISIqgjqGA/v5+SEtLQ3NmjWDp6en+oIjqiTYokJEpCF//PEHOnbsCACwtT2B2bM9OLSYqJTYokJEpAFpaWkYNmwYAMDMzBvx8R6cUZaoDJioEBG9IDc3Fzk5Oa9VhxACY8aMQWxsLFxcXDB3biBnlCUqIyYqRFTpJScnY+7cuahfvz6MjIwgl8vh5OSEkSNH4s8//0Rpn5CvWrUKmzdvhp6eHjZu3Ijx46tyRlmiMmIfFSKq1A4cOABPT08kJCQUWaZZs2aYMWMGevbsCZlMVmx9+/btQ69evaBQKLBkyRL4+PioO2SiSoUtKkRUaW3YsAHdu3dHQkIC6tati7CwMNy/fx8JCQk4ePAgRowYAVNTU5w/fx6ffPIJWrRogUOHDhXawiKEwIYNG9C7d28oFAoMHjwYEyZMkOCqiCoWtqgQUaW0d+9e9OzZE0IIDBs2DGvWrIFcLi9Q7smTJ1i2bBlWrFiBjIwMAECDBg0wdOhQtG7dGmZmZrh69Sq+/fZb/PnnnwCA/v37Y8uWLTA0NCzXayKqiJioEFGlExkZiffeew9paWkYOXIkgoODIZPJEBICBAbmdXp9uT/J48ePERgYiODgYGRlZRVar5GREebMmYMpU6ZAT48N1kTqwESFiCqVp0+fomnTprhx4wbatGmDw4cPq1o+SjITbXJyMn788Ufs2rULV65cwdOnT+Hk5ITOnTvD29sbrq6u5XYtRJUBExUiqlSmTp2KRYsWwcHBAZcuXYKNjY1qX3EtKkQkDbZNElGlce7cOQQFBQEAevYMQfPmNvkWHPTyQqmHERe2cKG6FjMkIraoEFEloVQq0bJlS5w7dw79+/dHePjW115wECj8cZE6FjMkojxsUSGiSmHbtm04d+4cqlatiuXLl6tlwUGg8IUL1VU3EbFFhYgqgezsbLz99tuIjo7GvHnzMGPGDKlDIqISYosKEVV43377LaKjo2Fvb89J2Ih0DBMVIqrQkpKSMG/ePADAvHnzUKVKFYkjIqLSYKJCRBVaYGAgkpKSUL9+fXh6ekodDhGVEhMVIqqwYmNjsWLFCgDA48cLsX69gcQREVFpMVEhogpr5syZyM7OhlzeFgkJ3RAYKHVERFRaTFSIqEK6dOkSvv/+ewDA+PGL4Ows43BhIh3E4clEVCF16tQJhw8fRv/+/bF161apwyGiMmKLChFVOAcOHFAtNjh//nypwyGi18BEhYh02svr6uTk5KjmShk7dixq1KghXXBE9NqYqBCRTnk5MQkMzFtX53lH2TVr1uDGjRuwsbHBzJkzJYuTiNSDiQoR6ZSXE5MX19W5d+8eZs+eDQBYsGABLCwspAuUiNSCiQoR6ZSXF/zz8spboXjkSIERI0YgNTUVLi4tMW/eUFWrCxHpLo76IaIKYePGjRg2bBjkcjmsrC7h4cO34eycl8QQke7iNI1EpPPOnDkDb29vAHnr+ZiZvY3AQHDeFKIKgC0qRCQJpVKJAwcO4KeffsI///yDp0+fwsnJCe+//z569OiBZs2alaiee/fuoUWLFoiLi0P37t2xZ88e6Ovrazh6IiovTFSIqNxFRUXB09MTJ06cKLLMu+++i1GjRqF///4wNTUttExkZCS6d++O6OhoNGjQACdOnODvAaIKhokKEZWrM2fOoGvXrkhMTESVKlUwfPhwdOzYEebm5oiIiMCRI0ewZ88e5OTkAAAsLS0xePBg9OjRA61atYJcLkdMTAw2btyIoKAgPH36FLVq1cKRI0fg5OQk8dURkboxUSGicnPjxg20atUK//77L1q0aIHt27cXmlwkJCQgNDQUISEhuHPnTr59crkc2dnZqvcdO3ZEWFgYqlevrvH4iaj8MVEhonKRkJCA5s2bIyYmBs2bN8eff/6JqlWrFnuMUqnEoUOH8PPPP+P333/Ho0ePAAD6+vrw8PDAmDFj8Omnn0Imk5XHJRCRBLQiUVmzZg0WL16MuLg4NG7cGKtWrUKLFi1KdCwTFSLtJ4RAnz59sGvXLtSqVQsnT56EjY1NqetISEhAZmYmbG1tYWJioqFoiUibSD7h288//wwfHx/4+/vjwoULaNy4MTp37ozHjx9LHRoRqUlYWBh27doFQ0NDbN++vdRJCgDIZDJUr14dLi4uTFKIKhHJW1RatmyJ5s2bY/Xq1QDymnodHR0xZswY+JZgEgS2qBBpt/j4eLi5uSElJQXz58/HtGnTpA6JiHSIpC0qOTk5OH/+PDp06KDapqenhw4dOiA8PLzQY7Kzs5GamprvRUTaa8aMGUhJSUGzZs0wZcoUqcMhIh0jaaLy5MkTKBQK2Nra5ttua2uLuLi4Qo8JCAiAhYWF6uXo6FgeoRJRGVy4cAEbNmwAAKxcuRIGBv+fDPvlVZCJiAojeR+V0vLz80NKSorqde/ePalDIqKXhIQAzs4C/ftPgBACAwcOhIeHR74yL6+CTERUGEnX+rG2toa+vj7i4+PzbY+Pj4ednV2hx8jlcsjl8vIIj4jKKDAQiI39HcBxGBsbI7CQbMTXF1yPh4heSdIWFSMjIzRr1gxHjhxRbVMqlThy5Ajc3d0ljIyIXsfUqQJGRjMAAF9//XWhj2i9vPJWNvbyKufgiEinSP7ox8fHB+vWrcPmzZtx7do1jBo1ChkZGRg6dKjUoRFRGTk4/IqcnHOoUqUKpk6dWuLjXu63wn4sRCT58GQAWL16tWrCtyZNmmDlypVo2bJliY7l8GQi7aJUKtGkSRNcuXIF06ZNw/z580t8rItLXr8VZ+e81paX3xNR5SN5iwoAjB49GjExMcjOzsbp06dLnKQQkfbZvn07rly5AgsLC0yaNKlUx/r65iUlz/utvPyeiCofrWhReR1sUSHSHrm5uWjQoAFu3LiBuXPnYubMmap9ISH/7zzLfilEVFJMVIhIbUJDQzF06FBYWVnhzp07+X4m+RiHiMpCKx79EJHuy8rKgr+/PwBg6tSpBf5x4GMcIioLtqgQkVosX74cEyZMwJtvvolbt25x4UAiUgu2qBDRa1u2LBUTJ+aN7pk9ezaTFCJSG7aoENFrs7T0R0rKXBgYuOHp06v51vQhInodbFEhotcSFxeHrKwlAIChQ+czSSEitWKiQkSvxcfHB9nZGWjRogXWru0tdThEVMEwUSGiMjt8+DC2bt0KPT09fPvtt5DJZFKHREQVDBMVIiqTtLQ0fP311wDyZpdu1qyZxBERUUXERIWISk0IgREjRuD27dt46623MG/ePKlDIqIKiokKEZXamjVr8NNPP8HAwAA///wzR9wRkcawez5RJSOEwKVLl3D+/HmkpqbCwcEB9erVQ4MGDaCn9+r/XX744QeMGzcOALBw4UJ4eHhoOmQiqsSYqBBVIr/++iv8/PwQGRlZYJ+dnR0++eQT9O7dG23atIGhoWG+/VlZWZg7dy4CAgIAAMOHD8eECRPKJW4iqrw44RtRJfDs2TOMGTMGa9euBQCYmpri/fffh5WVFWJiYnDlyhWkpaWpyltaWqJ9+/Zo2LAhLC0tcfv2bezcuRNxcXEAgPHjxyMoKAj6+vqSXA8RVR5MVIgqOKVSiQEDBmDbtm2QyWSYNGkSpk+fDgsLC1WZnJwcHDlyBDt37sSvv/6KhISEQutydHTEsmXL0KdPn/IKn4gqOSYqRBXctGnTEBAQAENDQ+zYsQM9evQotrxCoUB4eDjOnDmDyMhIbN2ajsxMe9jYtMH9+92wcaMRAgPzVkH28iqniyCiSouJClEFtnXrVgwcOBAAsHnzZgwePLjUdYSEIF9i4uICxMQAzs5AdLR64yUiehkTFaIKKi4uDvXq1UNSUhL8/PywYMECtdT7cuJCRKRJnEeFqAISQuDrr79GUlIS3nnnHcyZMwchIXmtISEhr1e3l1deSwqTFCIqD0xUiCqg/fv3Y9euXQAM0LXrRhgaGiIwMO+RTWCg1NEREZUcExWiCuDF1hIhBGbOnPm/PT4IC2sMIO9RjbNz3kciIl3BRIWoAnixtWT37t24dOkSjI3N8NZbU1SJSWGPbF5+HKSux0NEROrCzrREFcDzDq5TpigREtIEV65cwcyZMzF37txij3t5BA9H9BCRtmGLClEF8Ly1xMZmJ65cuQILC4sSTW//8uMgPh4iIm3DFhWiCkKhUKBRo0aIjIzEnDlzMGvWLKlDIiJ6bWxRIaogtm3bhsjISFSrVk21ujERka5jokJUAeTm5mL27NkAgEmTJuVbx4eISJcxUSHSQS+Pzvnxxx9x8+ZNWFlZYcyYMZLGRkSkTkxUiHTQi8ORnz17phrdM2XKFJiZmUkcHRGR+jBRIdJBL47O+f777xEVFQUbGxt4e3tLHRoRkVoZSB0AEZWel1feKycnB25u8wAAvr6+qFKlisSRERGpF1tUiHRYaGgooqOjYWdnBy+uEkhEFRATFSIdlZ2djW+++QYA4OfnB1NTU4kjIiJSPyYqRDpq/fr1uHfvHhwcHDBixAipwyEi0ggmKkRapiQLA6anp6tG+syYMQPGxsblExwRUTljokKkZV4celyUZcuW4fHjx6hVqxa++uqr8guOiKicMVEh0jKvWhjw8ePHWLRoEQBg/vz5MDQ0LMfoiIjKFxclJNIxQ4YMwebNm9GsWTOcOXMGenr8f4OIKi7+hiMqRyXpf1Kco0ePYvPmzZDJZFi9ejWTFCKq8NiiQlSOXFzy+p84OwPR0aU7NjMzE02bNsXNmzfx9ddfY82aNZoIkYhIq/DfMaJy9Kr+J0URQmD48OG4efMm7O3tsWDBAs0ESESkZdiiQqQDVqxYgfHjx0NfXx9HjhxBmzZtpA6JiKhcsEWFSEIl6bOyceNGTJgwAQAQFBTEJIWIKhW2qBBpSEhI3lwovr5Ap0538MMPP+DMmTNIT0+HTCZDnTp1sH17IyQmusPJqSFiYvKvEZqUlITp06cjODgYAODl5YVvv/0WMplMisshIpIEExUiDcnrOJuBqlWnIDMzBEqlssiycnlVvP9+S9SqVQumpqa4e/cufv/9d2RmZgIApk2bhnnz5nGUDxFVOkxUiDQkMPAhZs3qgmfPrgAAOnXqhB49esDa2ho5OTm4fv06zp8/j/DwcKSmphZaR6NGjbB06VJ8+OGH5Rk6EZHWMHh1ESIqraSkJGza1A7Pnt2EnZ0dvv/+e3To0KHQsgqFApGRkQgPD0dcXBzS09NhZ2eHDz74AO+++y4f9RBRpcYWFSI1y83NRffu3fH777/DyckJf/31F1xcXKQOi4hIJ/GBN5GazZw5E7///jtMTU2xZ88eJilERK+BiQqRmoSEAPb257FwYd6CgZs2bUKTJk3UUu/rTLtPRKTL+OiHSE2cnXMRG9sCwEUMGDAAP/74o1rqfZ1p94mIdB1bVIjUpGXLNQAuwtS0GpYtW6a2ess67T4RUUXAFhUiNUhJSUGNGjWQmJiItWvXYsSIEVKHRERUIbBFhUgNFi9ejMTERNStWxdffvml1OEQEVUYGktU5s+fDw8PD5iamsLS0rLQMrGxsejevTtMTU1RvXp1TJ48Gbm5uZoKiUgj4uLiVI96FixYAAMDTk9ERKQuGvuNmpOTg759+8Ld3R0bNmwosF+hUKB79+6ws7PDyZMn8ejRIwwePBiGhoZcwp50SlBQEDIzM/Hee++hZ8+eUodDRFShaLyPSmhoKMaPH4/k5OR82w8cOICPPvoIDx8+hK2tLQAgJCQEU6dORUJCAoyMjEpUP/uokJQSExPh5OSEjIwM/Pbbb+jatavUIRERVSiS9VEJDw9Hw4YNVUkKAHTu3BmpqamIiIiQKiyiUlm1ahUyMjLQpEkTdOnSRepwiIgqHMkepsfFxeVLUgCo3sfFxRV5XHZ2NrKzs1Xvi1rMjUjT0tPTsXLlSgCAr68v1+QhItKAUrWoPP9lXNzr+vXrmooVABAQEAALCwvVy9HRUaPnIyrKunXrkJiYiFq1auHTTz+VOhwiogqpVC0qEydOxJAhQ4otU6NGjRLVZWdnhzNnzuTbFh8fr9pXFD8/P/j4+Kjep6amMlmhcpednY0lS5YAAKZMmQJ9fX2JIyIiqphKlajY2NjAxsZGLSd2d3fH/Pnz8fjxY1SvXh0AcPjwYZibm6NevXpFHieXyyGXy9USA1FZffVVGB48eAALCwcMHjxY6nCIiCosjfVRiY2NRWJiImJjY6FQKHDp0iUAQK1atVC1alV06tQJ9erVw6BBg7Bo0SLExcVhxowZ8Pb2ZiJCWk2hUOCnnxYCAPT0JvL7lYhIgzSWqMyaNQubN29WvW/atCkA4OjRo2jbti309fWxb98+jBo1Cu7u7qhSpQo8PT0xd+5cTYVEpBY7duxAbu4t6OlVw6xZnCqfiEiTuNYPUSkIIdCkSRNcvnwZs2fPhr+/v9QhERFVaFzrhyqVkBDAxSXvY3Hbijpu9Oj9uHz5MqpWrYoxY8ZoOFoiImKLClUqLi5ATAzg7AxERxe9rfDjBIyMPJCTcwpTpkzBwoULyyVmIqLKjC0qVKn4+uYlJL6+xW8r7Dhb22PIyTkFuVyOCRMmaD5YIiJiiwpRSQgh0LZtWxw/fhze3t5YvXq11CEREVUKbFEhKoHffvsNx48fh7GxMaZOnSp1OERElQYTFaJXUCgU8PPzAwCMHTuWMyETEZUjJipEr7B582ZcuXIFlpaW8C2uIwsREakdExWiYjx+/BiTJ08GAMyYMQPVqlWTOCIiosqFiQpVGCWZD6W0xo8fj8TERDRp0gRjx45VX8VERFQiHPVDFUZJ5kMpjZ9++gkDBgyAnp4ezpw5g2bNmr1+pUREVCpsUaEKoyTzoZTUuXPnMHTo0P/V68skhYhIImxRIXrJzZs30a5dOzx8+BDdunXDr7/+Cn19fanDIiKqlNiiQvQ/Qgjs3r0bHh4eePjwIerVq4cff/yRSQoRkYQMpA6ASFOuX7+O0NBQnDx5EnFxccjKyoKtrS3eeustuLq6okaNGnBycsKzZ88QGxuLHTt24OTJkwAAI6PmGDJkPywsLCS+CiKiyo2PfqjCSUtLw6RJk/Ddd9+V+lhDQ0OYmPggNXUOnJ3laumUS0REZccWFapQHjx4gM6dOyMiIgIA8PHHH+PTTz+Fi4sL5HI54uPjce/ePdy9exd37txBbGwsTExMYG1tjVatWmHgwIH49VcHBAaqp1MuERG9HraoUIXx5MkTeHh44NatW7C3t8fWrVvRpk0bqcMiIqLXwBYVqhAUCgUGDhyIW7duwcXFBceOHYOzs7PUYRER0WviqB+qEGbPno3Dhw/D1NQUe/fuZZJCRFRBMFEhnfTidPnnz5/HggULAADr1q1DgwYNpA2OiIjUhn1USCc9ny7fyUkBW1t3nD17FgMGDMCPP/4odWhERKRGbFEhnfR8uvxWrdbh7NmzMDc3x5IlS/KV0cQihUREVL7YokI6Kz09Ha6urnjy5AlWrFhRYHVjdS9SSERE5Y8tKqSzVq5ciSdPnqBWrVr4+uuvC+xX5yKFREQkDbaokE5KTk6Gq6srkpOT8cMPP2DgwIFSh0RERBrAFhXSScuWLUNycjLq16+Pzz77TOpwiIhIQ5iokM7JyMjA6tWrAQD+/v5c3ZiIqAJjokI6Z9OmTUhMTETNmjXRu3dvqcMhIiINYqJCOkWhUGDp0qUAAB8fH7amEBFVcExUSKf88ssvuHv3LqysrDBkyBCpwyEiIg1jokI6QwiBxYsXAwC8vb1hamoqcURERKRpTFRIZ/znP//B2bNnYWxsDG9vb6nDISKicsBEhXTG89YUT09PVK9eXeJoiIioPDBRIY1S13o7165dw759+yCTyeDj46OW2IiISPsxUSGNCgzMW28nMPD16vnqq7wFBxs16oE6deqoITIiItIFTFRIo9Sx3k5cXBxOnvz+f59PVlNkRESkCwykDoAqNi+vvNfrWLVqFYAcyOXumD27lVriIiIi3cBEhbRaeno6goODAQBbt07GJ59IHBAREZUrPvohrbZx40YkJSWhdu3a6NGjh9ThEBFROWOiQlorJydHNV3+xIkTOV0+EVElxESFtFZoaChiYmJgZ2eHwYMHSx0OERFJgIkKaaXs7Gx88803AAA/Pz+YmJhIHBEREUmBiQpppQ0bNuDevXtwcHDAiBEjpA6HiIgkwkSFtE5ycjJmz54NAJg2bRqMjY2lDYiIiCTDRIW0jr+/PxISEvD2229j+PDhUodDREQSYqJCWuXKlStYs2YNAGDlypUwMjKSOCIiIpISExXSGk+fPsUXX3wBhUKB3r17o2PHjlKHREREEmOiQlrDx8cHly9fho2Nzf+mzSciosqOiQpphXXr1iEkJAQAEBYWBgcHB4kjIiIibcBEhSQlhMCqVaswcuRIAMCsWbPQqVMniaMiIiJtwUSFJBMREYFevXph7NixEELA29tbNSyZiIgI4OrJpGZZWVnYv38//vOf/+DatWtITU2Fvr4+TE1NYWZmBhMTEyQnJyMqKgrXr18HABgYGCAgIAATJ06ETCZDSAgQGAj4+gJeXhJfEBERSUomhBBSB/E6UlNTYWFhgZSUFJibm0sdTqUlhEBYWBh8fX3x8OHDEh1jYGCAHj16YM6cOWjQoIFqu4sLEBMDODsD0dGaiZeIiHQDW1ToteXk5GD48OHYsmULAMDBwQGffvopGjVqBGtraygUCmRmZiI1NRWZmZmwtLSEg4MD3nvvPbzxxhsF6vP1/X+LChERVW5sUaHX8uzZM/Tr1w+7d++Gvr4+5syZg0mTJkEul5e4Dj7qISKiojBRodcyceJELF26FHK5HLt370aXLl1KXQcf9RARUVE0NuonOjoaw4YNg6urK0xMTFCzZk34+/sjJycnX7nLly/jgw8+gLGxMRwdHbFo0SJNhURqtnfvXixduhQA8MMPP5QoSQkJyUtM/jdlCoC8lhRnZz7qISKigjTWR+X69etQKpVYu3YtatWqhatXr2L48OHIyMhAUFAQgLzWkE6dOqFDhw4ICQnBlStX8OWXX8LS0hIjRozQVGikBo8ePYKnpycAYPz48ejTp0+JjgsMzGs9CQz8/2MeLy8+8iEioiKIcrRo0SLh6uqqev/tt9+KatWqiezsbNW2qVOnCjc3txLXmZKSIgCIlJQUtcZKxRs0aJAAIJo1a6a6f8HBQjg7530sSknKEBERPVeuE76lpKTkG+URHh6O1q1b51sht3Pnzrhx4waSkpIKrSM7Oxupqan5XlS+Tp48ie+//x4ymQzBwcGq+/dia0lRvLzy+qGwBYWIiEqi3BKV27dv55sqHQDi4uJga2ubr9zz93FxcYXWExAQAAsLC9XL0dFRc0FTAUqlEmPHjgUAfPnll2jevLlqH/uaEBGRupU6UfH19YVMJiv29XzG0ecePHiALl26oG/fvhg+fPhrBezn54eUlBTV6969e69VH5XO7t27cf78eZiZmWHBggX59rG1hIiI1K3UnWknTpyIIUOGFFumRo0aqs8fPnyIdu3awcPDA999912+cnZ2doiPj8+37fl7Ozu7QuuWy+WlmqOD1EepVGLOnDkA8jrQVq9eXeKIiIiooit1omJjYwMbG5sSlX3w4AHatWuHZs2aYdOmTdDTy9+A4+7ujunTp+PZs2cwNDQEABw+fBhubm6oVq1aaUMjDdu9ezcuX74Mc3NzjB8/XupwiIioEtBYH5UHDx6gbdu2cHJyQlBQEBISEhAXF5ev78nAgQNhZGSEYcOGISIiAj///DNWrFgBHx8fTYVFZSSEwDfffAMAGDduHN54441C50QhIiJSJ43NTBsaGoqhQ4cWuu/FU16+fBne3t44e/YsrK2tMWbMGEydOrXE5+HMtOXjr7/+Qtu2bWFiYoJ79+7BysqKM8oSEZHGcQp9KpFPPvkEu3fvhpeXF4KDgwFwjR4iItI8Jir0Snfu3EGtWrUghEBkZCTq1q0rdUhERFRJlOuEb6SbVq9eDSEEOnfuzCSFiIjKFRMVKtTzjrLLlqVi/fr1AMCRPkREVO746IcK9byjbLVqK5GUNA5ubm6IjIwsMMSciIhIk/hXhwrl6ws4OSlhYLASQN6QZCYpRERU3tiiQkXau3cvevToAUtLS9y/fx9VqlSROiQiIqpk+C8yFWn58uUAgOHDhzNJISIiSTBRoUJdvnwZf/75J/T19TF69GjOQktERJJgokKFWrZsGYC8id6cnJwQGJjXuTYwUOLAiIioUmGiQgU8evQIP/zwA4C81bKBvM61zs55H4mIiMpLqVdPpopvzZo1ePbsGTw8PPDee+8ByJsin9PkExFReWOLCuWTkZGhWsvneWsKERGRVJioUD6bN29GYmIiatSogZ49e0odDhERVXJMVCqY1xmdo1AoVEOSx48fD319fbXGRkREVFqc8K2CeT71vbMzEB1dumN/+OEHfPHFF6hWrRpiY2NRtWpVTYRIRERUYmxRqWDKOjonNzcXc+bMAQBMmjSJSQoREWkFtqgQQkKAGTNC8e+/Q2FtbY07d+7AzMxM6rCIiIjYokLAggWZ+Pff2QCAKVOmMEkhIiKtwUSlEnq5w239+gsAxKBaNUd4e3tLGRoREVE+fPRTCb3Y4fb332+iYcOGyMnJwc6dO9G7d2+pwyMiIlJhi0ol9LzD7eTJzzB06FDk5OSgS5cu+OSTT6QOjYiIKB8mKpWQl1fe0OVbtybj5MmTsLCwwJo1ayCTyaQOjYiIKB8mKpXUhg0bsGLFCgDAli1bUKNGDYkjIiIiKoiJSiUjhMCyZcswfPhwAMD06dPRo0cPiaMiIiIqHBMVHVaa6fKVSiVOnDiBzp07w8fHB0IIjB49GvPmzdN4nERERGXFUT867MXRO3fvCly/fh1Xr17FnTt3kJiYiOTkZCQnJyMpKQn//PMPHj9+DACQy+VYtGgRxowZw34pRESk1QykDoDKztcXCAjIRvPmwWjYcD0iIiKKLW9mZoY+ffpg+vTpqFWrVjlFSUREVHZMVHSYh8dlmJp+hh07rgMAjIyM8M4776BmzZqoXr06LC0tVS8nJyd4eHjAyMhI4qiJiIhKjomKjjp27Bg+/vhjpKenw87ODv7+/ujfvz8sLS2lDo2IiEht2JlWSxXXUfbChQuqJKVdu3a4cuUKvLy8mKQQEVGFw860WurFjrLR0f/fnpKSgiZNmiA6Ohoffvgh9u3bB2NjY6nCJCIi0ii2qGip59Pc+/rm3+7t7Y3o6Gi4uLhg586dTFKIiKhCY4uKDtm+fTv69esHfX19HD9+HB4eHlKHREREpFFsUdERT58+xcSJEwEAfn5+JU5SSjMpHBERkbZhi4qOmD9/PmbMmAFHR0fcuHEDJiYmJTquqL4uREREuoAtKjogLi4OAQEBAIDAwMASJylA0X1diIiIdAFbVHTApEmTsGTJErRo0QKnTp3itPdERFRpsEVFyz158gTBwcEAgNmzZzNJISKiSoWJipZbsWIFMjMz8c4776BLly5Sh0NERFSumKhosbS0NKxatQoAMH36dLamEBFRpcNERYtt2bIFKSkpqFOnDnr16iV1OEREROWOiYqWEkJgzZo1AIDRo0dDT4+3ioiIKh/+9dNSR48exbVr11C1alV4enpKHQ4REZEkmKhoqeetKYMGDVINu+Yss0REVNlwHhUtFBsbC1dXVyiVSly9ehX169cHwFlmiYio8mGLihZau3YtlEol2rVrp0pSAM4yS0RElQ9bVLRMdnY2HB0dkZCQgB07dqBPnz5Sh0RERCQZtqhome3btyMhIQFvvfUWevbsKXU4REREkmKiomWed6L18vKCgYGBxNEQERFJi4mKFjl37hxOnToFQ0NDfPXVV1KHQ0REJDkmKlrkeWtKv379YGtrK3E0RERE0mOioiUWL05AaOhWAHkz0RIRERETFa2xYME6ANkwMmqOli1bSh0OERGRVmCiogWePXsG4FsAwMCBY7hKMhER0f8wUdECu3fvRnLyA1SvXh0hIf2kDoeIiEhrMFHRAitXrgQAjBw5EnK5XOJoiIiItIdGE5UePXrAyckJxsbGsLe3x6BBg/Dw4cN8ZS5fvowPPvgAxsbGcHR0xKJFizQZkta5cOEC/v77bxgYGMDLy0vqcIiIiLSKRhOVdu3aYdu2bbhx4wZ27tyJqKgofPrpp6r9qamp6NSpE5ydnXH+/HksXrwYs2fPxnfffafJsLRKYGAggLwhyQ4ODhJHQ0REpF3Kda2fX3/9Fb169UJ2djYMDQ0RHByM6dOnIy4uDkZGRgAAX19f7N69G9evXy9Rnbq81s/169dRr149CCFw5coVNGjQQOqQiIiItEq59VFJTEzEDz/8AA8PDxgaGgIAwsPD0bp1a1WSAgCdO3fGjRs3kJSUVGg92dnZSE1NzffSVYGBgRBCoGfPnkxSiIiICqHxRGXq1KmoUqUKrKysEBsbiz179qj2xcXFFZiB9fn7uLi4QusLCAiAhYWF6uXo6Ki54DXo1q1bCAsLAwBMnz5d4miIiIi0U6kTFV9fX8hksmJfLz62mTx5Mi5evIjff/8d+vr6GDx4MF7naZOfnx9SUlJUr3v37pW5LilNnjwZCoUC3bp1Q/PmzaUOh4iISCuVenneiRMnYsiQIcWWqVGjhupza2trWFtbo06dOqhbty4cHR1x6tQpuLu7w87ODvHx8fmOff7ezs6u0LrlcrnOD+E9evQo9uzZA319fQQFBUkdDhERkdYqdaJiY2MDGxubMp1MqVQCyOtnAgDu7u6YPn06nj17puq3cvjwYbi5uaFatWplOoe2y8nJwfjx4wEAXl5eqFu3rrQBERERaTGN9VE5ffo0Vq9ejUuXLiEmJgZ//vknBgwYgJo1a8Ld3R0AMHDgQBgZGWHYsGGIiIjAzz//jBUrVsDHx0dTYWlcSAjg4pL3sTCzZs3C5cuX8cYbb8Df379cYyMiItI1GhuefOXKFYwbNw7//PMPMjIyYG9vjy5dumDGjBl48803VeUuX74Mb29vnD17FtbW1hgzZgymTp1a4vNo2/BkFxcgJgZwdgaio/PvO3bsGNq3bw8hBHbu3InevXtLESIREZHOKNd5VDRB2xKVkBAgMBDw9QVenGg2KioK7u7uSEhIgIfHl3jwYEOBMkRERJQfE5VyEBkZic6dO+P+/fto2rQpnjw5jnv3qhba6kJERET/x0UJNejZs2dYs2YNWrRogfv376Nu3brYv38/pk3LS1J8faWOkIiISLuxRUXNsURFReHWrVs4duwY9uzZo1qEsX379vj5559hbW0taYxERES6pNTDk+n/bt++jR9//BEnT57ExYsX8fjx4wJl7OzsMGPGDHh5eUFfX1+CKImIiHQXE5UyuH79OiZNmoT9+/cX2GdjY4OaNWuiadOm+Oijj9C+fXsYGxtLECUREZHuY6JSSt9//z2GDx+umrSua9eu+Oijj9C8eXO4ublJ/viJiIioImGiUgobNmzAV199BQDo1KkTVq1ahTp16rzyuKKGLBMREVHx2Jm2hHbu3Il+/fpBqVRiwoQJCAoKgp5eyQZNFTcJHBERERWNw5NL4NatWxg8eDCUSiW++uorLFmypMRJCpDXksLhyERERKXHFpVXyM3NRevWrREeHo527drh8OHDHL1DRERUTtii8gpLlixBeHg4zM3NERoayiSFiIioHDFRKcaiRfHw85sHAFi+fDl++82pwMrIr1otmYiIiMqOj36KYWY2CunpITAyao6srNNwdZUV6BTLjrJERESawxaVIly/fh2ZmesAAKNHB0EmkxXaKZYdZYmIiDSHLSpF+PTTT7Fz50706NEDe/bsUVu9REREVHKc8K0IixYtgpGREWbOnCl1KERERJUWW1SIiIhIa7GPChEREWktJipERESktZioEBERkdZiokJERERai4kKERERaS0mKkRERKS1mKgQERGR1mKiQkRERFqLiQoRERFpLSYqREREpLWYqBAREZHWYqJCREREWouJChEREWktA6kDeF3PF39OTU2VOBIiIiIqLTMzM8hksiL363yikpaWBgBwdHSUOBIiIiIqrZSUFJibmxe5XyaeN0noKKVSiYcPH74yIyuL1NRUODo64t69e8V+EXUVr0/3VfRr5PXpvop+jby+11fhW1T09PTw1ltvafQc5ubmFfIb8Dlen+6r6NfI69N9Ff0aeX2aw860REREpLWYqBAREZHWYqJSDLlcDn9/f8jlcqlD0Qhen+6r6NfI69N9Ff0aeX2ap/OdaYmIiKjiYosKERERaS0mKkRERKS1mKgQERGR1mKiQkRERFqrUicq8+fPh4eHB0xNTWFpaVlomdjYWHTv3h2mpqaoXr06Jk+ejNzc3GLrTUxMxOeffw5zc3NYWlpi2LBhSE9P18AVlM6xY8cgk8kKfZ09e7bI49q2bVugvJeXVzlGXnIuLi4FYg0MDCz2mKysLHh7e8PKygpVq1ZFnz59EB8fX04Rl1x0dDSGDRsGV1dXmJiYoGbNmvD390dOTk6xx2n7/VuzZg1cXFxgbGyMli1b4syZM8WW3759O95++20YGxujYcOG+O2338op0tIJCAhA8+bNYWZmhurVq6NXr164ceNGsceEhoYWuFfGxsblFHHpzZ49u0C8b7/9drHH6Mr9Awr/fSKTyeDt7V1oeV24f8ePH8fHH38MBwcHyGQy7N69O99+IQRmzZoFe3t7mJiYoEOHDrh169Yr6y3tz3FpVOpEJScnB3379sWoUaMK3a9QKNC9e3fk5OTg5MmT2Lx5M0JDQzFr1qxi6/38888RERGBw4cPY9++fTh+/DhGjBihiUsoFQ8PDzx69Cjf66uvvoKrqyvefffdYo8dPnx4vuMWLVpUTlGX3ty5c/PFOmbMmGLLT5gwAXv37sX27dvx119/4eHDh+jdu3c5RVty169fh1KpxNq1axEREYFly5YhJCQE06ZNe+Wx2nr/fv75Z/j4+MDf3x8XLlxA48aN0blzZzx+/LjQ8idPnsSAAQMwbNgwXLx4Eb169UKvXr1w9erVco781f766y94e3vj1KlTOHz4MJ49e4ZOnTohIyOj2OPMzc3z3auYmJhyirhs6tevny/ev//+u8iyunT/AODs2bP5ru3w4cMAgL59+xZ5jLbfv4yMDDRu3Bhr1qwpdP+iRYuwcuVKhISE4PTp06hSpQo6d+6MrKysIuss7c9xqQkSmzZtEhYWFgW2//bbb0JPT0/ExcWptgUHBwtzc3ORnZ1daF2RkZECgDh79qxq24EDB4RMJhMPHjxQe+yvIycnR9jY2Ii5c+cWW65NmzZi3Lhx5RPUa3J2dhbLli0rcfnk5GRhaGgotm/frtp27do1AUCEh4drIEL1WrRokXB1dS22jDbfvxYtWghvb2/Ve4VCIRwcHERAQECh5fv16ye6d++eb1vLli3FyJEjNRqnOjx+/FgAEH/99VeRZYr6XaSt/P39RePGjUtcXpfvnxBCjBs3TtSsWVMolcpC9+va/QMgdu3apXqvVCqFnZ2dWLx4sWpbcnKykMvlYuvWrUXWU9qf49Kq1C0qrxIeHo6GDRvC1tZWta1z585ITU1FREREkcdYWlrma6Ho0KED9PT0cPr0aY3HXBq//vor/v33XwwdOvSVZX/44QdYW1ujQYMG8PPzQ2ZmZjlEWDaBgYGwsrJC06ZNsXjx4mIf1Z0/fx7Pnj1Dhw4dVNvefvttODk5ITw8vDzCfS0pKSl44403XllOG+9fTk4Ozp8/n+9rr6enhw4dOhT5tQ8PD89XHsj7mdSVewXglfcrPT0dzs7OcHR0RM+ePYv8XaMtbt26BQcHB9SoUQOff/45YmNjiyyry/cvJycHYWFh+PLLL4tdQE/X7t+L7t69i7i4uHz3yMLCAi1btizyHpXl57i0dH5RQk2Ki4vLl6QAUL2Pi4sr8pjq1avn22ZgYIA33nijyGOksmHDBnTu3PmVizoOHDgQzs7OcHBwwOXLlzF16lTcuHEDv/zySzlFWnJjx47FO++8gzfeeAMnT56En58fHj16hKVLlxZaPi4uDkZGRgX6KNna2mrd/XrZ7du3sWrVKgQFBRVbTlvv35MnT6BQKAr9Gbt+/XqhxxT1M6nt90qpVGL8+PFo1aoVGjRoUGQ5Nzc3bNy4EY0aNUJKSgqCgoLg4eGBiIgIjS++WhYtW7ZEaGgo3Nzc8OjRI8yZMwcffPABrl69CjMzswLldfX+AcDu3buRnJyMIUOGFFlG1+7fy57fh9Lco7L8HJdWhUtUfH19sXDhwmLLXLt27ZUdvnRJWa75/v37OHToELZt2/bK+l/sX9OwYUPY29vjww8/RFRUFGrWrFn2wEuoNNfn4+Oj2taoUSMYGRlh5MiRCAgI0Noprsty/x48eIAuXbqgb9++GD58eLHHSn3/CPD29sbVq1eL7b8BAO7u7nB3d1e99/DwQN26dbF27VrMmzdP02GWWteuXVWfN2rUCC1btoSzszO2bduGYcOGSRiZ+m3YsAFdu3aFg4NDkWV07f7pigqXqEycOLHYjBcAatSoUaK67OzsCvRcfj4axM7OrshjXu5AlJubi8TExCKPeV1lueZNmzbBysoKPXr0KPX5WrZsCSDvP/ry+EP3Ove0ZcuWyM3NRXR0NNzc3Arst7OzQ05ODpKTk/O1qsTHx2vsfr2stNf38OFDtGvXDh4eHvjuu+9Kfb7yvn9Fsba2hr6+foERVsV97e3s7EpVXhuMHj1a1am+tP9VGxoaomnTprh9+7aGolMvS0tL1KlTp8h4dfH+AUBMTAz++OOPUrdC6tr9e34f4uPjYW9vr9oeHx+PJk2aFHpMWX6OS00tPV103Ks608bHx6u2rV27Vpibm4usrKxC63remfbcuXOqbYcOHdKqzrRKpVK4urqKiRMnlun4v//+WwAQ//zzj5ojU7+wsDChp6cnEhMTC93/vDPtjh07VNuuX7+utZ1p79+/L2rXri369+8vcnNzy1SHNt2/Fi1aiNGjR6veKxQK8eabbxbbmfajjz7Kt83d3V0rO2MqlUrh7e0tHBwcxM2bN8tUR25urnBzcxMTJkxQc3SakZaWJqpVqyZWrFhR6H5dun8v8vf3F3Z2duLZs2elOk7b7x+K6EwbFBSk2paSklKizrSl+TkudZxqqUVHxcTEiIsXL4o5c+aIqlWriosXL4qLFy+KtLQ0IUTeN1mDBg1Ep06dxKVLl8TBgweFjY2N8PPzU9Vx+vRp4ebmJu7fv6/a1qVLF9G0aVNx+vRp8ffff4vatWuLAQMGlPv1FeWPP/4QAMS1a9cK7Lt//75wc3MTp0+fFkIIcfv2bTF37lxx7tw5cffuXbFnzx5Ro0YN0bp16/IO+5VOnjwpli1bJi5duiSioqJEWFiYsLGxEYMHD1aVefn6hBDCy8tLODk5iT///FOcO3dOuLu7C3d3dykuoVj3798XtWrVEh9++KG4f/++ePToker1Yhldun8//fSTkMvlIjQ0VERGRooRI0YIS0tL1Ui7QYMGCV9fX1X5EydOCAMDAxEUFCSuXbsm/P39haGhobhy5YpUl1CkUaNGCQsLC3Hs2LF89yozM1NV5uXrmzNnjjh06JCIiooS58+fF/379xfGxsYiIiJCikt4pYkTJ4pjx46Ju3fvihMnTogOHToIa2tr8fjxYyGEbt+/5xQKhXBychJTp04tsE8X719aWprqbx0AsXTpUnHx4kURExMjhBAiMDBQWFpaij179ojLly+Lnj17CldXV/H06VNVHe3btxerVq1SvX/Vz/HrqtSJiqenpwBQ4HX06FFVmejoaNG1a1dhYmIirK2txcSJE/Nl1UePHhUAxN27d1Xb/v33XzFgwABRtWpVYW5uLoYOHapKfrTBgAEDhIeHR6H77t69m+9rEBsbK1q3bi3eeOMNIZfLRa1atcTkyZNFSkpKOUZcMufPnxctW7YUFhYWwtjYWNStW1csWLAgX+vXy9cnhBBPnz4VX3/9tahWrZowNTUVn3zySb4//tpi06ZNhX6/vtgwqov3b9WqVcLJyUkYGRmJFi1aiFOnTqn2tWnTRnh6euYrv23bNlGnTh1hZGQk6tevL/bv31/OEZdMUfdq06ZNqjIvX9/48eNVXwtbW1vRrVs3ceHChfIPvoQ+++wzYW9vL4yMjMSbb74pPvvsM3H79m3Vfl2+f88dOnRIABA3btwosE8X79/zv1kvv55fh1KpFDNnzhS2trZCLpeLDz/8sMC1Ozs7C39//3zbivs5fl0yIYRQz0MkIiIiIvXiPCpERESktZioEBERkdZiokJERERai4kKERERaS0mKkRERKS1mKgQERGR1mKiQkRERFqLiQoRERFpLSYqREREpLWYqBAREZHWYqJCREREWouJChEREWmt/wI/cDdneHwDQQAAAABJRU5ErkJggg==\n" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "def get_example_synthetic_experiment_runner():\n", - " rng = np.random.default_rng(seed=180)\n", - " def runner(xs):\n", - " return ground_truth(xs) + rng.normal(0, 1.0, xs.shape)\n", - " return runner\n", - "\n", - "example_synthetic_experiment_runner = get_example_synthetic_experiment_runner()\n", - "\n", - "plt.scatter(study_metadata.independent_variables[0].allowed_values[::5,], example_synthetic_experiment_runner(study_metadata.independent_variables[0].allowed_values[::5,]), alpha=1, s=1, c='b', label=\"samples\")\n", - "plt.plot(study_metadata.independent_variables[0].allowed_values, ground_truth(study_metadata.independent_variables[0].allowed_values), c=\"black\", label=\"ground truth\")\n", - "plt.legend()" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "markdown", - "source": [ - "## Theorist\n", - "We use a common BMS regressor with a common parametrization as the theorist." - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": 4, - "outputs": [], - "source": [ - "bms_theorist = BMSRegressor(epochs=800)" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "markdown", - "source": [ - "## Experimentalist - Random Sampler" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": 5, - "outputs": [], - "source": [ - "n_cycles = 9\n", - "n_observations_per_cycle = 50\n", - "\n", - "random_experimentalist = make_pipeline(\n", - " [study_metadata.independent_variables[0].allowed_values, random_sampler],\n", - " params={\"random_sampler\": {\"n\": n_observations_per_cycle}}\n", - ")" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": 6, - "outputs": [], - "source": [ - "%%capture\n", - "# %%capture will supress printing of warnings from BMS.\n", - "logging.disable('CRITICAL') # Removes BMS run progress INFO print-outs.\n", - "\n", - "random_experimentalist_cycle = Cycle(\n", - " metadata=study_metadata,\n", - " theorist=bms_theorist,\n", - " experimentalist=random_experimentalist,\n", - " experiment_runner=example_synthetic_experiment_runner\n", - ")\n", - "\n", - "random_experimentalist_cycle.run(n_cycles);" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "markdown", - "source": [ - "## Evaluating Results" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "markdown", - "source": [ - "#### Scoring the models of each cycle\n", - "We will test the performance of the models against the ground truth. Here we generate the ground truth values across the value range as the test set." - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": 7, - "outputs": [], - "source": [ - "X_test = study_metadata.independent_variables[0].allowed_values.reshape(-1,1)\n", - "y_test = ground_truth(X_test)" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": 8, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[0.994244272938371, 0.9958028271781731, 0.994493719396887, 0.9969328594804331, 0.9954537487709832, 0.9967720207897841, 0.9950749157731527, 0.9957246653727153, 0.9959339920921304]\n" - ] - }, - { - "data": { - "text/plain": "
", - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAeUAAAEmCAYAAABcTIh4AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAABe3UlEQVR4nO3deVyU5doH8N/MwMywDCD7KggouLIKobaYJC4poZV5LJWyjh2so5xX0zLz2HHJU75a+madU1pYRyuUjloQUZomyq4ooqKyDbvIsMMsz/vHMKPkIIszPDPD9f185g8e7nnmGhSuee7nvq+LwzAMA0IIIYSwjst2AIQQQghRoqRMCCGE6AlKyoQQQoieoKRMCCGE6AlKyoQQQoieoKRMCCGE6AlKyoQQQoieoKRMCCGE6AlKyjrEMAwaGxtB9VkIIYT0BSVlHWpqaoK1tTWamprYDoUQQogB0IukvGfPHnh5eUEoFCI8PBwZGRk9jpVKpdi0aRN8fHwgFAoREBCA5OTkbmOampqwcuVKeHp6wszMDJMmTUJmZma3MRwOR+Pjn//8p3pMfX09Fi1aBCsrK9jY2OCll15Cc3Ozdt88IYQQ0oX1pHzo0CHEx8fjnXfeQU5ODgICAhAVFYWamhqN49evX49PPvkEH330EQoKCrB8+XLExMQgNzdXPWbZsmVITU1FQkIC8vPzMX36dERGRkIsFqvHVFZWdnt8/vnn4HA4mD9/vnrMokWLcOnSJaSmpuLYsWP47bff8Morr+juh0EIIWRoY1gWFhbGxMXFqb+Wy+WMq6srs3XrVo3jXVxcmN27d3c7Nm/ePGbRokUMwzBMa2srw+PxmGPHjnUbExwczLz11ls9xhEdHc08/vjj6q8LCgoYAExmZqb62I8//shwOBxGLBb36b1JJBIGACORSPo0nhBCyNDG6pVyZ2cnsrOzERkZqT7G5XIRGRmJ9PR0jc/p6OiAUCjsdszMzAynT58GAMhkMsjl8vuO+aPq6mocP34cL730kvpYeno6bGxsEBoaqj4WGRkJLpeLc+fO9RhbY2NjtwchhBDSV6wm5bq6Osjlcjg5OXU77uTkhKqqKo3PiYqKwo4dO3Dt2jUoFAqkpqbi8OHDqKysBACIRCJERETg3XffRUVFBeRyOQ4cOID09HT1mD/64osvIBKJMG/ePPWxqqoqODo6dhtnYmICW1vbHmPbunUrrK2t1Q8PD48+/ywIIYQQ1u8p99euXbswcuRI+Pv7g8/nY8WKFYiNjQWXe+etJCQkgGEYuLm5QSAQ4MMPP8TChQu7jbnb559/jkWLFt1zdd1f69atg0QiUT/Kysoe6HyEEEKGFlaTsr29PXg8Hqqrq7sdr66uhrOzs8bnODg4ICkpCS0tLSgpKUFhYSEsLS3h7e2tHuPj44OTJ0+iubkZZWVlyMjIgFQq7TZG5dSpU7hy5QqWLVvW7bizs/M9i81kMhnq6+t7jE0gEMDKyqrbgxBCCOkrVpMyn89HSEgI0tLS1McUCgXS0tIQERFx3+cKhUK4ublBJpMhMTER0dHR94yxsLCAi4sLbt++jZSUFI1jPvvsM4SEhCAgIKDb8YiICDQ0NCA7O1t97JdffoFCoUB4eHh/3yohhBDSKw7DsFtu6tChQ1iyZAk++eQThIWFYefOnfjmm29QWFgIJycnLF68GG5ubti6dSsA4Ny5cxCLxQgMDIRYLMbGjRtx8+ZN5OTkwMbGBgCQkpIChmHg5+eHoqIirF69GkKhEKdOnYKpqan6tRsbG+Hi4oIPPvgAy5cvvye2mTNnorq6Gnv37oVUKkVsbCxCQ0Px9ddf9+m9NTY2wtraGhKJhK6aiVZcqpDgveQrWDvDH2Nc6f8UIcbGhO0AFixYgNraWmzYsAFVVVUIDAxEcnKyevFXaWlpt3vB7e3tWL9+PW7cuAFLS0vMmjULCQkJ6oQMABKJBOvWrUN5eTlsbW0xf/58bN68uVtCBoCDBw+CYRgsXLhQY2xfffUVVqxYgWnTpoHL5WL+/Pn48MMPtf9DIKSP/vXbDfx2tRYcAF+8GMZ2OIQQLWP9StmY0ZUy0bYp7/2C8ttt4HCAM2sfh4u1GdshEUK0yOBWXxMyVFVJ2lF+uw0AwDDA4RxxL88ghBgaSsqEGIisknoAAJej/PrbrDLqQEaIkaGkTIiByCq+DQCYH+wOCz4Pxbdakdl1jBBiHCgpE2IgskuUCfjhUQ6YPcEFAPBNFhWoIcSYUFImxAC0dMhQUKmspR7qOQzPhipLuP6QX4nmDhmboRFCtIiSMiEG4HxZA+QKBm42ZnC1MUOI5zB421ugtVOOHy5orulOCDE8lJQJMQCqe8chnsMAABwOB0+HugOgKWxCjAklZUIMgGrldajXMPWx+cHu4HKArJLbuFHbzFZohBAtoqRMiJ6TKxjkljYAuHOlDABOVkI8OsoBAPBtdjkboRFCtIySMiF67kpVE5o7ZLAUmMDfuXtlONWCr8M55ZDJFWyEZ1QYhsG16ib6WRLWUFImRM9ld01dBw23AU9VOaTLtNFOGGZuiurGDpy6VsdGeEblq3OleOJ/f8OHadfYDoUMUZSUCdFzWV37k0M9be/5Ht+Ei6eC3AAA32bTgq8HIVcw2HvyOgDgUFYZFAqqlkYGHyVlQvScqpLX3Yu87vZMiHIKO7WgGvUtnYMWl7H5pbBGXVu8urEDOaVULY0MPkrKhOixSkkbxA1t4HE5CPSw0ThmjKsVxrlZQSpnkJRLTSoGav+ZmwAAPk/5Z/F4Pu3/JoOPkjIhekx1lTzaRQQLQc/tz1ULvr6hJhUDcq26Cb8X3QKXA7w5yx8A8GN+FU1hk0FHSZkQPZZ9n/vJd5sb4Ao+j4vCqiZcqmgcjNCMyv4zxQCA6WOc8VzYcFgKTFDV2I7cMprCJoOLkjIhekxT0RBNbMz5mD7WCYCypSPpO0mbVN2beulkLwhNeYgc7QgAOH6his3QyBBESZkQPdXcIUNBhaoJxf2vlAHgma4p7KS8CrRL5TqNzZh8m1WGNqkc/s4ihI9Q/pxnjVd24frxYiVNYZNBRUmZED2VV9oABQO42ZjB2VrY6/gpvvZwsRZC0ibFz5erByFCwydXMPgyvQQAsHSSFzgc5T7wR0Y5wFJggkpJO3LLGliMkAw1lJQJ0VN9nbpW4XE5mB+salJBZTf74tfCGpTWt8LazBTRgW7q40JTHqZ1TWH/QKuwySCipEyInrqzyKtvSRkAng5RJuVT12pR0dCmk7iMyRfpxQCA58I8YMbndfueego7n6awyeChpEyIHurehKL3+8kqXvYWCB9hC4ZR1sMmPSuqacKpa3XgcoAXHvK85/uPjnKABZ+HCkk78sobBj9AMiRRUiZEDxVWNaK5QwaRwAR+zqJ+PVe14Ovb7HLas3wfX5xR3kt+YowT3IeZ3/N95RS2ckX7DxdoCpsMDkrKhOgh1dR1kOewe5pQ9GbWeGdY8HkoudWKjJv1ugjP4DW2S5HYNZOwZJJXj+PurMKuog84ZFBQUiZED2UW9/9+soo53wRPTnAFQAu+evJtVjlaO+XwcxIhwtuux3GP+SmnsMUNbcijVdhkEFBSJkQPZRd3rbweQFIGgGcnKhd8/ZBfieYOmdbiMgYKBYMvuxZ4LblrG5QmQlMeHldNYdMqbDIIKCkTomcqGtpQIWlXNqEYbjOgcwQPHwZvBwu0SeU4fqFCuwEauBNXa1ByqxVWQhM8FeTa6/jZ450BAD/k0xQ20T1KyoToGVX/5DEuVjDn99yE4n44HI66peO3NIXdzb7fiwEAz4UN79PP9zE/R5h3TWGfL5foODoy1LGelPfs2QMvLy8IhUKEh4cjIyOjx7FSqRSbNm2Cj48PhEIhAgICkJyc3G1MU1MTVq5cCU9PT5iZmWHSpEnIzMy851yXL1/G3LlzYW1tDQsLC0ycOBGlpaXq7z/22GPgcDjdHsuXL9feGyekB+qp6z4WDenJ/GA38LgcZJXcxvXaZm2EZvCKappx6lodOD1sg9JEaMrD4/5USIQMDlaT8qFDhxAfH4933nkHOTk5CAgIQFRUFGpqajSOX79+PT755BN89NFHKCgowPLlyxETE4Pc3Fz1mGXLliE1NRUJCQnIz8/H9OnTERkZCbH4Tp/Z69evY8qUKfD398eJEydw4cIFvP322xAKu5cyfPnll1FZWal+bN++XTc/CELucmeRV9/3J2viaCXEo6McANDVsorqXnLkaCd42N67Daons7tWYR+/UElT2ESnOAyL/8PCw8MxceJE7N69GwCgUCjg4eGB1157DWvXrr1nvKurK9566y3ExcWpj82fPx9mZmY4cOAA2traIBKJ8P3332P27NnqMSEhIZg5cyb+8Y9/AACee+45mJqaIiEhocfYHnvsMQQGBmLnzp0Dfn+NjY2wtraGRCKBlZXVgM9Dho7mDhkmbEyBggHOvTkNTla917y+n+SLlVh+IAeOIgHOrH0cJjzWJ8dY09guRcSWNLR0yvHVsnBM9rXv83PbOuUIfjcVbVI5vo+bjAAPG90FSoY01n5DOzs7kZ2djcjIyDvBcLmIjIxEenq6xud0dHTcczVrZmaG06dPAwBkMhnkcvl9xygUChw/fhyjRo1CVFQUHB0dER4ejqSkpHte76uvvoK9vT3GjRuHdevWobW19b7vqaOjA42Njd0ehPRHbultKBjAfZjZAydkAHjc3wm2FnzUNHXgt2u1WojQcH2XVY6WTjlGOlpikk/P26A0MePz8DjVwiaDgLWkXFdXB7lcDicnp27HnZycUFWluYdpVFQUduzYgWvXrkGhUCA1NRWHDx9GZaXyl0QkEiEiIgLvvvsuKioqIJfLceDAAaSnp6vH1NTUoLm5Gdu2bcOMGTPw008/ISYmBvPmzcPJkyfVr/WnP/0JBw4cwK+//op169YhISEBzz///H3f09atW2Ftba1+eHh4PMiPiAxBWQ+wP1kTvgkXT3U1WhjKU9j92QbVE9UU9jGawiY6ZFBzWbt27cLIkSPh7+8PPp+PFStWIDY2FlzunbeRkJAAhmHg5uYGgUCADz/8EAsXLlSPUSgUAIDo6GisWrUKgYGBWLt2LZ588kns3btXfZ5XXnkFUVFRGD9+PBYtWoQvv/wSR44cwfXr13uMb926dZBIJOpHWRk1myf9o6rkFeL1YPeT7/ZMqHLP8s+Xq1Hf0qm18xqSk1drUXyrFSKhCeYFu/X+BA2m+jnCzFS5CvsCrcImOsJaUra3twePx0N1dfe+r9XV1XB2dtb4HAcHByQlJaGlpQUlJSUoLCyEpaUlvL291WN8fHxw8uRJNDc3o6ysDBkZGZBKpeox9vb2MDExwZgxY7qde/To0d1WX/9ReHg4AKCoqKjHMQKBAFZWVt0ehPSVTK5AbqkyKU98wJXXdxvtYoXxbtaQyhkk5Yp7f4IR2n+mGACwINRjwNvMzPi0CpvoHmtJmc/nIyQkBGlpaepjCoUCaWlpiIiIuO9zhUIh3NzcIJPJkJiYiOjo6HvGWFhYwMXFBbdv30ZKSop6DJ/Px8SJE3HlypVu469evQpPz563SOTl5QEAXFxc+voWCemXwqomtHTKIRKaYJRj/5pQ9ObZUFWf5bIhN/V6vbYZJ6/WgsMBFkd4PdC5VLWwj+fTFDbRjYF9ZNSS+Ph4LFmyBKGhoQgLC8POnTvR0tKC2NhYAMDixYvh5uaGrVu3AgDOnTsHsViMwMBAiMVibNy4EQqFAmvWrFGfMyUlBQzDwM/PD0VFRVi9ejX8/f3V5wSA1atXY8GCBXjkkUcwdepUJCcn4+jRozhx4gQA5Zapr7/+GrNmzYKdnR0uXLiAVatW4ZFHHsGECRMG7wdEhpSsrv3JwcOHgdvPJhS9mRvghnePX0ZhVRMuihsx3t1aq+fXZwnpym5Q0/wdMdyu79ugNJnq7wChKRflt9uQL5ZggruNFiIk5A5W7ykvWLAA77//PjZs2IDAwEDk5eUhOTlZvfirtLRUvUALANrb27F+/XqMGTMGMTExcHNzw+nTp2FjY6MeI5FIEBcXB39/fyxevBhTpkxBSkoKTE1N1WNiYmKwd+9ebN++HePHj8e///1vJCYmYsqUKQCUV9M///wzpk+fDn9/f/ztb3/D/PnzcfTo0cH5wZAhSVXJS1uLvO5mbW6KqLHK20LfZg+dtQ5N7VJ8m6V8v0snjXjg85nzTdRT2MdpCpvoAKv7lI0d7VMm/RGxNQ2VknZ8/XI4Jvn0fQ9tX/12tRaLP8+AldAEGW9FQmjK0/pr6Jv9v9/ExqMF8HW0ROqqRwa06vqPjl2owIqvc+Fha4bfVk/VyjkJUTGo1deEGCtxQxsqJe0w4XIQqKPCFJN97eFqLURjuwypBdW9P8HAKRQMvuiauh7oNihNHvd3hNCUi7L6NlwUUy0Col2UlAnRA6r7yWNdB96Eojc8LgfzQ+4s+DJ2v12rxc26FuU2qKCBbYPSxJxvgql+NIVNdIOSMiF6QFU0JOQB61335umupHy6qA4VDW06fS22fdG1DerZUA9YCLT7QUe1CvsHWoVNtIySMiF6QL3IS4v7kzXxtLPAQ962YBggMdt4K3zdrGvBr1dU26D61g2qP1RT2KX1rbhUQVPYRHsoKRPCsqZ2Ka5UKf+w62Ll9R+p+yxnl0OhMM6rPFVJzal+jvC0s9D6+S0ENIVNdIOSMiEsyy1tgIIBPGzN4KiFJhS9mTneGZYCE5TWtyKj6162MWnukKnrfC+d5KWz16EpbKILlJQJYZlq6nqiju8nq5jzTfDkBGVCMcYFX4dzytHcIYO3gwWm9KM9Y3897u8IgQkXJbdoCptoDyVlQliWXaK8Wg3R8f3kuz0TqpzC/jG/Ck3t0kF7XV1TKBh1neulk7y0XhntbndPYVMtbKItlJQJYZGyCUUDACB0kK6UASB4uA28HSzQJpXj+AXjSSini+pwo7YFlgITzAt21/nrzZpAU9hEuygpE8Kiy5VNaO2Uw0pogpGOloP2uhwOB8+G3lnwZSxUV8nPhLrDUsvboDSZ1jWFXXyrFQWVNIVNHhwlZUJYlNU1dR3sqf0mFL2ZF+QGHpeD7JLbKKppHtTX1oXiuhb8eqUGwIN3g+orC4EJHvNzAEBT2EQ7KCkTwiJdNqHojaOVEI+NUiYUY2hS8WV6CRgGmOrngBH22t8G1ZM7q7CraAqbPDBKyoSwhGEYZBerioYM3v3ku6kWfB3OEUMmV7ASgza0dMjU3aCW6HAblCbTRjuBb8LFzboWXK5sGtTXJsaHkjIhLBE3tKGqUdmEIoClvryP+zvC1oKP2qYOnLxay0oM2nA4pxxNHTJ421vgkZEOg/ralgIT9YwDTWGTB0VJmRCWqOpdj3WzhhmfnTaKfBMuYrqaNagKbhgahrmzDWpxhOeg35sHgNm0CptoCSVlQliiWuTFxv3kuz0Tqtw69PPlatxq7mA1loE4XVSH613boFRdsAabagr7Rl0LCqtoCpsMHCVlQliiulJmOyn7O1thgrs1ZAoGSXkVrMYyEKpuUE+HuEMkNGUlBkuBCR6lKWyiBZSUCWFBY7sUV6qVV1SDWcmrJ6oFX99mlRnU9GvprVakFaq2QWm/G1R/zO5ahX2cprDJA6CkTAgLcksbwDCAp505HEW6b0LRm7kTXME34aKwqgkXxYZTBOPL9GIwDPDoKAd4Owxe8RVNpo12VE5h19IUNhk4SsqEsCC7qztTCMtT1yrW5qaYMdYZgOE0qWjpkOFQV6xLJ3uxGwwAkdBUvfKbprDJQFFSJoQFmer7yezsT9ZEteDr+zwx2qVylqPp3ZFcMZraZRhhb4FHB3kbVE9mT1B+sKEpbDJQlJQJGWRSuQJ5ZQ0AgFA9uJ+sMsnHHm42Zmhsl+Gngmq2w7kvhmHUC7xeeIidbVCaTBvtBD5POYWtWjNASH9QUiZkkF2ubESbVNmEwpfl+6B343E5mB+s2rOs31PYZ67fwrWaZljweXg6lJ1tUJpYCU3xyChlD+cfjKj7Fhk8lJQJGWSqrVAhLDSh6M3TIcpV2KeL6iBuaGM5mp7t+70YADA/xB1WLG2D6sksWoVNHgAlZUIGWXYJu/Wu72e4nTkivO3AMECinrZ0LKtvRVqhcnp9sLpB9UfkGOUU9vXaFlytNvzuW2RwUVImZBAxDIPMYv2o5NUT1YKv77LLoVDo35WeahvUwyPt4TuIPaj7ykpoiodHKqewj9MqbNJPlJQJGUTlt9tQ09QBUx4HAR42bIej0cxxLrAUmKC0vhXnbtazHU43rZ0yHMpU3u+O1YNtUD25086RkjLpH0rKhAwiVb3rsa7WEJqy04SiN2Z8HuYEKJOKvi34OpIrRmO7DJ525nhslCPb4fQocowTTHkcFNU04yqtwib9wHpS3rNnD7y8vCAUChEeHo6MjIwex0qlUmzatAk+Pj4QCoUICAhAcnJytzFNTU1YuXIlPD09YWZmhkmTJiEzM/Oec12+fBlz586FtbU1LCwsMHHiRJSWlqq/397ejri4ONjZ2cHS0hLz589HdbV+bxMh+k9f6l33RlV284eLlWhql7IcjdLd26AWR3jp3SK5u1mbmeLhrr3Tx2kVNukHVpPyoUOHEB8fj3feeQc5OTkICAhAVFQUampqNI5fv349PvnkE3z00UcoKCjA8uXLERMTg9zcXPWYZcuWITU1FQkJCcjPz8f06dMRGRkJsVisHnP9+nVMmTIF/v7+OHHiBC5cuIC3334bQuGdcoerVq3C0aNH8e233+LkyZOoqKjAvHnzdPfDIEPCnUVe+p2Ugzxs4OtoiXapAsf0JKmkX7+Fq9XNMOfz1Pe99dlsmsImA8GwKCwsjImLi1N/LZfLGVdXV2br1q0ax7u4uDC7d+/udmzevHnMokWLGIZhmNbWVobH4zHHjh3rNiY4OJh566231F8vWLCAef7553uMq6GhgTE1NWW+/fZb9bHLly8zAJj09PQ+vz+JRMIAYCQSSZ+fQ4xXQ2sn47X2GOP5xjGmprGd7XB6tfdEEeP5xjEmZs9ptkNhGIZhXv4ik/F84xiz/kg+26H0SUNrJ+P75nHG841jzNWqRrbDIQaCtSvlzs5OZGdnIzIyUn2My+UiMjIS6enpGp/T0dHR7WoWAMzMzHD69GkAgEwmg1wuv+8YhUKB48ePY9SoUYiKioKjoyPCw8ORlJSkHp+dnQ2pVNotNn9/fwwfPrzH2FTxNTY2dnsQopJTehsMA3jZmcNBJGA7nF7FBLuBx+Ugp7QBRTXs3hctq2/Fz5eVt4+WTGK3G1RfdZvCpqtl0kesJeW6ujrI5XI4OTl1O+7k5ISqqiqNz4mKisKOHTtw7do1KBQKpKam4vDhw6isVP6HF4lEiIiIwLvvvouKigrI5XIcOHAA6enp6jE1NTVobm7Gtm3bMGPGDPz000+IiYnBvHnzcPLkSQBAVVUV+Hw+bGxs+hwbAGzduhXW1tbqh4eHx0B/PMQIZauLhujf/mRNHEVCTPVTJpVvWd6zfOBsCRTqbVAiVmPpD1qFTfqL9YVe/bFr1y6MHDkS/v7+4PP5WLFiBWJjY8Hl3nkbCQkJYBgGbm5uEAgE+PDDD7Fw4UL1GIVCAQCIjo7GqlWrEBgYiLVr1+LJJ5/E3r17Hyi+devWQSKRqB9lZfq1cpWwS7XyWt/vJ99NteArMVsMqVzBSgxtnXIc7NoGtUQPi4XczxNdq7CvVjezPttADANrSdne3h48Hu+eFc3V1dVwdnbW+BwHBwckJSWhpaUFJSUlKCwshKWlJby9vdVjfHx8cPLkSTQ3N6OsrAwZGRmQSqXqMfb29jAxMcGYMWO6nXv06NHq1dfOzs7o7OxEQ0NDn2MDAIFAACsrq24PQoA/NKHQ85XXd3vc3xF2FnzUNXfg5JVaVmJIyhND0ibFcFtzTPXX321QmlibmWKKb1chkQs9z7IRosJaUubz+QgJCUFaWpr6mEKhQFpaGiIiIu77XKFQCDc3N8hkMiQmJiI6OvqeMRYWFnBxccHt27eRkpKiHsPn8zFx4kRcuXKl2/irV6/C01N5ryokJASmpqbdYrty5QpKS0t7jY0QTQoqGtEuVcDG3BQ+etSEojemPC5igrqaVGQP/swPwzDY31XnenGEJ3h6vA2qJzSFbfhkgzhLZDJor6RBfHw8lixZgtDQUISFhWHnzp1oaWlBbGwsAGDx4sVwc3PD1q1bAQDnzp2DWCxGYGAgxGIxNm7cCIVCgTVr1qjPmZKSAoZh4Ofnh6KiIqxevRr+/v7qcwLA6tWrsWDBAjzyyCOYOnUqkpOTcfToUZw4cQIAYG1tjZdeegnx8fGwtbWFlZUVXnvtNUREROChhx4avB8QMRpZXVuhQobrXxOK3jwT6oF/n76JtMs1qGvugL3l4C1SO3ujHleqm2BmylNPpRua6WOc8SYvH1eqm1BU06yXpUHJvWqbOvB9nhiJOWJMH+OEVU+MGpTXZTUpL1iwALW1tdiwYQOqqqoQGBiI5ORk9eKv0tLSbveL29vbsX79ety4cQOWlpaYNWsWEhISui3IkkgkWLduHcrLy2Fra4v58+dj8+bNMDW900kmJiYGe/fuxdatW/H666/Dz88PiYmJmDJlinrM//7v/4LL5WL+/Pno6OhAVFQU/u///k/3PxRilLK66l2HGND9ZBU/ZxEC3K1xvlyCpFwxlj3s3fuTtERVLGResBuszfSrG1RfWZubYrKvPU5cqcUP+ZV4fdpItkMiPeiQyZF2uQaJ2eU4cbUW8q7a750yOVZGjgSHo/sP1ByGebDeYu3t7fdsQSJKjY2NsLa2hkQiofvLQxjDMAjbkobapg588+cIhI0wjNXXdztwtgTrky7Cz0mE5JUPD8ofp/LbrXhk+69QMEDqqkcw0slwVl3/0TdZZVjz3QX4O4uQvPIRtsMhd2EYBnllDUjMKcfR85WQtN2pYBfgYYOng90wJ8AVNub8QYlnQFfKCoUCmzdvxt69e1FdXY2rV6/C29sbb7/9Nry8vPDSSy9pO05CDFZZfRtqu5pQTHC3ZjucAZkT4Ip3jxXgSnUT8sUSTHC30flrHjhbCgUDTPa1M+iEDADTxzjhTS4HhVVNuF7bbFDrCoxVpaQNh3PEOJxTjuu1LerjzlZCxAS7YX6wOyu3Gga00Osf//gH9u/fj+3bt4PPv/PpYdy4cfj3v/+tteAIMQaqrVDj3PS3CUVvrM1MMWOccufBN4PQpKJdKsfBTOVuCEPbBqWJjTkfk7tWYf+gJ2VLh6K2TjmO5Jbjhc/OYdK2X/DPlCu4XtsCoSkXTwW6IuGlMPy+9nG8McOftXv/A7pS/vLLL/Hpp59i2rRpWL58ufp4QEAACgsLtRYcIcZAtchropfhTVvf7ZkQD3yfV4Hv8yqwfvYYnX7A+D5PjIZWKdyHmWHaaKfen2AAZo93wcmrtTieX4nX6L7yoFEolD3ME3PK8UN+FZo7ZOrvhY2wxdPB7pg53hkioX6sWRhQUhaLxfD19b3nuEKhgFSqHx1lCNEXdyp5Gd4ir7tN8rGDm40ZxA1tSLlUhehAN528DsMw2Gfg26A0mT7WCW8eoSnswVJ6qxWJOeU4nFuOsvo29XEPWzPMD3bHvCB3DLczZzFCzQaUlMeMGYNTp06p9/WqfPfddwgKCtJKYIQYA0mrFFe6+ukaelLmcjl4OsQdu9Ku4duscp0l5Yyb9SisUm6DWhA6XCevwQYbcz4m+drjt6u1+OECXS3rQlO7FD/kVyIxW4yMrh0PAGApMMGs8c6YH+yOiV62er0tcUBJecOGDViyZAnEYjEUCgUOHz6MK1eu4Msvv8SxY8e0HSMhBiunVHmVPMLeYlD39+qKKin/fr0O5bdb4T5M+1ca+7u2QT0V5AZrc/2YUtSW2eOd8RtNYWuVXMHg96I6JOaUI+VSFdqlykIfHA4wxdce84PdETXWGWZ8w1jPMaCkHB0djaNHj2LTpk2wsLDAhg0bEBwcjKNHj+KJJ57QdoyEGCzVIi9Dv0pW8bA1xyQfO5y5fguJ2WL8NVK7iUXc0IafCpSld5dO8tLqufXB9DHOePPIRRRWNeFGbTO8aQp7wIpqmvBdthhJuWJUNbarj/s4WGB+iDtigtzgYm3GYoQD0++kLJPJsGXLFrz44otITU3VRUzEgFVJ2pGUJ8YLD3nCQsBqbRq9kNV1P9mQ6l335plQd5y5fgvf5ZThtcd9tToVeOBsCeQKBhHedvBzNuxtUJoMs+Bjko8dTl2rww/5lVjxOF0t90dDayeOnq/Ad9nlOF8uUR+3NjPF3ABXzA9xR4C79aDso9eVfv/VNDExwfbt27F48WJdxEMM3NvfX0RqQTWqJO3YOHcs2+GwSipX4Hx5AwAg1MBXXt9txlgXbBBcQll9G87evIVJPvZaOW+7VI6DGcptUEsne2nlnPpo9ngXnLpWh+P5VZSU+0AqV+DklVok5pQj7XINOrvqUPO4HEz1c8D8YHc8PtoRAhPDmJ7uzYAuZaZNm4aTJ0/Cy8tLy+EQQ1bf0olfC2sAAN9ll+Nv00fpzTYDNlzqakIxzNwUPg4WbIejNWZ8Hp4McMV/MkrxbVa51pLyf/MqcLtVCjcbM0QayTYoTaaPdcZbSRdxubIRN+taMMLeeP5vaNOlCgkSs8X473kx6po71cfHuFhhfog7ogNdjWKdxh8NKCnPnDkTa9euRX5+PkJCQmBh0f0/1dy5c7USHDEsxy9UQNZVK7a5Q4bE7HIsnTyC5ajYo6537TnMoKfTNHk21B3/ySjFjxcr8ffosbB6wA9fDMOoF3gZ0zYoTWz/MIUdN/Xe7aVDlaoJxHfZ5SisutN/2t6Sj+hAZZWtMa7GXbJ4QEn5L3/5CwBgx44d93yPw+FALpc/WFTEIB3OFQMA/J1FKKxqwhfpJVgc4aXX2w90KUu9P9l4pq5VAj1sMNLREtdqmnHsfCX+FP5gW5cyi2+joLIRQlMuFkw0zG5Q/TFLNYV9gZJyu7SrCUROOU7e1QSCz+Micowj5ge745FRDjDlsdZpeFANuPY1IXcrrmtBbmkDuBxg7/MhmLP7NG7WteDk1VqDa0yvDQzDqCt5hRpgZ6jecDgcPBPqji0/FOLb7LIHTsqqblAxQW6DVvifTVFjnbE+6SIKKhtRXNcCryE2hc0wDHLLGpCYXY6j5yvQ2H6nylaghw3mh7hjzgSXIfF/4Y9oeSzRiiNdV8mTfe3hZW+BBV09ePedKR6SSbm0vhV1zR3g87gY72aYTSh6ExPkjveSryC3tAFFNU3wdRzYaumKhjYkX6oCACwxwm1Qmtha8BHhbYfTRXU4PoSmsDtkcuz7vRjfZJXhxl1NIFyshYgJcsM8lppA6JMBzwecPHkSc+bMga+vL3x9fTF37lycOnVKm7ERA8EwDJLylEl5XrCyytPiCC9wOMBvV2tRVNPMZnisUE1dj3c33CYUvXEQCTDVT/mB69us8gGf56tzym1QD3nbwt/ZuO8X3m3WeBcAwA/5Q6NBhULBIP7QeWz7sRA3uppAxAS54cBL4Tj9xuNYw2ITCH0yoKR84MABREZGwtzcHK+//jpef/11mJmZYdq0afj666+1HSPRczmlDSi51QpzPg9RY5WdhIbbmatX0H6ZXsxidOxQT10b0f5kTZ4NdQcAJOaIIZX3/7ZWu1SO/2Qou04ZY7GQ+4ka6wQel4NLFY0oudXS+xMM3HvJhTieXwlTHgebY8Yha/0T+N8FgZgy0t6oF/b114CS8ubNm7F9+3YcOnRInZQPHTqEbdu24d1339V2jETPHclVXiVFjXWGOf/OHZHYrj+y32WXo7F9aDUquXvltTGb6u8Ie0s+6po7cOJKbb+ff/R8BepbOo1+G5QmdpYCRHjbAQCOG/nVcsLZEnzy2w0AwD+fDsCicE9YUnEhjQaUlG/cuIE5c+bcc3zu3Lm4efPmAwdFDEenTIFjXf1hY4K6NyiI8LHDKCdLtHbK8U2m7nvw6ouG1k5c65qyN/akbMrjqv/dv+1nn+W7t0E9/5AnTIbI6tq7DYUp7F8La/DO9xcBAH97YhSeCtJNIxNjMaDfAg8PD6Slpd1z/Oeff4aHh/FvZyB3nLhSg4ZWKRxEAkzysev2PQ6Hg6WTlPuUv0wvUW91MHaqJhTe9hawM8LiBn/0TKjyd/6XwhrUNXf0+XnZJbdxqaIRAhMunhsC26A0UU1hXxQ3ovRWK9vhaN1FsQRxX+dAwQDPhLhjxeNDY0HbgxhQUv7b3/6G119/Ha+++ioSEhKQkJCA5cuXY+XKlfif//kfbcdI9JhqgVd0gKvGK52YIDdYm5mitL5VXe3L2GUZSf/kvhrlJEKAhw1kCgZJXavw+2KfqhtUoBuGWQy9rS+Acgr7IW/lPnZjm8KuaGjDi/sz0dopxxRfe2yZN97oiujowoCS8quvvoqDBw8iPz8fK1euxMqVK3Hx4kUcOnQIf/7zn7UdI9FTkjYpfr6sTLQxwZqnpMz4PDwXprwKUk1VGjvVIq+JRlTvujeqBV/fZJWBYXqfEamUtCH54tDaBtUTY5zCbmyXInZfJmqaOjDKyRL/93zwkCn+8aAG/FOKiYnB6dOncevWLdy6dQunT59GdHS0NmMjeu6H/Ep0yhQY5WSJMS49b2V54SFPcDnA6aI6XK1u6nGcMeiUKXC+rAEAEGKERUN6MifAFQITLq5WN+PCXd17evLV2VLIFQzCRtgafdnE3kSNdQaXA+SLJUYxhS2VKxD3VQ6uVDfBUSTAvtiwBy7DOpQMKClnZmbi3Llz9xw/d+4csrKyHjgoYhhUBUNigtzvOy3lPswc08cot0oZ+9XyxQoJOmQK2Frw4T2EqjRZCU0xc5zy3/ibXhZ8KbdBdXWDGuJXyQBgbynAQ12rsH+4aNhXywzD4K0j+Th1rQ7mfB4+XzoRbjaG19OYTQNKynFxcSgru/cXTywWIy4u7oGDIvqvrL4VGTfrweEA0YGuvY6P7WrFdzinHJJW490eld11Pzl4uPE1oeiNasHXf89XoF3ac/37YxcqcaulEy7WQkwfM7S2QfXEWKaw9/xahG+yysHlALv/FIRxRlrNTpcGlJQLCgoQHBx8z/GgoCAUFBQ8cFBE//33fAUA4KERdnDtwyfhsBG2GO1ihXapAoeySnUdHmuySpT7k42x3nVvIrzt4GZjhqZ2GVK6ymb+EcMw6jrXQ3UblCYzximnsC+US1BWb5hT2Em5Yrz/01UAwN/njsXj/vSBayAG9BshEAhQXV19z/HKykqYmNCGcGPHMAwO5ygLhvS0wOuPOByOupjIF2dKIBtA9Sd9xzAMstWLvIZeUuZylU0qgJ6nsHNKbyNfLAHfhIuFYQ/WxMKY2FsKED6iawrbAK+Wz964hTXfXQAAvPKIN16I8GI3IAM2oKQ8ffp0rFu3DhLJnQUdDQ0NePPNN/HEE09oLTiin/LFElyvbYHAhKu+j9gXcwNdMczcFOKGNvWqbWNScqsVdc2d4Jtwh+y03fxgZVI+c/2Wxiu+/WdKACi30NkO0W1QPZk1wTCnsItqmvHnhGx0yhWYOc4Za2f4sx2SQRtQUn7//fdRVlYGT09PTJ06FVOnTsWIESNQVVWFDz74QNsxEj2jWuD1xBgniPqxqlJoylNfHe0/Y3yV3zK7SmtOcLOGwMQ4m1D0xsPWHJN97cAwQGJO9yYV1Y3t+LEr4Qz1bVCazOhahX3egKaw65o7ELs/A5I2KYKG2+B/FwQO2f7p2jKgpOzm5oYLFy5g+/btGDNmDEJCQrBr1y7k5+cPqKLXnj174OXlBaFQiPDwcGRkZPQ4ViqVYtOmTfDx8YFQKERAQACSk5O7jWlqasLKlSvh6ekJMzMzTJo0CZmZmd3GLF26FBwOp9tjxowZ3cZ4eXndM2bbtm39fn/GRCZX4GjX/eR5fZy6vtsLEZ7gcTk4e6MelysbtR0eq1RT10NpK5Qmz4Qo/wZ8l10OxV1V3L46WwKZgsFEr2FDdibhfhxEAoSNUO5tN4Sr5bZOOZZ9kYWy+jYMtzXHvxeHGm1HtME04BvAFhYWeOWVVx44gEOHDiE+Ph579+5FeHg4du7ciaioKFy5cgWOjvf24V2/fj0OHDiAf/3rX/D390dKSgpiYmJw5swZBAUFAQCWLVuGixcvIiEhAa6uruquVgUFBXBzu5NIZsyYgX379qm/FgjuLYm4adMmvPzyy+qvRaKB9Yw1FqeK6lDX3Ak7Cz4eHunQ7+e7WJthxjhnHL9Qif2/F+O9pyfoIEp23OkMNXSKhmgyY5wzRN+boPx2G87euIVJvvbokMnxtXob1AiWI9Rfs8e74OyNevyQX4k/P+rDdjg9kisYrDyUi7yyBtiYm2J/7MQhUVJ2MAzoSvmLL77A8ePH1V+vWbMGNjY2mDRpEkpKSvp1rh07duDll19GbGwsxowZg71798Lc3Byff/65xvEJCQl48803MWvWLHh7e+PVV1/FrFmz1NPmbW1tSExMxPbt2/HII4/A19cXGzduhK+vLz7++ONu5xIIBHB2dlY/hg279wpHJBJ1G2NhMXT2nmpyJEc5dT0nwHXAFXpUC76S8sSob+nUVmisamjtVPeNHirlNXsiNOVhToBym9y32cop7OMXKlHX3AlnKyGmj6VVuT2JGucMjgFMYW/54TJSLlWDz+PiX4tD4e1AfZC1ZUB/Vbds2QIzM+U2mPT0dOzevRvbt2+Hvb09Vq1a1efzdHZ2Ijs7G5GRkXcC4nIRGRmJ9PR0jc/p6OiAUCjsdszMzAynT58GAMhkMsjl8vuOUTlx4gQcHR3h5+eHV199Fbdu3brn9bZt2wY7OzsEBQXhn//8J2QyWY/vp6OjA42Njd0exqS5Q4afCpRbXR6k00uI5zCMc7NCh0yBg5nGsT1KNXXt42BBC5gAPNu1Z/mH/Eo0tkvVRWNeiPCkcov34SgSIqyrPOuPelpIZP/vN/HZaeWakPefDRhS5WQHw4B+O8rKyuDrq+z2kZSUhKeffhqvvPIKtm7dilOnTvX5PHV1dZDL5XBy6v7J2cnJCVVVmvc5RkVFYceOHbh27RoUCgVSU1Nx+PBhVFYq/wOLRCJERETg3XffRUVFBeRyOQ4cOID09HT1GEA5df3ll18iLS0N7733Hk6ePImZM2dCLr9T9OD111/HwYMH8euvv+LPf/4ztmzZgjVr1vT4frZu3Qpra2v1w9g6ZiVfrEK7VAFvewsEuA/8nqBye5RyCjMh3Ti2R9HUdXcB7tYY5WSJDpkCm44W4EK5chvUUO0G1R+zu1ZhH8/X/DeQTakF1dh0TFmLYs0MP8wN6L1wEOmfASVlS0tL9VXlTz/9pN4GJRQK0dbWpr3oNNi1axdGjhwJf39/8Pl8rFixArGxseBy77yVhIQEMAwDNzc3CAQCfPjhh1i4cGG3Mc899xzmzp2L8ePH46mnnsKxY8eQmZmJEydOqMfEx8fjsccew4QJE7B8+XJ88MEH+Oijj9DRobk9nWqbmOqhqeqZITuS27U3OcjtgatVPRngAntLPiol7Ui5dO+ed0OT1bXyeqgv8lLhcDjdFnwBwNwAV7rv2AczVFPYZQ0ov60/U9gXyhvw+n9yoWCAhWEeeFWP73kbsgEl5SeeeALLli3DsmXLcPXqVcyaNQsAcOnSJXh5efX5PPb29uDxePcUIqmuroazs+b9rw4ODkhKSkJLSwtKSkpQWFgIS0tLeHt7q8f4+Pjg5MmTaG5uRllZGTIyMiCVSruN+SNvb2/Y29ujqKioxzHh4eGQyWQoLi7W+H2BQAArK6tuD2NRJWnHmevKD2LaaFIuMOHhT0ayPapDJsf5riYMoUP8fvLdngpyg8ld22OoznXfOIqE6inhH/Xkarn8dite3J+FNqkcj4xywKbocUOujOxgGVBS3rNnDyIiIlBbW4vExETY2Skr0WRnZ2PhwoV9Pg+fz0dISAjS0tLUxxQKBdLS0hAREXHf5wqFQri5uUEmkyExMVFjhyoLCwu4uLjg9u3bSElJuW8Xq/Lycty6dQsuLi49jsnLywOXy9W4KtzYfZ8nBsMoK1V52Jpr5ZyLHvKECZeDzOLbuCjuvbOQvroobkSnTAE7Cz5GDKEmFL1xEAkw1V/5uxLqSdug+mP2eNUUNvv3lSVtyjaMdc0d8HcWYc+fgmhdgA4NaEuUjY0Ndu/efc/xv//9792+/stf/oJNmzbB3t6+x3PFx8djyZIlCA0NRVhYGHbu3ImWlhbExsYCABYvXgw3Nzds3boVgLITlVgsRmBgIMRiMTZu3AiFQtHtXm9KSgoYhoGfnx+KioqwevVq+Pv7q8/Z3NyMv//975g/fz6cnZ1x/fp1rFmzBr6+voiKigKgXMB27tw5TJ06FSKRCOnp6Vi1ahWef/55jau0jZ2qYIg2rpJVnKyEmD3BBd/nVWD/mWK8/0yA1s49mLK76l0Hew69JhS9WRPlB5lcgfgn/NgOxaDMHOeMjUcvIa+sAeKGNtY6LXXKFHj1QDau1TTD2UqIfbET+1UwiPSfTj/uHDhwoNcVyAsWLMD777+PDRs2IDAwEHl5eUhOTlYv/iotLe22QKu9vR3r16/HmDFjEBMTAzc3N5w+fRo2NjbqMRKJBHFxcfD398fixYsxZcoUpKSkwNRU+Z+Jx+PhwoULmDt3LkaNGoWXXnoJISEhOHXqlHqvskAgwMGDB/Hoo49i7Nix2Lx5M1atWoVPP/1Uyz8l/Xe5shGFVU3g87h4crx2F3aopjT/m1eBumbN9+r1XVbx0K133ZuRTiLsiw3D+AdYGDgUOVoJMdFTNYXNztUywzBYe/gCzly/BYuuNowu1tSGUdc4DMMwvQ8bGJFIhPPnz9/3Xq4xa2xshLW1NSQSiUHfX97yw2V8+tsNzBjrjL0vhGj9/NF7fsf5sgb87YlReG3aSK2fX5cYhkHoP37GrZZOJL46acjvUSbas//3m9h4tABBw21w5C+TB/31d/58FTt/vgYel4PPloTiMb+hd9uODXRjgNyXXMHg+zztT13fTVVMJOFsCaQGtj3qZl0LbrWomlAY7gcvon9mjncBhwPkljagokG3u1r+6Lvscuz8+RoA4N3ocZSQBxElZXJf6ddvobqxA9Zmppjq3/+ymn0xa7wLHEQC1DR14MeL+rHatK9U+5MD3IduEwqiG05WQvVq/sGshX2mqA5rE5VtGF99zAd/CqcWm4OJkjK5L9UCr9kTXHSWdPgmXDwf7gkA2Pe7YW2Pyu66nxxCRUOIDswaP7jtHK9VN+HPB7IhUzB4coILVk+nBXqDjZIy6VFbpxzJXaX+5ulo6lrlT+HDYcrjILe0AXllDTp9LW3K6lp5TfuTiS7MHKecws4ZhCnsmqZ2LN2XiaZ2GUI9h+H9ZwKoDSMLdJqUn3/+eYNe4DTU/VRQhZZOOTxszXS+gMlBJMCcCcqV3V901UnWd7dbOnG9tgUANaEguuFsfWcKW5e3dlo7ZVj2RRbEDW0YYW+BT6kNI2sGlJQVCs2LcRQKBUpL7zQY+Pjjj++7R5noN9XUdUzgg5fV7IvYycp62McuVKCmqV3nr/egVE0ofB0tMYyaUBAd0fUUtlzB4PX/5OJCuQS2FnzsWzqRmqqwqF9JubGxEc8++ywsLCzg5OSEDRs2dGvgUFtbixEjqFeqMaht6sCpa3UAdLfq+o/Gu1sjxHMYpHIGX53V/+5RmTR1TQbBzHHKpJxdchuVEu1OYTMMg01HL+HnyzXgmyjbMHpRVTpW9Sspv/322zh//jwSEhKwefNmfPnll4iOjkZn552euDrc9kwG0dHzFZArGAR42Axqr1RVMZGvzpWiQya//2CW3VnkRUmZ6E63KWwt18L+/PdifJFeAgDYuSCQ/i/rgX4l5aSkJHzyySd4+umnsWzZMmRlZaG2thZz5sxRd06iMoPGQTV1resFXn80Y5wznK2EqGvuGNRtIP3VIZPjQle97lDqJ0t0TBdT2MkXq/CP48o2jG/O8le/BmFXv5JybW0tPD091V/b29vj559/RlNTE2bNmoXWVv1pM0YGrqimCfliCUy4HDw5YXB/UU15XLwQodoeVay3My8XxRJ1EwovO+006CCkJzPHK7vmZZXcRpXkwddb5JbexspDuWAY4PmHhuPlh4dm1UV91K+kPHz4cFy+fLnbMZFIhJ9++gltbW2IiYnRanCEHaqr5EdHObDS//a5iR7gm3BxoVyCXD3dHqWqdx3qRU0oiO65WN/ZAfHjxQe7Wi691YplX2ShXarAVD8HbJwzlv4P65F+JeXp06dj37599xy3tLRESkoKhEKh1gIj7FAoGCTlVgAAYoIHd+paxc5SgOgA5faofb8XsxJDb1SVvEKpaAgZJNqYwm5o7cTS/Rm41dKJsa5W2P2nYJhQG0a90q9/jb///e94++23MW3aNFy7dq3b90QiEVJTU/HLL79oNUAyuDKL6yFuaINIYILI0U6sxbGka8HXj/mVWpmu0yaGYdTboUKoMxQZJLPumsKubuz/70SHTI4/J2TjRm0LXKyF+HzpRFgIBtS9l+hQv5LysGHDMGHCBFy4cEHj90UiER599FGtBEbYoZq6njnemdXiAePcrBHmZQuZgsFX50pYi0OTG3UtqG/phMCEi3Gu1JKQDA4XazMED7cBw/S/nSPDMHjjuws4d7MeIoEJ9sVOhJMVzWzqowHNWzz//PP47LPPtB0LYVm7VI7jXb/sMUHuLEcDxE72AgB8fa4U7VL92R6l2goV4G4DvglN/ZHBo5rCPt7PpLwj9SqS8ipgwuXg4+dD4O9MlRb11YDmLmQyGT7//HP8/PPPCAkJgYVF983mO3bs0EpwZHD9UliDpnYZXK2FCB/B/r3SJ8Y4wdVaiApJO46er8AzoR5shwTgTr1rmromg23WeBf84/hl9RR2X652v8ksw0e/FAEAtsSMx5SRVGVRnw3oY/7FixcRHBwMkUiEq1evIjc3V/3Iy8vTcohksBzOUU5dRwe56UUhehMeFy9EeAEA9p/Rn+1RqkVeEykpk0HmamOGoH5MYZ+6Vos3j+QDAF573BfPTtSPD7akZwO6Uv7111+1HQdhWX1LJ05cqQEw+AVD7ue5iR7YlXYVlyoakVVyGxNZLtRxq7kDN7qaUAQPp6RMBt/s8S7ILW3AD/lVWDq557LGhVWN+MuBHMgUDKIDXRH/xKhBjJIMFN0QIwCA4xcqIFMwGOtqhZFOIrbDURtmwUdM14eE/XqwPUq16nqkoyVszKloPxl8M7vuK2eW1KOmh1XY1Y3teHFfJpo6ZAgbYYvtT0+gvcgGgpIyAQAcVnWE0qOrZBXV9qjkS1U67ynbG1VSDqWpa8ISNxszBHp0TWFraOfY0iHDi/szUSFph7eDBT59IQQCE2rDaCgoKRMU17Ugt7QBXA4wt6tohz7xd7ZChLcd5AoGCWfZ3R6lup8cQkVDCItm97AKWyZX4LX/5OJSRSPsLPjYvzSMZnQMDCVlot6bPGWkAxz1dO/i0q7tUf/JYG97VLtUjvxyZRMKWuRF2KSqhZ1ZfGcKm2EYbDx6Cb8U1kBoysVnSydiONVlNziUlIc4hmGQlMdOR6j+iBztBPdhZmholeL7rngH20WxBJ1yBewtBRhuS3/sCHvch5kjoGsKO/mScgr7X6du4MDZUnA4wM4FQQj0sGE3SDIglJSHuJzSBpTcaoU5n4fpY9krq9kbHpeDJV3bo9jqHpWpakLhSU0oCPtmd10tH79QieMXKrHlh0IAwPrZYzBjnDOboZEHQEl5iDuSWw4AmDHWGeZ8/a6D+2yoB8xMeSisasLZG/WD/vrZXUVDaJEX0QczxynvK2cU12PVN3kAgKWTvPBi160eYpgoKQ9hnTIFjl1QLhR5So+nrlWszU0xr6tz1f4zNwf1tbs1ofCkpEzY52FrjgB3azCM8nc5crQj3n5yDM3iGDhKykPYiSs1aGiVwlEkwGRfwyi9t7Rre1RqQTXK6lsH7XWv17bgdqsUAhMuxlITCqInVB+mx7tZ48OFQeDpQSU+8mAoKQ9hqgVe0YGuBvPLPNJJhIdH2kPBYFC3R6mmrgM9qAkF0R+LI7zw2ZJQ/OeVh/T+9hPpG73467Jnzx54eXlBKBQiPDwcGRkZPY6VSqXYtGkTfHx8IBQKERAQgOTk5G5jmpqasHLlSnh6esLMzAyTJk1CZmZmtzFLly4Fh8Pp9pgxY0a3MfX19Vi0aBGsrKxgY2ODl156Cc3Nzdp74yyStEnx82VlWU1DmLq+m+pq+WBGKVo7ZYPymlnFVDSE6B8el4Npo51gSX2RjQbrSfnQoUOIj4/HO++8g5ycHAQEBCAqKgo1NTUax69fvx6ffPIJPvroIxQUFGD58uWIiYlBbm6uesyyZcuQmpqKhIQE5OfnY/r06YiMjIRY3H0rzYwZM1BZWal+/Oc//+n2/UWLFuHSpUtITU3FsWPH8Ntvv+GVV17R/g+BBT/kV6JTpoCfkwhjXAyrjdtUP0d42pmjsV2m3mOta6qiIaFUNIQQoksMy8LCwpi4uDj113K5nHF1dWW2bt2qcbyLiwuze/fubsfmzZvHLFq0iGEYhmltbWV4PB5z7NixbmOCg4OZt956S/31kiVLmOjo6B7jKigoYAAwmZmZ6mM//vgjw+FwGLFY3Kf3JpFIGACMRCLp0/jB9MzeM4znG8eY//u1iO1QBuSzUzcYzzeOMZEfnGAUCoVOX6u2qZ3xfOMY4/nGMaahpVOnr0UIGdpYvVLu7OxEdnY2IiMj1ce4XC4iIyORnp6u8TkdHR0QCrtXnTIzM8Pp06cBKHs9y+Xy+45ROXHiBBwdHeHn54dXX30Vt27dUn8vPT0dNjY2CA0NVR+LjIwEl8vFuXPneoytsbGx20MfldW3IuNmPTgc4Kkg/Sur2RdPh7rDgs/DtZpm/F50q/cnPADVqutRTpawNjfV6WsRQoY2VpNyXV0d5HI5nJy6F61wcnJCVdW9hdYBICoqCjt27MC1a9egUCiQmpqKw4cPo7JSubVHJBIhIiIC7777LioqKiCXy3HgwAGkp6erxwDKqesvv/wSaWlpeO+993Dy5EnMnDkTcrmyhGNVVRUcHR27vbaJiQlsbW17jG3r1q2wtrZWPzw89LN36X/PVwAAIrzt4GJtxnI0A2MlNMXTIe4AdL89KpvqXRNCBgnr95T7a9euXRg5ciT8/f3B5/OxYsUKxMbGgsu981YSEhLAMAzc3NwgEAjw4YcfYuHChd3GPPfcc5g7dy7Gjx+Pp556CseOHUNmZiZOnDgx4NjWrVsHiUSifpSVlT3IW9UJhmFwOEdZMMTQFnj90eKuBV9phTUoudWis9fJKlauvKZ614QQXWM1Kdvb24PH46G6urrb8erqajg7ay4T5+DggKSkJLS0tKCkpASFhYWwtLSEt7e3eoyPjw9OnjyJ5uZmlJWVISMjA1KptNuYP/L29oa9vT2KiooAAM7OzvcsNpPJZKivr+8xNoFAACsrq24PfZMvluB6bQsEJlzMNPBSfD4OlnjMzwEMA3yZrpvtUe1SOfLFyiYUtMiLEKJrrCZlPp+PkJAQpKWlqY8pFAqkpaUhIiLivs8VCoVwc3ODTCZDYmIioqOj7xljYWEBFxcX3L59GykpKRrHqJSXl+PWrVtwcVGWrouIiEBDQwOys7PVY3755RcoFAqEh4f3963qDdVq5SfGOEEkNPz7o6rtUd9klqG5Q/vboy6USyCVM3AQCeBha5hT/YQQw8H69HV8fDz+9a9/4YsvvsDly5fx6quvoqWlBbGxsQCAxYsXY926derx586dw+HDh3Hjxg2cOnUKM2bMgEKhwJo1a9RjUlJSkJycjJs3byI1NRVTp06Fv7+/+pzNzc1YvXo1zp49i+LiYqSlpSE6Ohq+vr6IiooCAIwePRozZszAyy+/jIyMDPz+++9YsWIFnnvuObi6GubiKJlcgaNd95NV5SoN3SMjHeBtb4GmDpl6Wl6bslT1rqkJBSFkELCelBcsWID3338fGzZsQGBgIPLy8pCcnKxe/FVaWtptgVZ7ezvWr1+PMWPGICYmBm5ubjh9+jRsbGzUYyQSCeLi4uDv74/FixdjypQpSElJgamp8sqQx+PhwoULmDt3LkaNGoWXXnoJISEhOHXqFAQCgfo8X331Ffz9/TFt2jTMmjULU6ZMwaeffjo4PxgdOFVUh7rmTthZ8PHwSAe2w9EKLpeDJV1Xy/vPFEOh0G73qOxiqndNCBk8HIZhoQfeENHY2Ahra2tIJBK9uL/8+n9y8d/zFVg6yQsb545lOxytae6QIWJLGpo6ZPjixTA8Oko7HzgUCgbB/0hFQ6sUSXGTqT8tIUTnWL9SJoOjuUOGnwqUW7liDHzV9R9ZCkzwTKhy+9m+37W3PepGXTMaWqUQmnIx1pX9D1WEEONHSXmISL5YhXapAt4OFpjgbnxdjhZHeILDAU5cqcWNWu3UJ1fVuw70sIEpj35VCCG6R39phogjucpFUDGBbka5YMnL3gKP+ymLvWhre1RmMdW7JoQMLkrKQ0CVpB1nritLURp6wZD7WTrZCwDwbVYZmtqlD3w+VbvGECoaQggZJJSUh4Dv88RgGGVFKg9bc7bD0ZkpvvbwdbRES6cc32U/2Pao2qYOFN9qBYcDBA+npEwIGRyUlIcAVcGQmCB3liPRLQ6Hoy4m8sUDbo9SN6FwFMHazPCLrBBCDAMlZSN3ubIRhVVN4PO4mD3ehe1wdG5esBtEQhMU32rFiauae3L3hWrqOpSmrgkhg4iSspFTXSU/7u84JNoOmvNN8NxE1fao4gGfJ6vrSpmSMiFkMFFSNmJyBYPv87qmro2krGZfLI7wApcDnLpWh6Kapn4/v10qx0VqQkEIYQElZSOWfv0Wqhs7YG1misf8jKOsZl942JojcrSyTOv+M8X9fv75sgZI5QwcRQK4D6MmFISQwUNJ2Ygd7tqb/OQEFwhMeCxHM7hU26MSs8WQtPVve9TdU9fGuKebEKK/KCkbqdZOGVIuKstqGktHqP6I8LaDn5MIbVI5vs0q69dzVSuvaeqaEDLYKCkbqdSCarR0yjHc1nxI7rPlcDiI7bpa/iK9GPI+bo9SKJg7SZkWeRFCBhklZSOlWnX9VJBxltXsi+hAN9iYm6Ksvg1pl6v79Jzrtc2QtElhZsrDaBdqQkEIGVyUlI1QbVMHTl2rA2B8HaH6w4zPw3MThwPo+4KvTGpCQQhhEf3VMUL/PV8BuYJBoIcNRthbsB0Oq16I8ASPy8GZ67dwpar37VFZVDSEEMIiSspGKKlr6nooLvD6IzcbM0SN7fv2KNX95BBPSsqEkMFHSdnIFNU0IV8sgQmXgycnuLIdjl5YOmkEAGX7yobWzh7H1TZ1oETVhIKSMiGEBZSUjYxqgddjfg6wteCzHI1+mOg1DGNcrNAuVeBgZs/bo1T1rv2cRLASGn9JUkKI/qGkbEQUCgZJuRUAjLtvcn9xOBx1MZGE9BLI5AqN41SLvOh+MiGELZSUjUhGcT3EDW0QCUzUZSaJ0twAV9ha8CFuaMPPPWyPyqKiIYQQllFSNiKqBV6zxrtAaDq0ymr2RmjKw5/ClNujPtfQPaqtU45LXU0oaJEXIYQtlJSNRLtUjuP5lQBo6ronzz+k3B6VcbMelyok3b53vrwBMgUDJytqQkEIYQ8lZSPxS2ENmtplcLMxQ/gImn7VxNlaiJnjnAEAX/xhe9Sd0pq2Q7YCGiGEfZSUjcThHOXUdXSgK7hcSio9iZ2s3B6VlFeB+pY726OyiruKhtDUNSGERZSUjUB9SydOXKkBMLTLavZF8HAbTHC3RqdMgf9klAL4QxMKWuRFCGERJWUjcPxCBWQKBuPcrDDSScR2OHqNw+Fg6SQvAMrtUVK5AtdqmtHYLoM5n4fRLvTzI4Swh5KyETis6ggVSFfJfTF7ggvsLQWoamxHyqUqdb3rQA8bmFATCkIIi/TiL9CePXvg5eUFoVCI8PBwZGRk9DhWKpVi06ZN8PHxgVAoREBAAJKTk7uNaWpqwsqVK+Hp6QkzMzNMmjQJmZmZPZ5z+fLl4HA42LlzZ7fjXl5e4HA43R7btm17oPeqbcV1LcgtbQCXA8wNpLKafSEw4WFReFf3qN+Lka0qGkL3kwkhLGM9KR86dAjx8fF45513kJOTg4CAAERFRaGmpkbj+PXr1+OTTz7BRx99hIKCAixfvhwxMTHIzc1Vj1m2bBlSU1ORkJCA/Px8TJ8+HZGRkRCLxfec78iRIzh79ixcXTUntE2bNqGyslL9eO2117TzxrVEVVbz4ZEOcBQJWY7GcCwKHw5THgdZJbfxU4GymEioF91PJoSwi/WkvGPHDrz88suIjY3FmDFjsHfvXpibm+Pzzz/XOD4hIQFvvvkmZs2aBW9vb7z66quYNWsWPvjgAwBAW1sbEhMTsX37djzyyCPw9fXFxo0b4evri48//rjbucRiMV577TV89dVXMDXVXOtYJBLB2dlZ/bCw0J9WiAzDIClPmZRpgVf/OFoJMXu8CwCguUMGLgcIGm7DblCEkCGP1aTc2dmJ7OxsREZGqo9xuVxERkYiPT1d43M6OjogFHa/IjQzM8Pp06cBADKZDHK5/L5jAEChUOCFF17A6tWrMXbs2B5j3LZtG+zs7BAUFIR//vOfkMlkPY7t6OhAY2Njt4cu5ZQ2oORWK8z5PEwfS2U1+2tp1/YoAPBztoKImlAQQljGalKuq6uDXC6Hk1P3hOLk5ISqqiqNz4mKisKOHTtw7do1KBQKpKam4vDhw6isVFazEolEiIiIwLvvvouKigrI5XIcOHAA6enp6jEA8N5778HExASvv/56j/G9/vrrOHjwIH799Vf8+c9/xpYtW7BmzZoex2/duhXW1tbqh4eHR39+HP12JLccADBjrDPM+SY6fS1jFOhhg0APGwB0P5kQoh9Yn77ur127dmHkyJHw9/cHn8/HihUrEBsbCy73zltJSEgAwzBwc3ODQCDAhx9+iIULF6rHZGdnY9euXdi/f/99qzfFx8fjsccew4QJE7B8+XJ88MEH+Oijj9DR0aFx/Lp16yCRSNSPsrKe2wQ+qE6ZAscuKD9kxATT1PVA/eOpcZg+xgnLHh7R+2BCCNExVpOyvb09eDweqqu7d+2prq6Gs7Ozxuc4ODggKSkJLS0tKCkpQWFhISwtLeHt7a0e4+Pjg5MnT6K5uRllZWXIyMiAVCpVjzl16hRqamowfPhwmJiYwMTEBCUlJfjb3/4GLy+vHuMNDw+HTCZDcXGxxu8LBAJYWVl1e+jKiSs1aGiVwlEkwCQfe529jrEb52aNTxeHwtNOf9YKEEKGLlaTMp/PR0hICNLS0tTHFAoF0tLSEBERcd/nCoVCuLm5QSaTITExEdHR0feMsbCwgIuLC27fvo2UlBT1mBdeeAEXLlxAXl6e+uHq6orVq1cjJSWlx9fMy8sDl8uFo6PjAN+x9qgWeEUHuoJHZTUJIcQosH4jMj4+HkuWLEFoaCjCwsKwc+dOtLS0IDY2FgCwePFiuLm5YevWrQCAc+fOQSwWIzAwEGKxGBs3boRCoeh2rzclJQUMw8DPzw9FRUVYvXo1/P391ee0s7ODnZ1dtzhMTU3h7OwMPz8/AEB6ejrOnTuHqVOnQiQSIT09HatWrcLzzz+PYcPYvf8oaZPi58uqsprurMZCCCFEe1hPygsWLEBtbS02bNiAqqoqBAYGIjk5Wb34q7S0tNv94vb2dqxfvx43btyApaUlZs2ahYSEBNjY2KjHSCQSrFu3DuXl5bC1tcX8+fOxefPmHrc9aSIQCHDw4EFs3LgRHR0dGDFiBFatWoX4+HitvfeB+iG/Ep0yBfycRFQWkhBCjAiHYRiG7SCMVWNjI6ytrSGRSLR6f/nZT9KRcbMea2f6Y/mjPlo7LyGEEHYZ3Orroa6svhUZN+vB4SjvJxNCCDEelJQNzH/PVwAAIrzt4GJtxnI0hBBCtImSsgFhGAaHc5QFQ6isJiGEGB9KygYkXyzB9doWCEy4mDFO8z5uQgghhouSsgFRdYSaPtaZ6jQTQogRoqRsIGRyBY523U+eR1PXhBBilCgpG4hTRXWoa+6EnQUfU0ZSWU1CCDFGlJQNxJEc5dT1nABXmPLon40QQowR/XU3AM0dMvxUoGxlSauuCSHEeFFSNgDJF6vQLlXA28ECE9yt2Q6HEEKIjlBSNgBHcpV7k+cFud23/zMhhBDDRklZz1VJ2nHm+i0AQHQgTV0TQogxo6Ss577PE4NhgDAvW3jYmrMdDiGEEB2ipKznfrzYtcArmK6SCSHE2FHrRh3SRuvG5g4ZUi5WIXK0E6zNqYoXIYQYM0rKOqSrfsqEEEKME01fE0IIIXqCkjIhhBCiJygpE0IIIXqCkjIhhBCiJygpE0IIIXqCkjIhhBCiJygpE0IIIXrChO0AjJlqC3hjYyPLkRBCCGGbSCTqtakQJWUdampqAgB4eHiwHAkhhBC29aWQFFX00iGFQoGKioo+fTrqSWNjIzw8PFBWVmYQVcEoXt0ytHgBw4uZ4tWtoRwvXSmzjMvlwt3dXSvnsrKyMoj/wCoUr24ZWryA4cVM8eoWxasZLfQihBBC9AQlZUIIIURPUFLWcwKBAO+88w4EAgHbofQJxatbhhYvYHgxU7y6RfHeHy30IoQQQvQEXSkTQggheoKSMiGEEKInKCkTQggheoKSMiGEEKInKCnruT179sDLywtCoRDh4eHIyMhgO6Qe/fbbb5gzZw5cXV3B4XCQlJTEdkg92rp1KyZOnAiRSARHR0c89dRTuHLlCtth9ejjjz/GhAkT1AUMIiIi8OOPP7IdVp9t27YNHA4HK1euZDsUjTZu3AgOh9Pt4e/vz3ZY9yUWi/H888/Dzs4OZmZmGD9+PLKystgOSyMvL697fr4cDgdxcXFsh6aRXC7H22+/jREjRsDMzAw+Pj549913MRjroikp67FDhw4hPj4e77zzDnJychAQEICoqCjU1NSwHZpGLS0tCAgIwJ49e9gOpVcnT55EXFwczp49i9TUVEilUkyfPh0tLS1sh6aRu7s7tm3bhuzsbGRlZeHxxx9HdHQ0Ll26xHZovcrMzMQnn3yCCRMmsB3KfY0dOxaVlZXqx+nTp9kOqUe3b9/G5MmTYWpqih9//BEFBQX44IMPMGzYMLZD0ygzM7PbzzY1NRUA8Mwzz7AcmWbvvfcePv74Y+zevRuXL1/Ge++9h+3bt+Ojjz7S/YszRG+FhYUxcXFx6q/lcjnj6urKbN26lcWo+gYAc+TIEbbD6LOamhoGAHPy5Em2Q+mzYcOGMf/+97/ZDuO+mpqamJEjRzKpqanMo48+yvz1r39lOySN3nnnHSYgIIDtMPrsjTfeYKZMmcJ2GAP217/+lfHx8WEUCgXboWg0e/Zs5sUXX+x2bN68ecyiRYt0/tp0paynOjs7kZ2djcjISPUxLpeLyMhIpKensxiZcZJIJAAAW1tbliPpnVwux8GDB9HS0oKIiAi2w7mvuLg4zJ49u9v/Y3117do1uLq6wtvbG4sWLUJpaSnbIfXov//9L0JDQ/HMM8/A0dERQUFB+Ne//sV2WH3S2dmJAwcO4MUXXxxwox5dmzRpEtLS0nD16lUAwPnz53H69GnMnDlT569NDSn0VF1dHeRyOZycnLodd3JyQmFhIUtRGSeFQoGVK1di8uTJGDduHNvh9Cg/Px8RERFob2+HpaUljhw5gjFjxrAdVo8OHjyInJwcZGZmsh1Kr8LDw7F//374+fmhsrISf//73/Hwww/j4sWLEIlEbId3jxs3buDjjz9GfHw83nzzTWRmZuL1118Hn8/HkiVL2A7vvpKSktDQ0IClS5eyHUqP1q5di8bGRvj7+4PH40Eul2Pz5s1YtGiRzl+bkjIZ8uLi4nDx4kW9vocIAH5+fsjLy4NEIsF3332HJUuW4OTJk3qZmMvKyvDXv/4VqampEAqFbIfTq7uvgCZMmIDw8HB4enrim2++wUsvvcRiZJopFAqEhoZiy5YtAICgoCBcvHgRe/fu1fuk/Nlnn2HmzJlwdXVlO5QeffPNN/jqq6/w9ddfY+zYscjLy8PKlSvh6uqq858vJWU9ZW9vDx6Ph+rq6m7Hq6ur4ezszFJUxmfFihU4duwYfvvtN6212dQVPp8PX19fAEBISAgyMzOxa9cufPLJJyxHdq/s7GzU1NQgODhYfUwul+O3337D7t270dHRAR6Px2KE92djY4NRo0ahqKiI7VA0cnFxuefD2OjRo5GYmMhSRH1TUlKCn3/+GYcPH2Y7lPtavXo11q5di+eeew4AMH78eJSUlGDr1q06T8p0T1lP8fl8hISEIC0tTX1MoVAgLS1N7+8jGgKGYbBixQocOXIEv/zyC0aMGMF2SP2mUCjQ0dHBdhgaTZs2Dfn5+cjLy1M/QkNDsWjRIuTl5el1QgaA5uZmXL9+HS4uLmyHotHkyZPv2cJ39epVeHp6shRR3+zbtw+Ojo6YPXs226HcV2trK7jc7umRx+NBoVDo/LXpSlmPxcfHY8mSJQgNDUVYWBh27tyJlpYWxMbGsh2aRs3Nzd2uLG7evIm8vDzY2tpi+PDhLEZ2r7i4OHz99df4/vvvIRKJUFVVBQCwtraGmZkZy9Hda926dZg5cyaGDx+OpqYmfP311zhx4gRSUlLYDk0jkUh0z/15CwsL2NnZ6eV9+//5n//BnDlz4OnpiYqKCrzzzjvg8XhYuHAh26FptGrVKkyaNAlbtmzBs88+i4yMDHz66af49NNP2Q6tRwqFAvv27cOSJUtgYqLfqWfOnDnYvHkzhg8fjrFjxyI3Nxc7duzAiy++qPsX1/n6bvJAPvroI2b48OEMn89nwsLCmLNnz7IdUo9+/fVXBsA9jyVLlrAd2j00xQmA2bdvH9uhafTiiy8ynp6eDJ/PZxwcHJhp06YxP/30E9th9Ys+b4lasGAB4+LiwvD5fMbNzY1ZsGABU1RUxHZY93X06FFm3LhxjEAgYPz9/ZlPP/2U7ZDuKyUlhQHAXLlyhe1QetXY2Mj89a9/ZYYPH84IhULG29ubeeutt5iOjg6dvza1biSEEEL0BN1TJoQQQvQEJWVCCCFET1BSJoQQQvQEJWVCCCFET1BSJoQQQvQEJWVCCCFET1BSJoQQQvQEJWVCCCFET1BSJoSwpri4GBwOB3l5eWyHQoheoKRMCLmvqqoqvPbaa/D29oZAIICHhwfmzJnTrVkKIUQ79LsqOCGEVcXFxZg8eTJsbGzwz3/+E+PHj4dUKkVKSgri4uJQWFjIdoiEGBW6UiaE9Ogvf/kLOBwOMjIyMH/+fIwaNQpjx45FfHw8zp49ixdffBFPPvlkt+dIpVI4Ojris88+A6DsDrR9+3b4+vpCIBBg+PDh2Lx5c4+vefHiRcycOROWlpZwcnLCCy+8gLq6Op2+T0L0BSVlQohG9fX1SE5ORlxcHCwsLO75vo2NDZYtW4bk5GRUVlaqjx87dgytra1YsGABAGXbyW3btuHtt99GQUEBvv76azg5OWl8zYaGBjz++OMICgpCVlYWkpOTUV1djWeffVY3b5IQPUPT14QQjYqKisAwDPz9/XscM2nSJPj5+SEhIQFr1qwBoGxk/8wzz8DS0hJNTU3YtWsXdu/ejSVLlgAAfHx8MGXKFI3n2717N4KCgrBlyxb1sc8//xweHh64evUqRo0apcV3SIj+oStlQohGfe3qumzZMuzbtw8AUF1djR9//FHdDP7y5cvo6OjAtGnT+nSu8+fP49dff4WlpaX6ofpQcP369QG8C0IMC10pE0I0GjlyJDgcTq+LuRYvXoy1a9ciPT0dZ86cwYgRI/Dwww8DAMzMzPr1ms3NzZgzZw7ee++9e77n4uLSr3MRYojoSpkQopGtrS2ioqKwZ88etLS03PP9hoYGAICdnR2eeuop7Nu3D/v370dsbKx6zMiRI2FmZtbn7VPBwcG4dOkSvLy84Ovr2+2h6b42IcaGkjIhpEd79uyBXC5HWFgYEhMTce3aNVy+fBkffvghIiIi1OOWLVuGL774ApcvX1bfOwYAoVCIN954A2vWrMGXX36J69ev4+zZs+qV2X8UFxeH+vp6LFy4EJmZmbh+/TpSUlIQGxsLuVyu8/dLCNto+poQ0iNvb2/k5ORg8+bN+Nvf/obKyko4ODggJCQEH3/8sXpcZGQkXFxcMHbsWLi6unY7x9tvvw0TExNs2LABFRUVcHFxwfLlyzW+nqurK37//Xe88cYbmD59Ojo6OuDp6YkZM2aAy6VrCGL8OExfV3MQQkgPmpub4ebmhn379mHevHlsh0OIwaIrZULIgCkUCtTV1eGDDz6AjY0N5s6dy3ZIhBg0SsqEkAErLS3FiBEj4O7ujv3798PEhP6kEPIgaPqaEEII0RO0coIQQgjRE5SUCSGEED1BSZkQQgjRE5SUCSGEED1BSZkQQgjRE5SUCSGEED1BSZkQQgjRE5SUCSGEED3x/8NnolKtRSgQAAAAAElFTkSuQmCC\n" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Calculate the r2 scores and plot them\n", - "scores = cycle_specified_score(r2_score, random_experimentalist_cycle, X_test, y_test)\n", - "print(scores)\n", - "plot_cycle_score(random_experimentalist_cycle, X_test, y_test,\n", - " scorer=r2_score,\n", - " figsize=(5,3));" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": 9, - "outputs": [ - { - "data": { - "text/plain": "
", - "image/png": "iVBORw0KGgoAAAANSUhEUgAABOQAAAN+CAYAAAC1m9S3AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd3hUZdrH8e9MeockkwJJ6L2XJFQrAvbeUFEEWVfUVXRVFsvrKqJrWeu6a8Oy9oplRVEUQSAh9N4hocxk0klP5pz3j4GBSICgJJPy+1zXXHHmnDNzz1xyz5z7PM/9WEzTNBEREREREREREZEGYfV2ACIiIiIiIiIiIi2JCnIiIiIiIiIiIiINSAU5ERERERERERGRBqSCnIiIiIiIiIiISANSQU5ERERERERERKQBqSAnIiIiIiIiIiLSgFSQExERERERERERaUAqyImIiIiIiIiIiDQgFeREREREREREREQakApy0qBM06SoqAjTNL0dioiINBDlfhGRlke5X0Tk2FSQE4+ZM2eSnJxMWFgYMTExXHTRRWzatKnGPuXl5UyZMoWoqChCQ0O59NJLcTgcdX6N/fv3ExERwf79+092+CIi0kgp94uItDzK/SIix6aCnHjMnz+fKVOmsGTJEubOnUtVVRWjR4+mpKTEs8+dd97JV199xccff8z8+fPZu3cvl1xyiRejrj87d+7EYrGwcuVKb4ciIiINRLlfRKTlUe4XEW9QQU485syZww033ECvXr3o168fb775JpmZmSxbtgyAwsJCXn/9dZ555hnOOOMMBg0axKxZs1i0aBFLlixp8Hjtdju33XYbHTt2JCAggMTERM4//3x+/PHHBo/lWFavXs3IkSMJDAwkMTGRf/zjH94OSUSkyWoKub+8vJwbbriBPn364Ovry0UXXeTtkEREmrSmkPt//vlnLrzwQuLj4wkJCaF///68++673g5LRBoxX28HII1XYWEhAJGRkQAsW7aMqqoqRo0a5dmne/fuJCUlsXjxYoYMGXLEc1RUVFBRUeG5X1RUdFJi27lzJ8OHD6dVq1Y8+eST9OnTh6qqKr777jumTJnCxo0bT8rr/FFFRUWMHj2aUaNG8e9//5s1a9Zw44030qpVKyZPnuzt8ERE6kVLz/0ul4ugoCBuv/12Pv30U2+HIyLSIFp67l+0aBF9+/bl3nvvJTY2lq+//prx48cTERHBeeed5+3wRKQxMkVq4XK5zHPPPdccPny457F3333X9Pf3P2Lf5ORk85577qn1eR566CETOOJWWFj4h+I7++yzzbZt25rFxcVHbMvPzzdN0zQnTJhgnnvuuTW2VVZWmjabzXzttddM03S/zyeeeMLs1KmT6e/vbyYmJpqPPvqoaZqmuWPHDhMwV6xY4Tl+zZo15tixY82QkBAzJibGvPbaa02n03nUOP/1r3+ZrVu3NisqKjyP3XvvvWa3bt1+71sXEWn0WnruP9z1119vXnjhhSf+ZkVEmhjl/iOdc8455oQJE07oGBFpOTRlVWo1ZcoU1q5dywcffPCHnmfatGkUFhZ6bllZWX84try8PObMmcOUKVMICQk5YnurVq0AmDRpEnPmzGHfvn2ebV9//TWlpaVceeWVnvgef/xxHnjgAdavX897771HbGxsra9bUFDAGWecwYABA8jIyGDOnDk4HA6uuOKKo8a6ePFiTjnlFPz9/T2PjRkzhk2bNpGfn/973r6ISKPX0nO/iEhLpNx/pMLCQs9sIxGR39KUVTnCrbfeytdff80vv/xCQkKC5/G4uDgqKyspKCjwfPkBOBwO4uLian2ugIAAAgICTmp8W7duxTRNunfvfsz9hg0bRrdu3XjnnXe45557AJg1axaXX345oaGh7N+/n+eee44XX3yR66+/HoBOnToxYsSIWp/vxRdfZMCAATz22GOex9544w0SExPZvHkzXbt2PeIYu91Ohw4dajx28IvfbrfTunXrur9xEZEmoqXnfhGRlki5v6aPPvqIpUuX8p///Keub1dEWhiNkBMP0zS59dZb+fzzz5k3b94RhaRBgwbh5+dXo3nqpk2byMzMZOjQoQ0aZ11NmjSJWbNmAe7C4bfffsuNN94IwIYNG6ioqODMM8+s03OtWrWKn376idDQUM/t4I+Dbdu2neC7EBGRE6HcLyLS8jTV3P/TTz8xYcIEXn31VXr16lXn9yAiLYtGyInHlClTeO+995g9ezZhYWHY7XYAIiIiCAoKIiIigokTJzJ16lQiIyMJDw/ntttuY+jQobUu6FBfunTpgsViqVMD1/Hjx3PfffexePFiFi1aRIcOHRg5ciQAQUFBJ/S6xcXFnH/++TzxxBNHbIuPj6/1mLi4OBwOR43HDt4/2qhCEWmcduWW8OnyPQxu15pTutq8HU6L05Ryv4g0L4ZhUmUYBPj6eDuUFqcp5v758+dz/vnn889//pPx48ef0OuKSMuiEXLi8fLLL1NYWMhpp51GfHy85/bhhx969vnnP//Jeeedx6WXXsopp5xCXFwcn332WYPGGRkZyZgxY3jppZcoKSk5YntBQYHnv6OiorjooouYNWsWb775JhMmTPBs69KlC0FBQXVeLn3gwIGsW7eO9u3b07lz5xq32npaAAwdOpRffvmFqqoqz2Nz586lW7dumq4q0gQUllXxfnoml728iFOf/Jnnf9zC24t3ejusFqkp5X4RafqqXQaLtubw4Oy1DH38R95Ly/R2SC1SU8v9P//8M+eeey5PPPEEkydPrvsbFZH6YRhQnO3+2wipICcepmnWervhhhs8+wQGBvLSSy+Rl5dHSUkJn332mVdGer300ku4XC5SUlL49NNP2bJlCxs2bOD5558/YvrspEmTeOutt9iwYYOnZwS438u9997LPffcw9tvv822bdtYsmQJr7/+eq2vOWXKFPLy8rj66qtZunQp27Zt47vvvmPChAm4XK5ajxk3bhz+/v5MnDiRdevW8eGHH/Lcc88xderUk/dhiMjxncCXcbXL4KdN2dz63nKSZ/zAtM/WkLErH6sFRnaJ5sL+bRsgYKlNU8n9AOvXr2flypXk5eVRWFjIypUrWbly5Un5HESkbgzDwOFwYNTxRKy8ysUP6x3c/fEqBs/4gXGvpfH24l04iir4eZOznqOVo2kquf+nn37i3HPP5fbbb+fSSy/Fbrdjt9vJy8s7eR+GiByXJ/e7qmHBUzD7VvffRliU05RVaZI6duzI8uXLmTFjBnfddRf79u3DZrMxaNAgXn755Rr7jho1ivj4eHr16kWbNm1qbHvggQfw9fXlwQcfZO/evcTHx3PzzTfX+ppt2rTh119/5d5772X06NFUVFTQrl07xo4di9Vae207IiKC77//nilTpjBo0CCio6N58MEHdcVMpCEZhvtLeHcGJAyGkXdDLf9mtzj288my3Xy+Yg/Z+ys8j3eJCeXSQQlc1L8tcRGBDRm5/EZTyf0A55xzDrt27fLcHzBgAHBi/ZBE5PczDIMZM2aQlpZGamoq06dPP/LfrGFQWuDgpyyDb9c5+GljNiWVh4otkSH+nNUjlrG94xjWOaqB34Ec1FRy/1tvvUVpaSkzZ85k5syZnsdPPfVUfv755z/2IYhInRye+89I6c2dHbdhKcl2nweU5kBoDIZh4HQ6sdlsx/wt1xAspn4ZSgMqKioiIiKCwsJCwsPDG+Q1i4uLadu2LbNmzeKSSy5pkNcUkUakONt9ZazYAaGxcOGLEBoDQEFpJV+t2ssny3azaneh55DWwX5c2L8tlw5MoHfbcCwWi7eibxaU+0WkoTkcDiZOnIjdbicuLo7XX3/ds9J9UXkV89bb+Xb+QuZnB1NuHhqjEB8RyJhecYztHcfgdq3x9dGEot9LuV9EGtrhuT8+Lpb3/jyIsIKN7ovyI6ZilOQw49lXSEtPP/rFmgakEXLSbBmGQU5ODk8//TStWrXiggsu8HZIIuINQZEQ0x1MExIG4wqMYsGmbD5etpu56xxUutzD132tFk7vHsNlgxI4vVsM/r46CWuKlPtFBNz9xHr16oVpmqSmphIQ2opPl+3mf2v2sWBLzoHc7y4StfMvYuygrpw9sBP9EiJ0EaYJUu4XEaiZ+1NShxAydhqU5bnPBxY+Q9W2X2mftZ0v7f6kpaXhdDo9F2t+q8pl4DJMAv3qb0EfFeSk2crMzKRDhw4kJCTw5ptv4uur/91FWhzDgIXPgGMD28MG8knpeXz2j5+xF5V7dukeF8blgxO5sH8bokMD3MeU5kBwdK1TW6VxU+4XEcMwmDlzJqvWbya89xlsTxhJ8mM/UuU6NDGoky2Ec8J3crZlMT06d8IceTnOnFxM01RBrglS7heRg7l/7dq19O7dm2nTpmH18XXPjCl2T1v1ryogta0v3ZxRdB2YgmEYGIbhGSW3v7yK+ZudzF3vYN7GbO4/twdXJifVW8zKVNJstW/fXr16RFq4kgIH36wu4OOcM1lakQjsAKBVsB8X9W/LZYMS6N024tABdew3J42Xcr9Iy7a/vIpPl2zho32R7O9xA1h84cCCDF1iQjmnTzzn9o2na2zYgQsw52AERTLjsZnH7jcnjZpyv4g4nU7S0tJwOBxYLBZyc3MPjX4LjoaEwVh2Z9D5tHN4cvK1vPLqa9x00030SR5Or9FXM3dDNou35XpmzwAs2pargpyIiEhdmabJ8sx8Plyaxder91FaORwAKyandovh8sGJnNkjhgDfWoafl+a4i3HFjhrNX0VEpPEqrazmxw3ZfL16Lz9tclJZbUB4ewBaWcoYf3ofzuvXxl2EO5zVCqExOB0O0tLSsNvtx53CJCIijZPNZiM1NdVzccVmsx3aaLW6L7SX5mANjmb35iz+t6OK3ITzWFuWCLPXeXbtEB3C6J6xnNUzlgFJres1ZhXkRESkWXDur+Cz5bv5KCOLbc4Sz+MdooK5vG8kl6Z2IbZV8LGf5MDVM88IueDoeo5aRKQJaIip/Cf4GhXVLn7ZnMOXq/byw3oHZVWHVkftGB3CuX3iGJYQSGqPpOOOdjvmSZyISAvVEKuRnszXsFqtTJ8+vdbnM02Tdfv28/26fOas28BmRzHEDfVs758YwVk94xjTK5ZOttAGa12gVValQXljtSURab5chskvm518uDSLHzY4qDbcX2lBfj6c2zeeKwYnkty+9Yl9qaqH3Emn3C/ShDXEVP46vka1y2DJ9jy+XLWHOWvtFJVXe7YlRgZxXt82nNc3np7xJ746dkOceLY0yv0iTZdhGMyYMaNep/Kf8Guc4G90o9rFiq27mLO1nDnr7WTllXm2+VotDOkYybDEYC7u3Yr4+ASv/O7XCDkREWlysvJK+Tgji4+X7WZf4aEFGvontuLK5ETO6xtPWKDf73vyA1OYRESEhpnKf4zXME2TVbsL+WLFHr5evY+c4grPYbHhAZzXtw3n92vzh1dHtVqth6ap6sKMiLRwB/ux1edU/hN6jTpeuHEZJuk78pizZh9zVmzFUXHofCDQz8qpXW2M6RXHmd1jiQj0cT/nz+7nNEZMxZmT26AXZlSQExGRJqHKZfDDegfvpWeycGsOB8d3twr24+IBbbkyOZHucboCLyJyUjXEVP5aXmO7s5jZK/cye+UeduaWenZtHezH2X3iuaBfG5LbR+JjPYnTigwDSrJh2VuwZ5kW9xGRFqshpvIf6zWOGLV8jAs31S6DtB15/G/NPr5bZyenuPLAs/gRaqngzPA9jB11Fqf260yw/2ElsAMrr5rFDiq2LeSln3P5aem6Bl3cR1NWpUFp6LqInKidOSV8sDSLT5ZlHfYFC8M6RXFVShKje8YS6FfLAg3SaCj3izRxDdRDLse5j6+2VPDFyr2s2l3o2RRkqeKsuBIuOutMRnaLwc+nHmI4OPpi569QuBsCQiE0Fi58UaOmfyflfpGmzVs95Gqdygo1RshVD5vK4p35B4pwDvJKDp0jtAr246weMZzNIoaX/0JA0sDaL64YBsYvT7L15w/4dVcFTyyqJjQsnLi4OF5//fUGWdxHI+RERKRxOOyEr7La4PuVW3lvZQGLtud6drGFBXD5oASuTE6kXVSIF4MVEWlB6nEqf0l5FZ+lbWbelnx+2V6E60AvUB8LjOwYzkUVX3OWzzJCwiMh6Syoj2IcHBp9UZbvvh/USov7iEiLVmMq/0lmGAYOhwNwj5RzOp1ERUWRm5uLYRi1TmV1Db+LtA07+HpLKXMe/6lGEa51sB9jesVxTp94hnaKcl+4MfpC6WVHv5hkteLsPp6/P/sjG7NyMCmhdevWDbq4jwpyIiJSd/U1SuLAyISd2zbxftVIPtnTmtxK91eUxQKndrVxVXISZ/aop5ERIiJyVCd7lIRhmKTvzOOTZVnMXpZJFYdGOQeVOrg4YjN3dtqDrX1vIBL2RNZ/cezwabNtB8HA691FSE1XFZEWqr5GyBmGwSOPPMJ7772HaZokJCQQGBhIRUUFgYGBpKSkkJKSQnp6OikpqWzfb+XFxWv5du2+GrNlIkP8GdMrjnP7xDOkYyS+vz1HqMPFJFtMLN0GjaSgOo3zk5OZPHkysbGxDdZDTlNWpUFp6LpIE1ZPK+1VuQzmLt/Me98tYGFxG8/jsT77uTJqO1dccR0JCYl/+HXEe5T7RZquk7nS3s6cEj5bvpvPVuxhd/6h1e6iDSejzSUMqlzGh6vKubt/Ef07xeHfOgkufAEs1oZZYEGLOZxUyv0iTVd9rrLqcDi49tprSU9PxzRNAgICsNls5OTkYLPZaNe+PVMffY4ftxQwb2sBjqJDi/m0Cvbj7N5xnNunTe1FuN/Bm6tsa4SciIjUzUleaW9vQRnvp2fywdIsnPsrgDZYMDkluphxiXmcWTUf38RB0KbtyXsPIiJyQv7oSnv7y6v4ZvU+Plm2m4xd+Z7HwwJ8OadPHPvX/Ejq3jcZ2tbK7pB4KkIhulUWfmU5EB7rLo75NNApi1bZFhEB6neVVZvNxogRI8jMzPSMkAsICKAsoDUFcX2p6DKCSR9u8uwfHujLmF5xnNevDcMOTkc9iepzau7xqCAnIiJ1U9eV9o4xwsAwTOZvcfLukkzmbXRwoFUQ0aEBXDGoLVf3DiYxIgBCoqHsGD0fRESkQdR1pb3DRxiAhSXbc/l42W6+XbuP8ioDAKsFRnaxccnAtozpFUegnw/GJX1w2K/EWpZHx6Ru9MnaRPSC6VhKc8EnAMryVCQTEWlgvyf313V0mdVq5YEHHmDSpEms3+VgQ2kIny7dhVlYhR9QDQT5WRndK47z+7ZhZNdoAnwbaAG3Bh4prYKciIjUjdUKI6ZCzmaI7lr7l9RRprXmlVTycUYW/03bRVbeoWlKQztGcc2QJEb3jMPfSr1MiRURkd/ParUybdo0Nm7cSPfu3Ws94To4tWnB8vWE9D4TZ2jHGlNSO8eEctmgBC4e0JbY8MAjjn/t9TfcJ30pKUwf6Y+lcI97gxZVEBHxihPJ/Sc6rTW3uIKvVu3lX9+kk22EHtrgqsbq2MAp7UN46W83ExLodzLf0vHVU3ueY1FBTkRE6sYwYOEzx/6SOmxaq5mVwcotO3lnVRFfr95HZbV7hER4oC+XDUpkXGoSnWMO+xIuzj6pU2JFROSPMwyDmTNnHvWEq6LaxceLNvOBw0ZJ13FQZYX8MsICfDm/fxsuH5RA/8RWWCyWWp//8GlRm5YvpCohiAD/EAhqDYOu14UZEREvOF7uhxOb1lpW6WLuBgdfrNjD/M3OAytqh4JpELR/N2F5G6nakUF0eDAzn3i74YtxcNLb89SFCnIiIlI3dfmSCo6mPD6ZL9fl83buQNau3eDZ1LttOOOHtOf8fm0I8q9l2Hldp8SKiMjRneTpNkc74dpoL+LDpVl8vmIPBaVVEOpefKeNtYi/XjaSs/vEE+h3/ClGh0+L6jYwBb+OAbBnmft7IOQEToS0IIOItGAne2GCuhTbjjet1WWYLNmey+cr9jBnrZ3iimrPtt5twwlxrqdg9Y8MG9ALS1wU6cWtSU1NPaF+bif1fXvhXEQFORERqZvjfEll5ZXy3yW7+HBpPwrKqgDw97VyXt94xqcm0S+yCkuI7egnSlare9SdTqhERH6fephuc/gJ18CUofy0q5wPPvmVlVkFnn3iIwK5bGBbzugQTL/OCe6TIsPAKLLjLDWxxcQe9UTJarUyffr0QydUcOLfA16YZiQi0lic1BVRD1zcsEVHHbeHnCd/ZzuwBVuwHoglbcNO/rc+j7lbCrAftkJq21ZBXDygLRcNaEPnmDAMYzhO50We5z7RwtpJXwnWC+ciKsiJiLRkJzKioJYvKcMwWbg1h7cX7+THjdmYBxZpSGgdxLWpSVzRM4jIqFj3VNeFdThR0gp3IiK/Xx2n25zIiAKr1cqFN9xKfqcxfLYpj7c/WwuAr9XCWT1juSI5kVO62PCxWjzP7bDvI3rDW2yb/yFpe6rZmXg50++//5hFuRojIk70e8AL04xERBqLuoxmq1PeP+zihjVhMNP/Ng1nTu4xj7ECsZveIXfHaj6pHMKrO2LIMUM828MDfTmvXxsuHtCWQUmtsVoPtS/4be4/5si4Ws5Z6mUl2AY+F1FBTkSkpfo9IwoOfEkVV1Tz2fJM3ly0k+3OEs/mkV2iuX5oe07vGo3Pr0/D3AyI6Q6ODVCSrRMlEZH6VIfpNnUdUVBSUc1Xq/bybloma/YUeh5vHxXMVSlJXDowAVtYQK3PvWnZAqb32YdvWR7tfQ2+W77w5JwoHY1aHohIC3a8qaN1Hkn2m4sb1rK8Y+btKpfBz6u28MmvofxYdDnVB8pLpquaqsyVJBl2Pn72QRLbxv+xN3iUc5a6rgTbmKkgJyLSUv2OEQW7ckt4a9EuPs7IYv+BPhChAb5cNiiBa4e0O7RIw+ELNJgmxPaEbItOlERE6lMdptscb0TBJvt+3k3bxefL93jyvL+PlTG947g6JZEhHaJqjHCo7bkd9lwyomFwfCQ7C6HbwBH1e6Kklgci0oIdMfX/9y6+EBQJMT3cv91r+81+YJTapqIAPl6+hy9W7iGnuBJoB0BsRSY5GzMwd2UQ6Crn7HHjaBt/Ei7EHOWc5XjvuylQQU5EpKWq44gC0zT5dWsus37dwbxNh6aldowO4fph7bl0UAKhAb/5Ovntc4+YCmV5OlESEalvh0+3qWWKT20jCsqrXMxZa+e/S3aRsSvf81Tto4IZl+oeDRcVGlDbq9Vw+HPvTErh6tsnEVluOWYPuZNGLQ9EpAU7fPrnb6en1mkkmWG4W8w41kNsD/dv98PydmFJBV9++jYf7/Bnddmhc4boUH8u6t+G0oxPWbM2jXOGpDDptb974jkpuf8Y5yxHtDxoYiymefDUSqT+FRUVERERQWFhIeHh4d4OR6R5OV4/uNq2H+OY8ioXX6zYwxu/7mCzo9jz+OndbFw/rD2ndLEddZREneKRFkO5X6T+HLUv0IEpPmbWUopb9yBk7INYfXxrHFPpG8p7S7P4cGkWeSWVAPhYLYzuGcs1qe0Y1unoo+FOOB5pcZT7RerP0XLtwempS5YsoXfv3syYMQNfX9/j5+bibJh9q3sUWmgsXPgiRrCNJTty+WhpFt+u3UdFtbt05IvBmd0iuTy1M6d2s+HnY63/3N9Mzys0Qk48fvnlF5588kmWLVvGvn37+Pzzz7nooos8203T5KGHHuLVV1+loKCA4cOH8/LLL9OlSxfvBS0ibsfrB3e07bWMKLAXlvPOkp28l5ZJfql7tdRgfx8uH5TA9cPa09EWWreYNFpBRKReHbMvUGkOZtZS9m1dxe6CpSxcVskd9z8GWFi4NZe3F2cxb6MD48Cl+fiIQMalJHFFciKx4YG/O6amPlpBRKSxqzX3A5Tm4Cx2sWTJElauXElGRgYAM2fOPH5uPmwUmiN6CB+nFfDRsnVk5pV6dukWWs4VYau5qEc4UaPurHGuUe+5v5meV6ggJx4lJSX069ePG2+8kUsuueSI7f/4xz94/vnneeutt+jQoQMPPPAAY8aMYf369QQG/v4fbiJyEhyvH1wd+sWt3VPI6wt38NWqvVQfOENr2yqICcPbc/ngRCKC/BryHYmIyHEcsy9QcDTFrXuwu2ApGXYLP27fgP83aXy2qYLtOYcW4xneOYrrhrRnVI8YfH2az6gDEZHm6ojcn+0gdtM7kLUUW0wP+vbuSUZGBr6+vqxZs4b169fTs2fPY45cc2Fhvm08720bzryfCzDMLYC7V/T5/dpwZXIi/dqEYSkb2exGqXmTCnLicfbZZ3P22WfXus00TZ599lnuv/9+LrzwQgDefvttYmNj+eKLL7jqqqsaMlQR+a3j9YOrbbthYJQ4+THT4LWFO0nbkefZPaV9JDeOaM+oHrE6QRMRaaSO2RfIaiVk7IN8tdSH/5X4U9K+O0/96s7zwf5WLh+UyHVD2x9ajEdERJqEI3J/kAk7fwXnRqx7l/PoGeMwuZ7Va9ZSUVHBvffeS2pKCn+69hJs7Xt42hcA7Cko46OlWXyUkcW+wnLP48ntW3NlchLn9Ikj2P+wslEzHKXmTSrISZ3s2LEDu93OqFGjPI9FRESQmprK4sWLj1qQq6iooKKiwnO/qKio3mMVaZFqW2Hut70WDm4PiqQs384n33zDG1tD2FEZAYCv1cK5feKYOLIjfRNaeff9SJOm3C/SMGpbYc4wDBzZ2WwssPDW4l38XD4Yotz7d/TN4RwWkbEmE9+KziSNfRKHw6F+b3JSKPeLNIwauT86CuuCpzHzd2KWF2IJjMDHuZHHpr/A+swc7r33XvbsziLMfwXbc14nPbA9Z/zft8xZvZtvNhXy8yanp3VBq2A/Lh2YwNUpiXSOCfPum2whVJCTOrHb7QBHzAuPjY31bKvNzJkzefjhh+s1NhE54Lcr69XSM87pCuOdN97hnZ3h5LvaABBuKWVcqw1cH7ON+Da9oM3dXnwT0hwo94s0nMP79pSUVzH5sdfIKAqjIrA1ABYLnN7VxsAdrzGoYA5LsqoYUFnJAMcS3pr0HbPzOpM6ZGjN/nMiv4Nyv0jD8eT+4mzM3RnsKyiBMoOyaj86JAzGGhpD9+7RlJeXU5m/l57hVZRUR/D9/nb8ZdqnGMFRnuca2jGKq1ISGdMrjkA/Hy++q5ZHBTmpV9OmTWPq1Kme+0VFRSQmJnoxIpEW4jc947ZlZfHaskI+XbabSpe7aJfok8dE/x+5PGgpIZRDWSzsLqu1v5zIiVDuF2lYjqJy3l68k3cW76SoMgkCweqq5PLBCfz5zJ4EuYqZNHEPX+ZFUlhYwCPJZcQEA6VOSpz+pKVZa/afE/kdlPtFvKBGv9BgFpfH89TN44m1Wsl1OgkIDMTSaQT/CO7PjvABGJYDJaDKEqKKtvDvu68luXs7776HFkwFOamTuLg4ABwOB/Hx8Z7HHQ4H/fv3P+pxAQEBBAQE1Hd4IvJbB3rGZWzaxb8dI/jh5bWeTf0iSvlTRDpjukfhU50E2cXgqgSfgNr7z4mcIOV+kYaxbm8hry3Ywder91Llcs85CrNUELI3g7M6hfDw5RcemMYaRErqENLS0jhn9IUYlQupLNnGboIIsSUd2X9O5HdQ7hfxggP9Qhcuq+SnrWtISR2CLSaW/eVVfLu1lL19J1BiBrHtwO4uxxZ8dy6mW3Apw4ekMKiriubepIKc1EmHDh2Ii4vjxx9/9BTgioqKSEtL489//rN3gxORGgzD5IcN2fxn3XCWZfYC3FOWRvWIZfIpHRmcGIGl7NRDhbcDfeUoy9OqSSIijZxpmvyyJYdXf9nOwq05nseT27dm4ogOnNk9hrzc4TX6wv221xymQW7mJgYmdOHcvHz1kBMRaSp+2yMasPr4csf9j3GN00muK5AHZq/j8xV7KK10AUEE+1m5aEBbxqUkQkE7una9hfx85f7GQAU58SguLmbr1q2e+zt27GDlypVERkaSlJTEHXfcwaOPPkqXLl3o0KEDDzzwAG3atOGiiy7yXtAi4lFR7WL2ir3855dtbHOWAODvY+XSQW2ZNLIjnWyHraR3+JTUg/+taaoiIo1WZbXBV6v28uqC7Wy07wfAx2rhnD7x3DSyQ43FeGqbenp4rzmwYuvQ66j7iohII3SUHtHVLoMfNjiY9etO0nbkeXbvEhPKdUPbcfGAtoQF+rkfTHD3F1XubxxUkBOPjIwMTj/9dM/9gz0grr/+et58803uueceSkpKmDx5MgUFBYwYMYI5c+YQGBjorZBFBCiuqOa9tF28vnAHjiL36mZhgb5cN6QdNwxvT0yY/o2KiDRVxRXVfJCeyWsLdmAvKgcg2N+Hq5KTmDC8PYmRwV6OUEREGsRvekTn5ezjg/Vl/HfxLvYWur8ffKwWxvSK5boh7RnSMRKLxeLloOVYLKZpmt4OQlqOoqIiIiIiKCwsJDw83NvhiDRpucUVvLVoJ28t3kVhWRUAceGBTBzRgatSEg9dCRPxMuV+kTo6bCpSbmnVETk+JiyACcM7MC4liYhg5Xhp3JT7RerGMAxPS4FjTiE9MEJuw5ZtvFk+ki/sUVRUGwBEhvgzLiWJa4YkER8R1ECRyx+lEXIiIk3FgRO1vRVBvPLzRj5YmUN5lftLuGN0CDef2omLBrTF31e9IEREmpwDJ1q7t2/gtfLT+WCvzZPjk1oHcPOpnRmZGEDb+Fj1/BERaSYMw2DGjBmkpaWRmprK9OnTDyzG4y7SRUVFkZubS1RUNPO35PD6plNYtL3XwaPp3TacG4Z14Ly+8QT6+Xj1vciJU0FORKQpMAx2zHmel1ebfFbQiWrcX7h92oZzy2mdGd0rDh+rhqSLiDRV27N28/ISfz7Pv/hAjjfo0zYCW84K7L98x+vfl/FuYCBDhgzxnLCJiEjT5nQ6SUtLY9++ffzyyy9MmjSJ2NhYZsyYwZIlSyitdFEW34/StikUme42ND5WC2N7xzFhWHsGtWutaalNmApyIiKN3EZ7ES99v45v1nfCwH0CNjRgJ7fEb2bENX/DEqamrCIiTdVGexEv/bSNb1bvxTC7ADDcfxu39LPSadglTLrpcfbszsJutxMfH09aWhpOp1MNuUVEmoJaVkU9nM1mIzk5mffee4/i4mJeffVVbrrpJhYuW8uOkF5UdE3GEhAMJoQF+DAutR3jh7WnbStNS20OVJATEWmkVmUV8OJPW5m73nHgEStnhmUxJSqDgaGFkJgMITavxigiIsdxlJOxNbsLeWHeFr735HgY1SWCKVVvMsCyBcpjMUIuIzU1FdM0iY6OJigwgDNSemOLjvLGOxERkToyDANntgPbxrex7llWY1XUw1mtViZPnszChQvJz89n/upt7P1uJ5u7X4eJBQvgX5FPb/8cZt1zMxEhWqytOVFBTkSkkVm2K5/nf9zC/M1OACwWOKd3PLec2pFerSohaBKU5R31SpuIiDQSB/rCsTvDczK2Zu9+nvtxMz9syAYOy/Gnd6JXXBgsWAS7iyBhMNbQGKZPn+7uIxTZmrLvHyU0fwOWhc/UemInIiLed7Av3KZlC3iwv5Mu8eFYdme4L86Exhyxf0xMDB2HncvC3EByQhPZtjEPsDAwIZTJp3Rm3rvPs27tWp5/Zr9aFjQzKsiJiDQSadtzeWHeVhZuzQHc/SEu7N+GW07rTOeY0Jo71/JlLiIijUxpjrsYV+xg7ZbtPLttMT9sLgDAaoEL+rVhyumd6RIbduiYkXfXGFFnBff01OJswgo2Qkm2+zmPcmInIiLedbAvnMOeS5qtmnZJrQhIGOzO64epchl8s3of/56/jY0VXSDU/fv/nD7x3DSyA30TWuFwOHhx3TocDodaFjRDKsiJiHiRaZos3p7Lcz9sIW1HHgC+VguXDkzgltM70S4qxMsRiojI7xYczbrwETy7y4+5RUlAAVYLXNi/Lbee0ZlOttAjj7Faay+0BUe7R9kdHG33mxM7ERFpHGw2G6mpqaSlpbEzMQW/yya78/qBkW2lldV8kJ7F6wt3sKegDIAQfx+uTE7ixhHtSWgdXOtzpaamYrOpXU1zYjFN0/R2ENJyFBUVERERQWFhIeHh4d4OR8SrFm3L4dkftpB+oBDn52PhisGJ3HxqJxIjg49ztEjTodwvLdE2ZzHPzN3MN6v3Ae6pqRf2a8OtZ3Q5ctRzXR2nObhIY6LcLy2ZYRg4nU5sNptnimleSSVvLtrJ24t3UlBaBUB0qD8Thnfg2tR2RAT71fm5pHnQCDkRkQa2eFsuz/6w2TMizt/HylUp7kJcG62YJCLSpO3OL+W5H7bw6fLdGAcue5/frw1/OfMPFOIOOtroORERaVSsVqtnaqm9sJxXF2znvbRMyqpcALSPCuamUzpy6cAEAv186vxc0ryoICci0kDStufyzx82s2R7zULcn0/rRHyECnEiIo2OYbh7tpnUmG5UG+f+Cl76aSvvpu2iyuWuxI3qEctdo7vSI16jg0REmgrDMHA43Ctgx8bG/u5RaTtySvjP/G18uny353uhd9tw/nxqZ8b2jsPHajlpMUvTpIKciEg9W56ZzzPfb/Ys1uDvY+XKZHchTiPiREQaKcOAX56E1R+57/e9Ak756xFFueKKal75ZTuvLdhOaaV75MOwTlHcPaYbA5NaN3TUIiLyBxiGwSOPPMJ7770HwDXXXMP999+PFWptGVDbdNJN9v28+NNWvlm91zNSOrVDJFNO78zILtFYLCrEiZsKciIi9WTtnkKembuZeRuzAfdiDVckJ3Lr6Z1ViBMRaexKc2DXIvcIOYDMRTVWNq1yGXyQtovnftxMTkk1AP2CnNzTu4ThF5+tHm8iIk2Q0+lk4cKF2O12LBYLCxYswJntIHbTO55FdYwRU3Hm5BIVFcXMmTM9Cy5cNOFWXvppO3PW2T3Pd0b3GG45rROD20d68V1JY6WCnIjISbbZsZ9nvt/s+TL2sVq4ZEBbbj+zixZrEBFpKoKjod0wKNztvp84FAwD0+Xi2/XZPDlnIztySwFoH1TOPdGLOdtnKZbyWCi9XL3eREQau1oWyrHZbIwYMYLMzEwAhg8fDiU5mFlLsZRkY2Yt5dkZ9zMvfS29evVi7dq17C7zZde+SF5/cRHgXsTn7N5x3Hp6F3q2UcsCOTqtsioNSqstSXOWmVPMP+es5Yt1uZim+8v4ggONvDva/mAjb5EmTLlfmqyDPeQMA1a8w4otu3gk93SWF7gvrkT5lPGXVgu4JHIXwYl9sGZvhNiecMYD4KPr3tKyKfdLo2YYsOApz6g3Rt7tKcod7CFnGAavv/46S9PTmJpsclqnEIpb92Dcy8vYZ3cQ2LY71d3HYLe4R79ZLXB+33huPaMLXWLDvPnupInQLwURkT8ou6ic53/cwgfpu6g23T0hxvaKZerobnTVl7GISNNltUJYHHv3ZPHE4mBmF54LQJCflZtGdmSS9UvsC+fz7dZKNmb1Y/qw7lgd62HhMzVO7kREpJEpzXEX44od7r+HtSSwAvFhPjiKIT09HbvdwTNLY+k9/v+ISupGu/RnWbsLzLgeAFhMk/4Vy7gtfAGnxZ+F1dbfe+9LmhQV5EREfqeC0kpenr+NtxbtpLzKACycErSdu9usp+/FD0OoinEiIk1ZSUU1/5m/jf/8sp2K6o5YMLm0bQF/ve4SYlsF49g3jlUfzSLOJx/2fkxVVmcCqguPOLkTEZFGJjjaPTLu4Ai54Gj344eNnLO1HURqSgpp6emkpKay2xrPX99ezs8VPSAOTMOFdVc6vctXM7XNUuLKrFRtDyFgsPK/1I0KciIiJ6is0sWsRTt4+edt7C93N/IelNSKv8atYEjZgppf6iIi0uQYhsnnK/bwxJyNZO+vACClfWsePDOe3p3aHeo1FOJDvzYBWEqsxIb445fYD5yb9D0gItLYWa3ukcy/XTn1sJFz1j3LmH7H8yzcdR2zMpxc/PJiAHwsYO5Mo+DXD4gOhJ4XXcjO/B3Ehvji13GY8r/UmQpyIiJ1VO0y+ChjN8/9uBlHkfsErXtcGPeM7cbp3WKwmEOh+DLQSuYiIk3Hb5p6r91TyIOz17I8swCAxMgg/nZ2D8b2jsNiqZngraExdD7tKiq3/0plTD9377jygpondyIi0ugYhoHT6cRms2E9PF8fNnJuc8Rw/jl7N9+ucwDuhdouHtCWW07ryH9fXsYvziQGDhzII48+Sn7eVGzBFqyhMcr/UmcqyIlIy1DLKkp1ZZomc9baefK7TWzPKQEgoXUQd43uyoX92mK1Wg7uCCverrU5rIiINDzDVU1u5iaikrphrW2RhcOmJuXHpPLk/rN4f2kWpgnB/j7cekZnbhzegUA/n9pfwGqFkXfxr1/y+emz5aSseILp06fXPLkTEZEGVV1dzcaNG+nevTu+vkfmfsMwmDFjBmlpaaSmptbM21YrO3v+mWez1jL71zxM01HrQm1/+9vfKCkpYe3atTzxhHK//D4qyIlI83eMVZSOZ+nOPGZ8s4GVWQUARIb4c9sZnRmXmkSA729O0I7RHFZERBqW4apm/qMXEJK/nrWte3Lq/V8eWZQrzcGVtYz398Xz1Pr2FLiyADi/Xxv+dk534iOCjvs6zpxc5qWvxW53kJaWhtPpJDY2tj7ekoiI/NZvLrpXV1czZswY1q5dS+/evfnuu++OKMo5nU7S0tKw2+018ra9sJznftzCRxlZuAwTgLG94rjzrK50i6vZGzo3N5d169bhcCj3y++ngpyINH+/o1C2zVnM499uZO569xD1YH8fJo3syE0jOxAW6Ff7QUdrDisiIg3jsBOz3MxNhOSvJ5RSyF9PbuYmbB161dh9dZ4f0zMvZ02Ru/DWPS6M/7ugF0M6RtX5JW02G6mpqZ6RFjab7aS+JREROYoDF93NrKUUt+5ByNgH2bhxI2vXrqW4uJi1a9eyceNGevfuXeOw3+Ztv5AIZv5vA28u2klFtQHA6d1sTD2rG30SImp9aeV+ORlUkBOR5u8ECmXO/RU89+Nm3k93XxmzWuCqlCTuGNWFmLDAY7/O0ZrDiohI/fvNaOio4XewtnVPyF9PSeueRCV18+xaWFbFU99t4r9puzDNIMICfLjrrK5cO7Q9vj4nlrutVivTp0+vvReRiIjUn9IczKyl7Nu6it0FS1m4rJJb7/s7vXv39oyQ6969+xGHHczbmXvtfL25hFOfmu9ZqC25fWvuHdudwe0jj/nSyv1yMqggJyLNXx0KZeVVLl5bsJ2Xf95GSaULgFE9Yrjv7O50jgk7Yv9jvpamqYqINLzfjIa2lhdw6v1f1ughZ5oms1fu5dFvNpBT7F6c5+IBbfnbOT2whQX87pe2Wq2aqiQi0tCCoylu3YPdBUvJsFv4aesarsnL5btP32FjVg7de/SstYdclcvgw6VZPPfjFpz7a1mozVK3FdqU++WPUkFORFqGoxTKDMPky1V7+cecjewtLAegb0IEfzunxwlNWRIRES+rZTS01Wr1TFPd7izm/i/WsmhbLgCdbCE8clFvhnVSewERkSbJaiVk7IMsXFbJT1vXkJKSim3j21j3LKN3wmCwHjZV1TAwS5x8v8vgie82sd3pXqgtMTKIu87qxgX92hxaqE2kgaggJyItVsbOPB75ZgOrDizY0CYikHvGdtcXsohIU3SU0dCV1Qb/mb+NF37aSmW1QYCvldvP7MJNIzvi76spRiIiTc5h/UKtPr7ccf9jXON0YgsysX51+5F9ow2DZV++xMzVIWSUuke0HVyo7ZrUdvouEK9RQU5O2EsvvcSTTz6J3W6nX79+vPDCC6SkpHg7LJE6y8or5fFvN/LNmn0AhPj7cMvpnZk4ogOBfj7HOVpERBqt34yGztiZx7TP1rAluxiAU7vaeOTC3iRFBXsrQhER+SN+0y+UkXcfmjpqGEeMlN6ZU8ITX6/i240dAQi0VDNpWCJ/OqvP0RdqE2kgKsjJCfnwww+ZOnUq//73v0lNTeXZZ59lzJgxbNq0iZgY9c2Sxq2kopp//byVVxfsoLLawGqBK5OTmHpW1z/UO0hERBqBw0ZMFFa4eGLORt5LywQgOtSfB8/vxfl94+vcG0hERBqh3/QLNYqzcZZZDi2scGCkdKElguf/t5G3F++kymVixeTy1lu4s79J3Fnna/E1aRQspmma3g5Cmo7U1FSSk5N58cUXATAMg8TERG677Tbuu+++4x5fVFREREQEhYWFhIeH13e4IoC7T9znK/bwxJyNZB9o3Dq8cxT3n92dHhGVWhFVpJ4p90u9O2zExBzf03lwaxdPvr9ycCLTzulOq2D/A7saWhVPpAEo90u9OCzfG20HMeOXCtLS00lNTWX69Om4TPjvkl089+MWCkqrAPfo6PvGdiG6Yq9nkR+RxkD/J0qdVVZWsmzZMqZNm+Z5zGq1MmrUKBYvXlzrMRUVFVRUVHjuFxUV1XucIodbnpnPw1+t9/SJa9c6gOnn9uKsHjFYFj5dY7i7inIiJ4dyvzS40hyyd6zlocwhfFuaBFTQMTqEGRf3IbVDa5xOJ0agDYAZM2aQlpbmOXlTUU7k5FDul3p3cCT0iKlQloez2EXaUzdht9tZkpbGZ0u28K9F+9ie416woWNUIA+e35tTutqU+6VR0v+FUmc5OTm4XK4jlnaOjY3FbrfXeszMmTOJiIjw3BITExsiVGkJDAOKs91/a5G9v5ypH63kkn8tYlVWASH+PtzXzc73bV5jdO47WEqcNYa7U5rTwG9ApPlS7pf6YhgGDocD47Dcb5omH20oZ9TWy/i2tBu+FpNbT+vE//4yktQOrZkxYwYTJ05kxowZOBwO0tLSsNvtpKWl4XQ6vfhuRJoX5X6pL4Zh4LDvw/jlSZh9Kyx8BoKjscXEkpqaSqt2Pcjvew13f7mV7TklRIX4M9x/F0Hzn2XBx68o90ujpYKc1Ktp06ZRWFjouWVlZXk7JGkODg5Vn32r++9hJ2ZVLoNXf9nOGU/N57Ple7BY4PJBCfx0Sx9u9v+OgNJ97gKcBffIuNBYT9NXETk5lPulPhiGUaO4ZhgGWXmlXPd6Ovd8uoaiah/6xAfz5a0juHtsdwL9fHA6nTVOwsDdfiMuLo7U1FRsNpuX35VI86HcL/XBMAxmPPooD986jq0/v4952MX0ovJqqvpczI6uV7HXCMffx8qfT+vER9f3onD5/3DY9yn3S6OmKatSZ9HR0fj4+OBwOGo87nA4iIuLq/WYgIAAAgLULF9Ost80cz24pPmCLU7+78t1bHO6h6n3S2zF3y/oRb/EVkeuuhQS42n6qh5yIieXcr/Uh8OLa0vS0njx+7W8/OteyqpcBPhamXpWVyaO6ICvz6F8brPZSE1N9UxTio2NZfr06eohJ1IPlPulPjizHbTP+pjTbDmUFPlSmZiET5vBvL+6hKd/WOnpEze2Vxx/O6cHSVHBGIZBamoq6WlLOD2lN7G2KKb/5SacpZOwxcQq90ujoUUd5ISkpqaSkpLCCy+8ALivWCQlJXHrrbdqUQdpOL9Z7nxPnyk88s1G5qxzT52OCvHn3rO7c9nABKxWS83jVIATaXDK/XIyHBwh98uKTRR1Px+HEQpAaodIHr+0Lx2iQ456nApwIg1PuV9OBqPIztZnzsZSko0ZYiP33Nd4+NdSNtr3A9AtNowHz+/J8M41Z7sYrmpK5vyd0Pz1WFyV4BMAicnqGy2NikbIyQmZOnUq119/PYMHDyYlJYVnn32WkpISJkyY4O3QpCU5sKR55f5sXlu+nxf+uYCyKhc+Vgvjh7bjjlFdiQjyq/240JiGj1dERP4wwwTbyKvJLN9MhcskxN+Haef0YFxKUs2LL79htVqP6H8rIiJNgzU0hs6nXcXuzSt5suw8vvrUPVsrIsiPu0Z3ZVxKUo2R0Z7jyvIIK9gI+/fBfru7Tc1ui2dmjUhjoIKcnJArr7wSp9PJgw8+iN1up3///syZM0c/dKXBLdqexwOzN3qmp6Z0iOSRC3vTLS7My5GJiMjJtnlfIX/9eAWr9rpz/sgu0cy8pA8JrYO9HJmIiNQXwzDYZ3fwNZfw/O6+lFQaWCwwLiWJu0d3o3WI/9EPDo52t6nJMiE4yj1CTn2jpZHRlFVpUBq6Lr/LYVNNHcWVPPrNBr5atReA6NAApp/bnYv6t8ViOfoICRHxHuV+qdVx2ggYhsE+RzafrS/ihR82UWlaCfN18cCF/bl8cKJyvkgjp9wvtTleG4GD26Oiorjt0ReYVxBNRWAkAP0TW/HIhb3pkxBR1xdzf88ERUJZntrWSKOjEXIi0rgd6BfnylrG266zeHp7AsUVLqwWGD+0PXeedZTpqSIi0nj9phfob3v6GIbBXY88zbd50ZQHxQBWzgzayox2K4jrMQRUjBMRabyOcsHlYC/QgwvtTJ8+vUZR7uD2hctWU9btHDItXSEQfKrLmHZOD248recxWxQc4fB2NZqmKo2QCnIi0riV5rBmy3b+ljmaNZVxgIv+ia149KLe9G5bx6tjIiLSuBxltWyAapfB0/9bzRcl3TCDfLC6ynm0xx6u9v8VS6KmG4mINGrHuOBy+GrZaWlpOJ3OGq2P7I5s/relGHvnqzAtgVhMk9Z5azkn0eDG0y45sWKcSBOggpyIeM9xpivtL6/i6R+zeXvreRhYCPd1ce+5fbk6tZ2+kEVEmijDMHAWu7C1HYR1z7IaPX022fdz98erWLOnEKw+hBXt5LzYIq66/q9Yyq7SdCMRkcbuKBdcDMPAMAxSUlJIT08nNTUVm83mOWzN7kL+9vlW9rU5BYBoawmv3TyK+IBkrZItzZYKciLiHce4emaaJt+ts/PQl+twFFUAFi7sFcn9F/THFhHk3bhFROR3qzFdKSWF6Xc8jzU0hmoTXvl5K8/O3UKlyyA80JeHzu/J8LaDiImJcZ+IabqRiEjjd3AxhYO/8YOja+T+5ORkXn31VWJjY7Fare4L8N9v5u3FOzFMCAv05eZhbZh8Rk/8fH28/W5E6pUKciLiHUe5emYvLOeB2WuZu969pHm7qGAeubA3p3S1HecJRUSksasxXSk9HWfZn9hfXsrdH69iZVYBAKN6xPDYxX2ICQ/0brAiInLirFb3hfbDZsE4HQ5P7l+6dCk333wzVquV79fZeXD2OuxF5QBc2L8N08/tQUyY8r+0DCrIiYh3/ObqmREYxbtLdvHEtxsprqjG12rh5lM7cesZnQn009UxEZEm5SgtCWw2G6mpqe5REimpzN5UzNPfL6ei2iAs0JeHzu/FpQO1araISFNUYwXVw0Y1H577U1NTMQLCuPmdZcxZZwegfVQwj17UhxFd1CNUWhaLaZqmt4OQlkPLn0sNB07YtuwPYNoX68jYlQ/AgKRWPH5JX7rFhXk5QBE5GZT7W5g6rKC6fEsWj8/b48n7p3S18cSlfYhXWwKRZkO5v2Wpywqqjuxs5m4v48nvNrP/wAX4yad05PYzu+gCvLRIGiEnIl5TacC/lhTw0k9bqXKZhPj7cM/Y7lw7pB0+WrRBRKRpOsYKqqZp8m5aJo/9byNlVS5C/H24/7yeXJWcqFFxIiJN2PFWUN2eU8p9n2/3XIjpl9iKxy/pQ494FWul5VJBTkS8YlVWAfd+upqN9v0AnNk9hkcu6k2bVhodISLSpNXS0BtgX2EZ93yymgVbcgAY2jGKf1zWl8TIYPdxx1l5W0REGq/fTks9uIJqlcvglV+289yPW6isNgjx9+GvY7px3dD2+FgtNae5KvdLC6Mpq9KgNHRdyqtc/HPuZl5dsB3DhKgQfx66oBfn943X6AiRZkq5vwU6rLhmWizMXrmXB2evpai8mgBfK/ed3Z3rh7bHenA09HGmuYpI06Pc3/L8tri2bm8h93yymnV7iwA4rZuNGRf3oe2BC/DHm+Yq0txphJyINJilO/O455PV7MgpAdwrKT10fi8iQ/y9HJmIiJxUViuExpBXUsn9X6zhf2vcjbv7JUTw9BX96RwTWnP/Y0xzFRGRpsFqtRIbG0tFtYsXf9jEyz9vo9owiQjy46Hze3LxgJqL9hxvmqtIc6eCnIjUu9LKav7x7UbeWrwLE4gJC2DGxX04q6e+cEVEmqufNmbz109WkVNcia/Vwu1nduGW0zrh61PL6IejTHMVEZEm4sDI6NV5ftz9yWo2ZxcDcHbvOB6+sBcxYYFHHHK0aa4iLYUKciJSr9J35HH3xyvJzCsD4MqEfP424XIiQgK8HJmIiNSH0spqZnyzgXfTMgEIKM9jbCsHt54+9uhTkaxW9zRV9ZATEWl6DIPK+U/zwvIq/pXTF5dpwae6lFND7Lw07uyj5n6r1cr06dPVQ05aLBXkRKRelFe5ePK7Tbzx6w5ME+L9Sng88htObV0G5mhAU5FERJqblVkF3PnhSk9rgqicVbD6S7bFRON0XnfsqUgHprmKiEjTsm57JnfNj2NjeSQA0UWbMFZ8QXZUOE7nFcfM/QenuYq0RCrIichJt3xnLnd/tJLteeUAXDEogftbzyXcUaapSCIizVC1y+DFeVt4Yd5WXCbEhQfy5GV9+PnD5aTZozUVSUSkGapyGbw0bwsv/LQVlxFJpE85f++TzYrNxaRFhSv3ixyHCnIictJUVLv45/ebeeWXbRhYiA2o4vGrhnB6jzgw+mgqkohIM7Qrt4Q7PljJiqwCADr65PHpX66gdUgAwzUVSUSkWdqavZ87PlzJ2j3uFVTb++Tz0a2nEhPblnNAuV+kDlSQE5GTYsO+Iu78cCUb7fsBC5eEruWhpDVEJA5z76CpSCIizYppmny6fA8PzV5LSaULH1cFweu/JNiSQ2XxaAiJ1VQkEZFmxjBM3lq8k8e/3UhFtYG1upzgDV8RYsnBtJ4FVitWUO4XqQMV5ETk9zmwkpIrMIpXf93JM99vptJlEBnsx2PdtjG2epmmp4qINDOGYeB0OvEPbcUDX6zj6zX7AEhpXcLtpf9iR5tcdiZerilKIiLNyMHcX+0fyj2fruHXrbkAtLUW4pz7T6rKi0gZN065X+QEqSAnIifOMGDBU2Rt38hd2WNJzw8BYFSPGGZe0hdbyCgovVTTU0VEmhHDMJgxYwbz1mSS3ekcSkx/fDG4s9Mebg6ch7XUJLldR/wum6wpSiIizcTB3P/dxlyyE0+nEl8sRhUDLTspWzWXCj+T1jFJTJ6s3C9yolSQE5ETZpY4+Xh1AQ/vPZ8S058QfysPnd+bywcnYLFY3DtpeqqISLOyz+7gyx0mzg4XgGmlnV8hz9lm0z/IgNiekA0BCYOV/0VEmpHtmXv4cm8IzsSBAASU2Ala9RHlYb706d2bdRYLqampmqIq8juoICciJyS/pJJpX2QxZ89wwD1N6emJ55AYHerlyEREpL5k5ZVy++fbccYMAqCrTw6fnppNmMOEhGQYMRXK8jQyWkSkGVm6PYc73s7AGdENq+mir5+d/tF2MsL9SE1NZdq0aeTm5mrxBpHfSQU5EamzX7fmMPWjlTiKKvC1WrjrtLZMPqM3Pr4+3g5NRETqyTer93HfZ6vZX15NWKAv085M4qrhZ2OFmqtna2SciEizUO0yeGHeVl6YtwXD9CfJN5+n4n9m8HWPQmhMjRVUNTJO5PdTQU5Ejqui2sXT32/mlV+2A9AxOoTnrhpAn4QIL0cmIiL1pbSymr9/tZ4PlmYBMDCpFc9dNYDEyOBDO6kIJyLSrGTllXLHhytZtisfgEvb5vNwxP8IbdffnfNVhBM5aVSQE5Fj2pq9n9vfX8n6fUUAjEtJ5P7TbAS3CvNyZCIiUl827Cvi1veWs81ZgsUCt5zaiXH9WhHfKtDboYmISD2ZvXIP93++lv0V1YQF+PLoRb0YEu9DcPAoTzFORE4e/YsSkVqZpskH6Zmc98JC1u8ronWwH69cO5DHouYQ/O1fYMFT7tVWRUSk2TBNk/fSMrnopV/Z5iwhJiyAd25MoXzpx/zppknMmDEDQ7lfRKRZKa2s5p5PVvGXD1ayv6Kawe1a883tw1n99SwmTrqJGc+9ijK/yMmngpwAMGPGDIYNG0ZwcDCtWrWqdZ/MzEzOPfdcgoODiYmJ4a9//SvV1dUNG6g0iKLyKm57fwX3fbaG8iqDEZ2j+e6OUxjd3gd2Z0Cxw/23NMfboYqIyElSXFHNXz5Yyd8+X0NFtcHp3Wx8+5eRdAk3SEtLw263k5aWhtPp9HaoIiJykmyy7+eCF3/lo4zdWCxw+5ld+GDyEAKqS5T7ReqZpqwKAJWVlVx++eUMHTqU119//YjtLpeLc889l7i4OBYtWsS+ffsYP348fn5+PPbYY16IWOrL8sx8bn9/Bbvzy9wLN4zuxp9O6YjVagHDHxIGu4txCYPdjbxFRKTJW7+3iCnvLWdHTgk+Vgv3jOnGTSPdud8ItpGamkpaWhqpqanYbDZvhysiIn+QaZp8sDSL//tyHRXVBjFhATx7VX+GdXL/vrfZlPtF6pvFNE3T20FI4/Hmm29yxx13UFBQUOPxb7/9lvPOO4+9e/d6mnj++9//5t5778XpdOLv71+n5y8qKiIiIoLCwkLCw8NPdvjyBxiGyX9+2c7T32+i2jBJaB3E81cPYGBS69/uWHNVPRGR41Dub7xM0+S99Ewe/mo9ldUGbSICeWHcAAa1i6yxn2EYNVbVExE5HuX+xmt/eRXTPlvD16v3AXBqVxtPX9GP6NCAGvsp94vUL42QkzpZvHgxffr0qbGizpgxY/jzn//MunXrGDBgQK3HVVRUUFFR4blfVFRU77HKicspruDOD1eyYIt7Cuq5feN57OI+RAT5Hbmz1apV9UTkmJT7m4aSimr+9vkaZq/cC8AZ3WN4+vJ+tA458iKbVavqichxKPc3Dev2FnLLu8vZlVuKr9XCXw8bEf1byv0i9UsFOakTu91+RDI+eN9utx/1uJkzZ/Lwww/Xa2zyx6Rtz+X2D1bgKKog0M/Kwxf04orBiVgsR34pi4jUhXJ/47c1ez83/3c5W7OL8bFauHdsNyaNqP2ETESkLpT7GzfTNPlwaRYPfrmOymqDtq2CeGFcLbNhRKTBaNxpM3bfffdhsViOedu4cWO9xjBt2jQKCws9t6ysrHp9Pak7wzB56aetXP3qEhxFFXSyhTB7ygiuTE5SMU5E/hDl/sbty1V7ueDFX9maXUxseAAfXteNySM6qBgnIn+Icn/jVVbp4u6PV3PfZ2uorDY4rZuNWVd1o39ChLdDE2nRNEKuGbvrrru44YYbjrlPx44d6/RccXFxpKen13jM4XB4th1NQEAAAQEBR90uXmAY5Dr3MfXr3cw/MEX1kgFteeSi3oQEKCWIyB+n3N/4GIbBXruD/6Tn8M6STACGdYzi+fa/Er38FcgeDCPvVm9QEfndlPsbwAn2cjYMg4xNWdw/ZyebHcVYLTD1rK7kLfyAqbe6F2uYPn26+sOJeInOvpsxm8120lbDGTp0KDNmzCA7O5uYGHf/sLlz5xIeHk7Pnj1PymtIAzAMMr58iVszYrFXhxBgqeaRXg4uv2wsFh8fb0cnIiL1wDAMpj3yD77MtVEW7L6I1s/PzltXDMTvm2eg2OFePbs0Rz1CRUQaK8OABU+583XC8S+iGIbBxIdfYn5pAoaPP75VpYwO282lPQZy0zNp2O120tLScDqd6hMn4iUqhQsAmZmZrFy5kszMTFwuFytXrmTlypUUFxcDMHr0aHr27Ml1113HqlWr+O6777j//vuZMmWKroQ1EaZp8vpPa7lqSXvs1SF0stqZHTeLKyw/YCnL9XZ4IiJST75dvo1P9nemLDgOs6KEkGVv41rxOXnluE/qQmPdf4OjvR2qiIgcTWmOuxh3+EWUo6h2Gdz/6XJ+quiI4eOPa99Gghc+T2bGjwCkpqYSFxdHamrqSRvAISInTiPkBIAHH3yQt956y3P/4KqpP/30E6eddho+Pj58/fXX/PnPf2bo0KGEhIRw/fXX8/e//91bIcsJKK6o5t5PVvPNmn2AlQsitjMz7idC/Px0EiYi0kyZpsnrC3cw89stuHyDCCxzErN5NmH+laSmDsEWEwsxd5/Q9CcREfGS4Gj37/bdGdB2EJiGe9Tcb3J3TnEFt723gsXb3Rfco5zLidg9n6DocFJTU4mNjWX69Ok4nU5sNpumq4p4kcU0TdPbQUjLUVRUREREBIWFhYSHh3s7nBZhi2M/f/rvMrY7S/C1Wnjg3B6M7xuMJTgKyvJ0EiYi9U65v+GVVlZzzyer+Xr1PsDdK/QvI2JpG2sjNzdXJ2EiUu+U++uBYUBxNix/C/YsO2Lq6sqsAv7832XsKywnxN+HJy7tQ3KcL1FRUcr9Io2QRsiJNGOzV+5h2mdrKK10ERceyEvXDGRQu8OWNlevIBGRZmdnTgl/emcZmxz78bVaePD8nlw3pJ1nBW31ChIRaaKsVvdtz7Ij+n++n57JQ7PXUeky6BgdwiuXdaBzUrynWKfcL9L4qCAn0gxVuQwe+98GZv26E4BhnaJ4/uoBRIeq35+ISHP208Zsbv9gBfvLq7GFBfDyNQMZ3D7S22GJiMjJcvjU1YTBVPpH8tBnq3k/PQuAMT1jearNz4T9+i/YpRW0RRozFeREmpmc4gqmvLuctB15ANxyWifuGt0NH6vFy5GJiEh9MU2Tf8/fzj++24hpwqCkVvzr4nbExrbydmgiInIyWa3uIltpDk5XGH9+PZ2MXflYLHDXWV25on0FoYvSoCRbK2iLNHIqyIk0I6sz8/nTO0vZt7+KEH8fnr6iP2N7x3k7LBERqUcl5VXc+X4G329yX4i5OjmRhyO/w3/ec0f0FxIRkabPAH7ZVsy0/61hX2E5YYG+PH9VfxZ+/AoTn1nC1GST0zrFYNHibSKNmgpyIs3EJxmZ/O2zVVQaVjqGVPDKTaPoHHeUBrqGoVX1RESagd15JVz41P/INYKxYPLwBb0Y3zcEZi89or+QYRhaVU9EpCk67Le7AUx4+F/8UpaIafWlY3QIr10/mBCjhKfT0rDbHTyzNJbe4/+PqKRuyvsijZgKciJNXJXL4NGv1/PW4l2AlVHBW3mmXTrhoSOAWgpyhgELnvL0ndDICRGRpiljZx43vb2UfCMYS2UJ7XfPZUyn5CP6CxEcjWEYzJgxg7S0NFJTU5k+fbpOzkREmoLDfru72g7mIefpzK/oAFYIK9rJq7dcREdbKIYrkDNSevNTuklK6hBaJ3ZjxmMzlfdFGjEV5ESasLySSv7832WefnF3ds7mtsBfsSYeY3h6aY77JO03IydERKTp+GhpFtO/WEOVyyTSWkr0js8ZObAnNputRn+hgyOhnQ4HaWlp2O120tLScDqdWnFPRKQpOPDbfX9RPrfvjOCn/dkARDuXc3476JAQD4aBdeEz3NlxGzcNGkTI2Gk4c3KV90UaORXkRJqoDfuKuOntDHbnlxEa4MuzV/ZnVHcblJ577KmotYycEBGRpsFlmDz+7QZeXbADgHP7xPPEpb0pKTyl5pQkq7XGxRabzUZqaqpnpITNZvNG+CIiUlcHp6kGRZIVOZSJm21srmhNgK+Vf1zahyFtBh/K+8XuBRwsJdmEWSxQlqe8L9IEWEzTNL0dhLQcRUVFREREUFhYSHj4UfqbyXF9t3Yfd364ktIqg3ZRwbw2fjBdYsPq/gTqISciDUi5/+QoKqvklrfTWbijEIC/nNmFO0Z1wWKp2yra6iEnIg1Juf8POGyaanrwSCav7kJBmYuYsABeHT+Yfomtjrr/4S1plPdFGjeNkBNpQkzT5MUft/D0D1sAGB5VzEt/PpNWoYEn9kS/GTkhIiKN0GEXT7Lyy7jgqW/JN4PwweCZKwdw4YCEE3o6q9Wq6UoiIo2cYRjk7tpAdNZSPrNHc19OElW4iLKW8vktp9G2dciRB9XSqsD9sPK+SGOmgpxIE1FW6eLuj1fxzZp9ANwQvoz749fhy+nACRbkRESkcTtstMOykJFMWt2VfDMIS8V+2u3+niFtUrwdoYiInGSHFuBZQrv+qXxTPQgA/+z1xDp/xbfyFKCWghzogrtIE6SCnEgT4CgqZ9JbGazZU4ifj4W/99jD1Za16gEnItJcHWji/aW9NXfntKPSrHYv3rDzc0YO7K1eQCIizZDT6WRxegZbbaeytroXAP1891GdPZ8h6gMn0uyoICfSyK3dU8iktzKwF5UTGeLPv68dREq7VlB6oXrAiYg0U2ZQFP+qGMuTTvdUo7N6xPDMFf0oLTpFvYBERJopa1A4OX3GUWmEYsXgicv6cenAs3E6z1fuF2mGVJATacTmrndw+/srKKty0ckWwqwbUkiKCnZv1JB0EZFmqcplcP/n6/hws7sYN2lEe6ad0xMfq4WwIPUCEhFpjrY7i7lh1lKyjVDCAnz4z3UpDOvsHhGnPnAizZMKciKNkGmavLpgOzO/3Yhpwsgu0bw4biARQX7eDk1EROpRUXkVU95dzoItOVgt8H8X9GL80PbeDktEROpR+o48Jr+TQUFpFQmtg3hzQjKdY8K8HZaI1DMV5EQamSqXwQNfrOWDpVkAXJOaxP9d0As/Hw1RFxFpzvYUlHHjrKVscuwn2N+HF64ewJk9NCpCRKQ5+3LVXu7+aBWVLoN+ia14bfxgbGEB3g5LRBqACnIijUhReRW3/Hc5C7e6R0Y8cF5PbhjWHovF4u3QRESkvhgGa7fvYsKH23DuryAmLIA3bkimd9sIb0cmIiL1xOVy8c9v1/Diwj0AjOkVy7NXDiDI38fLkYlIQ1FBTqSR2FtQxo1vLmWj3T0y4sVxAziju0ZGiIg0a4bBL5+9zJ+Xt6XE8KN7XBhv3JBMm1ZB3o5MRETqSXW1iwv+723WV7t7Qk8Y3p77z3X3ChWRlkNz4EQagXV7C7n4X7+y0b4fW1gAH92UyhkJFjAMb4cmIiL16LMlG7kxI4kSw4+hIft4eWxr4sI1VUlEpLkqr3Lxp7fSPMW46Kz5TB4cqWKcSAukgpyIl/28KZsr/r0YR1EFXWND+eLPQ+m9/VWYfSsseEpFORGRZsg0TV7+eRtTv9xBNVYuiNjOBNcX3H73fcyYMQNDuV9EpNkpLKvi+jfS+XFLPlYMfJe+w/6M2bzyyivK+yItkApyIl70QXomE9/KoKTSxbBOUXx88zDa+pfA7gwodrj/luZ4O0wRETmJXIbJ/325jifmbARg8sgOTL/ydF7MMKjI20N62hKcTqeXoxQRkZPJXljOlf9ZTNqOPEIDfHn24q60t+QQEBBAenq68r5IC6QeciJeYJom//xhC8//uAWAS/pE8fhlA/GvyoegSEgY7C7GJQyG4GgvRysiIidLeUUVd76/lG835mMB/nZONy7oFkZUZGvuTIaQ/AJKWrfBFh3l7VBFROQkMAyDpZsyueOLbewrLCcq2I9ZEwYTZS3DMAwcDgc2m42oKOV9kZZGBTmR+mQY7hFuwdFgdQ9IrXYZ3P/FWj5YmgXA7Z2yudN4E8sHFeATAInJMGIqlOXVOE5ERJoGwzBwOp3YbDb3VIQD3wP7y6u46cXZLMkLwRcX8Zk/8MHDz/BFYCBnpvbhjk7BVBe2xS8iBEtZHoTGePutiIhIHR2e+wGcTidRUVFMffQ5viluh8s3iAhLGZHL3+HO+U9gsVjYvXs3cXFxBAYGkpubS2ysFnQTaUlUkBOpL4bh7gF3cKTbyLspqza57f3l/LAhG6sFHhnbjmt2vwVFe2G/HUJjYbfFXYzTiZiISJNjGAYzZswgLS2N1JQUpp8SgHXPMnJsqVy/bgDr8kIIsVRwd8XLvLPNztqd2cTFxfGTBW4aNIgwi1Wjo0VEmpjDc39ycjIWi4X09HSiew3nF6M7hq8/ASV2orZ8gdOexb59+4iNjcVisRATE8OQIUM8hTwRaTlUkBOpL6U5NXrB5efYmfjJDpZnFhDga+X5qwcwpkcMLBgMWSYER7lHyOlETESkyXI6naSlpWG329m0fCFVCUFklxqM3xTPjsoyov2reTPxO5x7/QiOTqR3aAyBgYGkpA4hZOw0jY4WEWmCDs/9CxcuBMDuG8s6sxemjw8hxbu5xObEN3ow6ekGUVFR7tyfnMzN112KrX0PrMr7Ii2OCnICwM6dO3nkkUeYN28edrudNm3acO211zJ9+nT8/f09+61evZopU6awdOlSbDYbt912G/fcc48XI2/EgqM9veB2Rw3l+nc2s81ZQnigL6/fkExy+0j3fiPvdhfvgiJ1IiYi0sTZbDZSU1LYtHwh3QYMZ7stghvS2uKoDqZtqyD+e2MyHYKHYgRF0jMnl6ioKHJzc93TW61WjY4WEWmCbDYbycnJLFy4kGHDhrHNjGFLRRJYrIzpGcP9Zw6kbbx7OurBqay5OU5sG9/GuuQR2O2eTaNzAJGWRQU5AWDjxo0YhsF//vMfOnfuzNq1a7npppsoKSnhqaeeAqCoqIjRo0czatQo/v3vf7NmzRpuvPFGWrVqxeTJk738DhohqxVG3s2mnZmM/2ArjqIS4iMCeevGFLrGhtXc7+AJmE7ERESaNCsw/ZQAqhKCWNO6NVct70ZhdTVdY0J5e2IqcRGBQBhW8PQKUs8gEZGmz2KxALDeaMPSqgSwwBWDE3js4j74+hwqtHlyf6gP7FnmmU1DaY7OBURaGBXkBICxY8cyduxYz/2OHTuyadMmXn75ZU9B7t1336WyspI33ngDf39/evXqxcqVK3nmmWdUkDuK5Zn5THh7I4XlLrrGhvLWjSnERwR5OywREaknRnE2VdsXkVYUwZ+2JFFmVjMwqRVv3JBMq2D/4z+BiIg0OQ6Hg18WLGBP5AC2VCUA8KdTOnLf2d09hbojHDabRi1rRFomFeTkqAoLC4mMjPTcX7x4MaecckqNKaxjxozhiSeeID8/n9atWx/xHBUVFVRUVHjuFxUV1W/QjciCTdlMfjuNMpeVAa1KmXXTmbQKDfR2WCIi9a6l5n7DMJjx7CuU2gP5JPxSqvDllC7R/Pu6QQT76yeXiDRvLTn3/+c/r7AjYgCuDqcC8NcxXZlyepdjH3hgNs3Blbg1XVWk5dG/eqnV1q1beeGFF/jTn/7kecxutx8xrebgfbvdXuvzzJw5k4iICM8tMTGx/oJuRL5ZvY8b38qgzGVlZNAO3m37Oa1oGT9KRERaau53Op18tymf90OvoQpfTu/citeuT1YxTkRahJaa++2ObGbvDcbV2V2Mu+u0RHcxzjCgONv992gOtq5RMU6kRdK//Gbuvvvuw2KxHPO2cePGGsfs2bOHsWPHcvnll3PTTTf9odefNm0ahYWFnltWVtYfer6m4P30TG59fzlVhsm5cYW83nEhwUn9NQxdRFqMlpj7AeZuL2N34plg9aGLby7/uT4Vf1/91BKRlqEl5v5ql8ET8/eRH9kTTIOR/juZMrq3uwi34CmYfav777GKciLSYumSbTN31113ccMNNxxzn44dO3r+e+/evZx++ukMGzaMV155pcZ+cXFxOByOGo8dvB8XF1frcwcEBBAQEPA7Im+CDIOXf1jDE/N2A3B1ShKPXtATn/JRGoYuIi1KS8r9hmHgdDr5YuN+Zn67CbBwWT8bj18+Fl9fH2+HJyLSYFpa7t+zz8EjP+7h+/UOfK0W/m9sZ8aNONe9YnZxtrs3nBZsEJFjUEGumbPZbNhstjrtu2fPHk4//XQGDRrErFmz3F8mhxk6dCjTp0+nqqoKPz8/AObOnUu3bt1q7R/XkpguF0++/g7/2u7+rG85tSN/HXugiau+fEVEmiXDMHj00Rl8tdPAGTMYgD+f1ol7xnQ7ehNvERFp/AzjqL3dDMPg4Ucf41NHFMVhSfj7WPjXNYMY1fOw1j5asEFE6kBDdgRwF+NOO+00kpKSeOqpp3A6ndjt9hq94caNG4e/vz8TJ05k3bp1fPjhhzz33HNMnTrVi5F7n2maPPzFck8x7r64DO4ZGaWTMRGRZi47O5svd1kOFeOGt+XescdYUU9ERBq/40w3zdpr55NsG8VhSViMKp6+sEvNYhwcWrDhwhfdfzVTRkRqoRFyArhHum3dupWtW7eSkJBQY5tpmgBERETw/fffM2XKFAYNGkR0dDQPPvggkydP9kbIjYLLMJn++Ro+WJoNwCNtlnBdvzBdBRMRaeZM0+SVpbnk2AYAkOqfxV/PPdvLUYmIyB9WmnPU6aal5ZXc99VWSkITsLqqGBuyg3MHX1D78xxcsEFE5Cgs5sFqi0gDKCoqIiIigsLCQsLDw70dzh9S5TK4++NVzF65F6sF/nFpHy7rHqh+cSIiv9Gccj+AYZj831freHvxLgDuOSOJm0f1OqLVg4hIS9Zkc//BEXIHp5seGOFWUlbJhOe/ID0/hFAfF89c2oNR/Tsp94vI76YRciK/Q0W1i9vfX8F369xNXJ+9qj/n9W3j7bBERKSeGYbJ9C/W8n56JhYLPH5JH65MTvJ2WCIicrIcnG56WA+54opqJryxmKX5IYRZKniz3Y8M6jpEF+FF5A9RQU7kBJVXufjTO8uYv9mJv6+Vl68ZyJk9Yo9/oIiINGkuw+TeT1fzybLdWC3w5GX9uHRQwvEPFBGRpuWw6ab7y6u4YdZSlmUVE+br4p12P9C/a3u1qBGRP0wFOZETUFbp4qa3M1i4NYcgPx9eHT+YEV30ZSwi0iwcY1U9l2Fy98er+HzFHqwW+OeV/bmwf1svBSoiIieLYRg4nU5sNtsR00/3l1cx/o10VmQWEB7oy3+v7k7f+BR3sU6j40TkD1IWEamj0spqJr61lIVbcwj29+GtG1NUjBMRaS6Osare4cU4H6uFF64eqGKciEgzYBgGM2bMYOLEicyYMQPjsNxfXFHNDQeKcRFBvrw3cBN9M6bBire9GLGINCcqyInUQUlFNRNmLWXRtlxC/H14+8YUUjpEejssERE5WWpbVQ93Me6vnxwqxr149QDO7Rvv5WBFRORkcDqdpKWlYbfbSUtLw+l0Au4L8TfOSmdZZgHh1gre7b2C3kULjviOEBH5I1SQEzmO4opqbpiVTtqOPMICfHl7YiqD26sYJyLSrARHu1fTC411/w2OxjjQM+6z5e5i3PNXDeDsPirGiYg0FzabjdTUVOLi4khNTcVms1FW6WLimxmk78wnzFrJO3Ef0rtsGcT2rPEdISLyR6mHnMgx7C+v4vo30lmeWUBYoC/vTEylf2KrY/YZEhGRJug3q+oZWJj22Ro+WbYbH6uF567qz9m9Y3E4HLX2GRIRkabHarUyffp0Tw+5SpfJ5HcyWLw9l9AAH94ckEX3vHKMhGFYR94FZXn6/S8iJ40yichRHGziujyzgIggP96bNORQMe4ofYZERKQJMgwoznb/d2gMBhamf7GGDzOyPAs4nNM77qh9hkREpOkxDAOHwwFAbGwsVYbJn95ZxoIt7n7Rb9yQzP9WFzDxyzJm/FKBsr6InGwaIScCR4x4c09TXcqKzAJaBfvx34mp9G4b4d63tj5DB5ZFFxGRpsMwDJzZDmwb38a6ZxkkDMYccRcPfLme99MPFeMu6NcGh8NBWloaDvs+Ni1bgDPbQWycpq+KiDQ1Bwtxr776Kunp6aSmpvLXe6dx6/srmL/ZSaCflTduSKZdcDVp6enY7XkUVC3B+em9xFRmYklMdo+o1ig5EfmDVJATMQz45UnYtQjaDaN0yJ3c+OYylu3Kdy9vPiGZ3hEV7v2s1kN9hnZnqIeEiEgTZRgGjzzyCOvS5jEzJY+O8ZGQlcEjs1fwbroDiwUeHNOB8w8s4GCz2UhNSaF91sektnVi2/g2xPxVJ2QiIk3Iwdz/ww8/sHfvXlq1asWStHRu/W86P2zOJ8DXytMXdCalfWswDc5I6c28NINAVzG7fv0UV2t/4gGLLsiLyEmggpxISTas/ghKsinLd3DjhiGk7yomLMCXd25Mpvf2Vw8V3w5eDTusz5BOxkREmh6Hw8H7773LtUkOLEVWqiOsPGe5gTfWuqcvjfDbySdPvUzWglSmT5/u7jN0x2SqPlmGf1UBlj3LNEJaRKSJcTgcvPvuu+zcuRMAEwuRY2/nh835+PlYOM1nMy8//BLLU1KYfkoAd3bcxjXdezDprfVkOCxgqSSsdQ/CdEFeRE4CVRJETPefctOPSXnjWLKrmNAAX96amEK/yOojp6eCuwgXGqNinIhIExYZaDA4HkqqLLxUdT4vbncX1/56RhL5y7/FbreTlpaG0+kEwBoaQ0Cn4Vi0yp6ISJPlcrkwTROLxULw8OvY4orGaoG/n92Rvcu+pzJvN5uXL6Bq+yIsJdnEVGZyemo/vi3uycLIqwgZ+6DOAUTkpNAIOZHQGMp7XcnkReH8WplIsL8Pb05IZmBSa/c0VU1PFRFpdmJjYxl7yXXs2/khKyJO4z95QwH42zndmTSiA3lpqaSlpZGamorNZnMfpBHSIiJNWmxsLNdddx3vvPMO9D2f4jaDAXjysn5c3D+OuGSTkPwCSlrF49dxKOxZjiVhMHdcPZVrcnK1yraInFQW0zRNbwchLUdRUREREREUFhYSHh7u7XAAqKw2uPmdDOZtchLk5y7GpXaMOrTDbxZ8EBGRE9MYcz+4ewn954e1PDEvC4A7R3XlL6O6eLY5nU6dfImI/E6NOfc/+fUqXl60F4BHLuzFdUPbQ3E25hdTqCrci19EGywXvgAWq84BRKTeaISctGjVLoM7P1jBvE1OAnytvH7D4JrFODg0PVVERJoNwzB4a/4GTzHu5lM7cfuZnT3brVYrsbGx3gpPRETqgWEY/GvuOk8x7r6zu7uLcQDB0VgSk/G3HJgZE6L2NCJSv1SQkxbLMEzu/XQ136y142dx8Ur/nQzrMMbbYYmISD0zDIObHn6RH8s7gMXK9UPbce/YblgsFm+HJiIi9cQwDG58+F/8XNEBgFtP78TNp3Y6tIPaEohIA1OWkRbJNE0e+nIdny7fgw8GL9i+5NSK+YcWbRARkWbrf8u2Ma+sPVistMrfwM2p0SrGiYg0c7PTt/JzeRIAkbmrubZfqyN30sJtItKANEJOWhzTNHl8zkbeWbILiwWe6rOXsWaRFm0QEWkBVmTmc89X2zCtPoQXbufitmXExqgtgYhIc7ZsVz7TvtkGFh8iCjZzUWI1Mcr9IuJlKshJi/PivK38Z/52AGZc1IeLk8+G0os1NF1EpJnb7NjPhDeXUlrpYlinKJ44ZyBt42O1aIOISDO2yb6fG99cSnmVwaldo5kxdiBt4pT7RcT7VJCTFuWNhTt4eu5mAO4/twfjUt3D1rVog4hI85aVV8p1r6dRUFpF/8RWvDp+MCEB+hkkItKcZeWVMv6NNArLqhiY1IqXrx1EsL9yv4g0DrosIC3Gp8t28/ev1wNw56iuTBrZ0csRiYhIQ8jeX861r6fhKKqgW2wYb05IVjFORKSZyymu4LoDub9rbChv3JCsYpyINCoqyEmL8MN6B/d8uhqAiSM6cPuZnb0ckYiI1CvDgOJsikoruP6NpezKLSUxMoi3J6bQKtjf29GJiEg9MAwDh8NBUVklN8xKZ2duKW1bBfH2janK/SLS6OgSgTR7adtzmfLeclyGyaUDE5h+Tg+tpici0pwZBix4ivLM5Uzedwkb8kKIDg3gvxNTiQ0P9HZ0IiJSDwzDYMaMGSxJW0pBv6vY44ogMsSfdyamEBeh3C8ijY8KctKsrdtbyKS3MqioNhjVI5YnLu2D1apinIhIs1aagytrGVN3pLCkNIRQfytvTkimXVSItyMTEZF64nQ6WZKWxtbIIVS4Igj0tfLGDcl0tIV6OzQRkVqpICfN1o6cEq5/I539FdWkdIjkxXED8PXRLG0RkebODIri4aJz+V9pFP4Wg1euS6F32whvhyUiIvXIZrPhN+AiKqrisWDy4rgB9E9s5e2wRESOStUJ8bjgggtISkoiMDCQ+Ph4rrvuOvbu3Vtjn9WrVzNy5EgCAwNJTEzkH//4h5eiPTZHUTnXvZ5GTnElPePDee36wQT6+Xg7LBERaQAvzd/O25lRWIBnrhzIsC42b4ckIiL17P2lWaysigfgsYv7MKpnnJcjEhE5NhXkxOP000/no48+YtOmTXz66ads27aNyy67zLO9qKiI0aNH065dO5YtW8aTTz7J//3f//HKK694MeojFZZVcf0b6ezOL6N9VDBv3ZhCeKCft8MSEZEG8OHSTJ76fjMAD53fk/P6t/VyRCIiUt/mrnfwwBdrAfjLmV24OrWdlyMSETk+TVkVjzvvvNPz3+3ateO+++7joosuoqqqCj8/P959910qKyt544038Pf3p1evXqxcuZJnnnmGyZMnezHyQyqqXfzpnQw22vdjCwvgnYmp2MIC3A2+S3MgOBqsqkOLiDRHP6x3MO2zNQDcclonxg9th8PhwGazYVXuFxFplpZn5nPb+8sxTLhycCK3n9FJuV9EmgRlKKlVXl4e7777LsOGDcPPzz26bPHixZxyyin4+x9aMnzMmDFs2rSJ/Pz8Wp+noqKCoqKiGrf6YhgmUz9axZLteYQG+PLmhGQSI4M9q+0x+1b3X8OotxhERKRhc/9Bq7IKuPXACdllgxK466wuzJgxg4kTJzJjxgwM5X4RkXrljdyfmVvKpLcyKK8yOL2bjUcu7Mljjz2m3C8iTYIKclLDvffeS0hICFFRUWRmZjJ79mzPNrvdTmxsbI39D9632+21Pt/MmTOJiIjw3BITE+slbtM0efSbDXyzeh9+Phb+c90gerU50MC7NAd2Z0Cxw/23NKdeYhAREbeGyv0HZeWVMvGtpZRXGZza1cbMS/qQk5NDWloadrudtLQ0nE5nvcYgItLSNXTuLyyt4oY308krqaR323BeHDeQ/Lxc5X4RaTJUkGvm7rvvPiwWyzFvGzdu9Oz/17/+lRUrVvD999/j4+PD+PHjMU3zd7/+tGnTKCws9NyysrJOxts6wmsLdvDGrzsAeOryfgzvHH1oY3A0JAyG0Fj33+DoozyLiIicDA2V+wEKSiu5fla6ZxGfl64ZiJ+PFZvNRmpqKnFxcaSmpmKzaWEHEZH61JC5v7La4E//zWC7s4Q2EYG8fn0yIQG+yv0i0qRYzD9SbZFGz+l0kpube8x9OnbsWGMa6kG7d+8mMTGRRYsWMXToUMaPH09RURFffPGFZ5+ffvqJM844g7y8PFq3bn3ceIqKioiIiKCwsJDw8PATfj+1mb1yD3/5YCUA08/pwU2ndDxyJ/WQExHxmvrI/eDuG3rd6+mk78ijTUQgn08ZTmx4oGe7YRg4nU71ERIR8YL6yv2maXL3x6v5dPluQgN8+fjmofSIDfX81jdAuV9EmgQt6tDM2Wy2331l6GDPhYqKCgCGDh3K9OnTPYs8AMydO5du3brVqRhXH37dmsPdH68CYOKIDrUX48BdhAuNacDIRESkPhmG+4QsfUceYQG+zJqQUqMYB2C1Wo9otSAiIk3bi/O28uny3fhYLbx0zUB3MW7BU+7WNAmDsY68W7lfRJoEXTIQANLS0njxxRdZuXIlu3btYt68eVx99dV06tSJoUOHAjBu3Dj8/f2ZOHEi69at48MPP+S5555j6tSpXol5s2M/N7+zjCqXyXl945l+Tg+vxCEiIg3vye838dWqvfhaLfz7ukF0iwvzdkgiIlLPZq/cw9NzNwPw9zFJnNo5Sv2iRaTJUkFOAAgODuazzz7jzDPPpFu3bkycOJG+ffsyf/58AgICAIiIiOD7779nx44dDBo0iLvuuosHH3yQyZMnN3i82fvLmTBrKfsrqklpH8nTV/TDarU0eBwiItLw3kvL5OWftwHwxKV9a/YNFRGRZmnpzjz++vFqACZ3yOGa3X93j4wLilS/aBFpktRDThrUyeglUVpZzVWvLGH17kI6RIfw2Z+H0TrkyB54IiLSOJzMPkILtji5YdZSXIbJnaO68pdRXU5SlCIicjKdzNyflVfKhS/9Sl5JJWO7t+Zfvs9iLXG4i3AXvuguwqlftIg0McpW0qS4DJPb31/J6t2FRIb4M+uGZBXjRERaiK3Z+7nl3eW4DJNLBrTl9jM7ezskERGpL4YBxdnsL61g4ltLySuppE/bCP55VTLWxN+MiDvYL1rFOBFpQrSogzQpj36znh82OPD3tfLq+EG0jw7xdkgiItIA8koqufHNDPaXV5PcvjUzL+2DxaJWBSIizZJhwIKncGUt4y+Oi9nsDCMmLIBXxw8mKNAPRt6tEXEi0uSpICdNxpu/7mDWrzsB+OcV/RnULtK7AYmISIOoqHbxp3cyyMwrJSkymP9cN5gAXx9vhyUiIvXlwEINT2T1YF5hGAG+Fl4dP5i4iAOraR8cESci0oSpICdNwg/rHfz96/UA3Du2O+f2jfdyRCIi0hBM0+S+T9ewdGc+YYG+vHHDYCLVqkBEpHkLjuZjRvFKYVsAnry0L/0SW3k3JhGRk0zje6VJ+GbNPgwTrk5J5OZTO3o7HBERaSAv/bSVz1fswcdq4V/XDKRzTJi3QxIRkXqWkVnA39YnAHD76Z24YECClyMSETn5NEJOmoSnLu9HcvtILh+coJ5BIiItxNer9/LU95sBePiCXozsYvNyRCIiUt+y8kr50zvLqHKZnN07jjvO6ubtkERE6oUKctIk+FgtjEtN8nYYIiLSQEzT5JNluwG4cXgHrh3SzssRiYhIfTMMkz+/u4zckkp6tQnn6Sv6YbXqYryINE+asioiIiKNjsVi4ZXrBvN/5/dk+rk9vB2OiIg0AKvVwt/O7kGXmFBeHT+YYH+NHxGR5stimqbp7SCk5SgqKiIiIoLCwkLCw8O9HY6IiDQA5X4RkZbnj+R+l2Hio5FxItLMaYSciIiIiIiINBoqxolIS6CCnIiIiIiIiIiISANSQU5ERERERERERKQBqSAnIiIiIiIiIiLSgFSQExERERERERERaUAqyImIiIiIiIiIiDQgFeREREREREREREQakApyIiIiIiIiIiIiDUgFORERERERERERkQakgpyIiIiIiIiIiEgDUkFORERERERERESkAfl6OwBpWUzTBKCoqMjLkYiINLywsDAsFou3w2hwyv0i0pIp9yv3i0jLU5fcr4KcNKj9+/cDkJiY6OVIREQaXmFhIeHh4d4Oo8Ep94tIS6bcr9wvIi1PXXK/xTx46UKkARiGwd69e0/oSmFRURGJiYlkZWW1yB8zdaHP6Pj0GR2fPqPj+6OfUUsdJaHcXz/0GR2fPqPj02d0fMr9v49yf/3QZ3R8+oyOT5/RsZ2Mz0cj5KTRsVqtJCQk/K5jw8PDlSyOQ5/R8ekzOj59Rsenz+jEKPfXL31Gx6fP6Pj0GR2fPqMTo9xfv/QZHZ8+o+PTZ3Rs9f35aFEHERERERERERGRBqSCnIiIiIiIiIiISANSQU4avYCAAB566CECAgK8HUqjpc/o+PQZHZ8+o+PTZ9Rw9Fkfnz6j49NndHz6jI5Pn1HD0Wd9fPqMjk+f0fHpMzq2hvp8tKiDiIiIiIiIiIhIA9IIORERERERERERkQakgpyIiIiIiIiIiEgDUkFORERERERERESkAakgJyIiIiIiIiIi0oBUkBMREREREREREWlAKsiJiIiIiIiIiIg0IBXkREREREREREREGpAKciIiIiIiIiIiIg1IBTkREREREREREZEGpIKciIiIiIiIiIhIA1JBTkREREREREREpAGpICciIiIiIiIiItKAVJATERERERERERFpQCrIiYiIiIiIiIiINCAV5ERERERERERERBqQCnIiIiIiIiIiIiINSAU5ERERERERERGRBqSCnIiIiIiIiIiISANSQU5ERERERERERKQBqSAnIiIiIiIiIiLSgFSQExERERERERERaUAqyImIiIiIiIiIiDQgFeREREREREREREQakApyIiIiIiIiIiIiDUgFORERERERERERkQakgpyIiIiIiIiIiEgDUkFORERERERERESkAakgJyIiIiIiIiIi0oBUkBMREREREREREWlAKsiJiIiIiIiIiIg0IBXkREREREREREREGpAKciIiIiIiIiIiIg1IBTkREREREREREZEGpIKciIiIiIiIiIhIA1JBThqUaZoUFRVhmqa3QxERkQai3C8i0vIo94uIHJsKcuIxc+ZMkpOTCQsLIyYmhosuuohNmzbV2Ke8vJwpU6YQFRVFaGgol156KQ6Ho86vsX//fiIiIti/f//JDl9ERBop5X4RkZZHuV9E5NhUkBOP+fPnM2XKFJYsWcLcuXOpqqpi9OjRlJSUePa58847+eqrr/j444+ZP38+e/fu5ZJLLvFi1PVn586dWCwWVq5c6e1QRESkgSj3i4i0PMr9IuINKsiJx5w5c7jhhhvo1asX/fr148033yQzM5Nly5YBUFhYyOuvv84zzzzDGWecwaBBg5g1axaLFi1iyZIlDR6v3W7ntttuo2PHjgQEBJCYmMj555/Pjz/+2OCxHM2mTZs4/fTTiY2NJTAwkI4dO3L//fdTVVXl7dBERJqkppD7D7d161bCwsJo1aqVt0MREWmymkLuP1jU++3NG+dJItI0+Ho7AGm8CgsLAYiMjARg2bJlVFVVMWrUKM8+3bt3JykpicWLFzNkyJAjnqOiooKKigrP/aKiopMS286dOxk+fDitWrXiySefpE+fPlRVVfHdd98xZcoUNm7ceFJe54/y8/Nj/PjxDBw4kFatWrFq1SpuuukmDMPgscce83Z4IiL1oqXn/oOqqqq4+uqrGTlyJIsWLfJ2OCIi9Uq53+2HH36gV69envtRUVFejEZEGjONkJNaGYbBHXfcwfDhw+nduzfgvjLl7+9/xFX+2NhY7HZ7rc8zc+ZMIiIiPLfExMSTEt8tt9yCxWIhPT2dSy+9lK5du9KrVy+mTp3quQp14403ct5559U4rqqqipiYGF5//XXP+/zHP/5B586dCQgIICkpiRkzZhz1ddeuXcvZZ59NaGgosbGxXHfddeTk5Bx1/44dOzJhwgT69etHu3btuOCCC7jmmmtYsGDBSfgUREQap5ae+w+6//776d69O1dcccUfeNciIk2Dcr9bVFQUcXFxnpufn98fePci0pypICe1mjJlCmvXruWDDz74Q88zbdo0CgsLPbesrKw/HFteXh5z5sxhypQphISEHLH9YMFw0qRJzJkzh3379nm2ff3115SWlnLllVd64nv88cd54IEHWL9+Pe+99x6xsbG1vm5BQQFnnHEGAwYMICMjgzlz5uBwOE7oRGvr1q3MmTOHU0899QTesYhI06LcD/PmzePjjz/mpZde+p3vWESkaVHud7vggguIiYlhxIgRfPnll7/jXYtIi2GK/MaUKVPMhIQEc/v27TUe//HHH03AzM/Pr/F4UlKS+cwzz9TpuQsLC03ALCws/N3xpaWlmYD52WefHXffnj17mk888YTn/vnnn2/ecMMNpmmaZlFRkRkQEGC++uqrtR67Y8cOEzBXrFhhmqZpPvLII+bo0aNr7JOVlWUC5qZNm44Zx9ChQ82AgAATMCdPnmy6XK7jxi4i0ly0tNyfk5NjJiYmmvPnzzdN0zRnzZplRkREHDduEZHmpKXlfqfTaT799NPmkiVLzPT0dPPee+81LRaLOXv27Lq8VRFpgTRCTjxM0+TWW2/l888/Z968eXTo0KHG9kGDBuHn51ejeeqmTZvIzMxk6NChDRpnXU2aNIlZs2YB4HA4+Pbbb7nxxhsB2LBhAxUVFZx55pl1eq5Vq1bx008/ERoa6rl1794dgG3bth3z2A8//JDly5fz3nvv8c033/DUU0/V+T2IiEjTyv033XQT48aN45RTTqlzzCIicqSmlPujo6OZOnUqqampJCcn8/jjj3Pttdfy5JNP1vk9iEjLokUdxGPKlCm89957zJ49m7CwME9fuIiICIKCgoiIiGDixIlMnTqVyMhIwsPDue222xg6dGitCzrUly5dumCxWOrUwHX8+PHcd999LF68mEWLFtGhQwdGjhwJQFBQ0Am9bnFxMeeffz5PPPHEEdvi4+OPeezBHho9e/bE5XIxefJk7rrrLnx8fE4oBhGRlqop5f558+bx5Zdfei6+mKaJYRj4+vryyiuveE4QRaTxK6t08eNGB91iw+gSG+btcFqcppT7a5OamsrcuXNP6LVFpOXQCDnxePnllyksLOS0004jPj7ec/vwww89+/zzn//kvPPO49JLL+WUU04hLi6Ozz77rEHjjIyMZMyYMbz00kuUlJQcsb2goMDz31FRUVx00UXMmjWLN998kwkTJni2denShaCgoDovlz5w4EDWrVtH+/bt6dy5c41bbT0tjsYwDKqqqjAMo87HiMjJZRgGDodD/w6bkKaU+xcvXszKlSs9t7///e+EhYWxcuVKLr744hN74yJy0tQ195dXufhunZ3b3l/BoEfncut7K3g3LbOBopTDNaXcX5uVK1eeUAFPRE6uxv6bXyPkxKMuQ8IDAwN56aWXvN6k+qWXXmL48OGkpKTw97//nb59+1JdXc3cuXN5+eWX2bBhg2ffSZMmcd555+Fyubj++us9jwcGBnLvvfdyzz334O/vz/Dhw3E6naxbt46JEyce8ZpTpkzh1Vdf5eqrr+aee+4hMjKSrVu38sEHH/Daa6/VOtrt3Xffxc/Pjz59+hAQEEBGRgbTpk3jyiuv1IpLIg3IMAycTic2mw2AGTNmkJaWRmpqKtOnT8dq1fWppqCp5P4ePXrUuJ+RkYHVavWsWi4iDeNEcn+Vy2Dhlhy+Wr2Xuesc7K+o9mxLaB1EfERgg8cvbk0l97/11lv4+/szYMAAAD777DPeeOMNXnvttXr4VETkaA7m/qioKGbOnNmof/OrICdNUseOHVm+fDkzZszgrrvuYt++fdhsNgYNGsTLL79cY99Ro0YRHx9Pr169aNOmTY1tDzzwAL6+vjz44IPs3buX+Ph4br755lpfs02bNvz666/ce++9jB49moqKCtq1a8fYsWOP+g/b19eXJ554gs2bN2OaJu3atePWW2/lzjvvPDkfhIgcl2EYNU7CJk2aRFpaGna7nbS0NJxO51FXWZPGpankfhHxvrrk/mhbDOk78vhy1V6+XbuPgtIqz/HxEYGc2yee8/q1oV9CBBaLxYvvpmVrSrn/kUceYdeuXfj6+tK9e3c+/PBDLrvssj/+IYhInRye+3v16sXatWtxOBy/6ze/aZq4DBNfn/r7vWcxT6RTpsgfVFRUREREBIWFhYSHhzfIaxYXF9O2bVtmzZrFJZdc0iCvKSKNh8PhYOLEidjtduLi4nj11Vd57bXXSEtLIzk5mcmTJ2Oz2cjNzeX/2bvvqLjq9I/j77kz9M4wDCSQXoH0wJCYZizRtbv2ronZdfW3rmVXI3bFqOtG3dVdNbFETYzrWmLvMZ0B0iEhPaEEhqH3MnPv748JE0ggFULJ8zonB2EK3zlHPnfmuc99viaTqdU32tX1DtL2lbB2dzEjo4K5aKRcfnIiJPuFEKdbW9mfYrXSf9w0/IZPZdnucgor692PCfP34qIREVw8qhfj+oSgKFKEOxWS/UKI06159pvNZuLi4sjMzMRisTBnzhyKi4sxGo1tvu8vr2lk9e4iVuyws3yHnfvOG8I146M7bL3SISd6LFVVKSoq4h//+AfBwcFceumlnb0kIcTxUlWoKQLfMDjFLiSj0UhsbCyapmGxWDCbzSQlJWGz2Zg/fz6zZs2irq4Ob29vEhMTSUpKosGpsX5/KWt2F7N2TzGbcspwqK7zV+fHmKUg14VJ9gvRfTW/xPRUO1APz/4qnR++CVdTZpjA1+X1sLEQAMVZxyCvKh675UImDAzr0E4I0XEk+4Xovjoq+xMTE1sU4ebOnUtKSkqL9/0Pz3mEzPxKlm+3s2KnnQ3ZpajNWtZW7SySgpwQJyM7O5v+/fsTFRXFe++9h8Eg/7sL0S2oKqx8CXLTIWo8TH7wpItyqqoyd+5cMjIyiIuLY86cOe4DvaIopKamkpeXR35BAWGDx1K0u4FN/1nF5gNVNDhbNpBHhfgwcaCR6cPCT/klio4j2S9E93T4JaanMuunKfs3ZO3FJ+4C1gaO4u1XVrpv16mNGGxbqcpcjslpx7N3LwbdfT7FRe3zgVCcfpL9QnRPHZH9zd/3GwwGzGaz+7LVvLw88kurCY2ZSG6eP5888yMV9S03fBgU7s+UwSamDAnD0t/YHi+zTZJUosfq16/fcW1UIYToYmqKXMW4Kpvra00R+J9cEcxut2O1WrHZbOh0OoqLi92zI+oNfgSNvYjs6Ab8/HpTbfChGrDlVALgq2vg/FH9mDgwjAkDjUSH+rbXKxQdSLJfiO6pKa9Pdb5neW0j/12znSU2M9XDRoNOgfxKDIqOqUNMXDIqkvVfLWRd5hrqghx4e0eSkJDAW2+9RVpaWpcd/C2OTrJfiO6pvbK/+XMd/r7fqWpk1xgwjLmcugF6fHzDqQVqAepVPHEwPbY3U4eGM2WIid7BPu35Eo9KCnJCCCG6Ft8wV2dcU4ecb9hJP5XJZMJisWC1WhmbMIEtxRr/sWayYoedPUXVQB8Ict3Xz1PPuCh/dq76mtp9G+kdaGDOX96WDR+EEOI0aJ7XFovFvTPq8ah3OFmWZWfpxjx+ySqkwaGCf28AzEol/3dJIheNiCCECvAN49JRc9w78BUXF6OqKnfeeads9iOEEKfZqWT/0Z5rZMJZrM5tYNkv61m+o5CKOicQCQfPrw8M9aQ8aw2N+zcR5dPIU/ct6JTcl4KcEEKIruHg3DjVJxT70JsxjbkFxT/8pC9X1TSNPUXVmKfcgHfoVJYcqOL999e5b9crOsb1CWHS4DAmDQ5jZGQASm0RyQW+WEsMp/ymQAghxLE1zQ4yGo3MmjWLWbNmYTabj9mhpmka6/aX8tmGPL7ZnE957aEdUoeY/blsdC/OivJi5MAo0FSqv38arXQbuuh4lMkPuj94mUwmbDYb8fHx7g45yX4hhOhYJ5v9bdE0ja35lQROuBYtYDIf2apZ/Mlm9+2eODh/RDRnDwtn8pAwQn0MJCX9TIatnkRLIqYwI1QVtsv86hMhBTkhhBDHrT2Hrh72xLDyJbScNJbvrmZemo4Ei2uDhaP9lsPXU9vgZO2eIpZl2Vm2vZDc0toW94/yaeAsz12cPcCPsy6ZSYCvl+sGpwN+fQZsW3lk8ji2XfEcw4bHyCVLQghBx2V/0+ygw4dsJz0yB6pa39hnX1E1n67P5bN1OeSVH9oh1RzoxWWje3P56N4MjwxAp9O5f8fLzyZxVvFH9An1JhLQHRyF4HA4SEpKIiMjg4SEBJ577jliYiT7hRACOjj7n32WrHUrsVU58fL2cW/AcLTfd/h6ahocrN5VzK9ZNn7NKsRWUd/i/sFaJYWbfkOXn0lMVBCP3fc2ZpMJR0UBjya9QkZGJrGxsdxx+22w8h+Qt+6U51efKCnICSGEOC7tOXT1CAfnxjWWH8CvNI/6kuBjXjbUtJ6V6zMIGzENz/7jWLu7mHrHocGsngaFxAFGzh5qYnIvHc73rkApKUSrD8fvwiuBCFcx8NenYcMiNMXA7l07eX7jrwwdN9m9M5MM+RZCnKk6Mvub5v3k5eWRn59PREQEqdYUqr9/moCyLPcHo/I6J19vOcCn63JZn13mfrwHTi4d24crx0aROMCIXtEd8TtsNhvzF39Obd9yzupbi//4YQT6hqGqKklJSbz33nvo9Xp27tzJqlWrmDJlimS/EOKM16HZX2ijX84nTI2wsyangSW5UaSkQFJSEpmZma3+vqb1rFqXgXGk633/mt3FrhEFB/l66jlrUBjnDAtneIjG1RedR0l2NgaDgbgZf8IUZkRd8Xd2/vIhwVvy2LjRi507d7I3I5XkhHIGRQTSuHs1HmNuQQmMaJfXeixSkBNCCHFc2nPo6hEOzo3z0DSqQ4LwCtWRcNhlQ4da28PIzK/ki/Q9fFQUTd3QsexoALbbAegd7MP0YeGcPcxE4gAjvp6uQ52tIJ8fDzjoZ1DZV+YgqEbDHIirGGjbBooB1dHApgN6tucWU1C1nMrKSrZu3SpDvoUQZ6zm2Z9qTaF4/zZMfYe3S/dA07wfTdMwGo14e3tzdsII/Eu30VhVxIqtBXy6N4Wfd5a5d75WdOBbkQ37UumjlPK3+97EbD76rFENHS9Z4VtbEJ8+OZvAmiLsVU4yMjIwGAw0NDTgdDopKSlh+XLJfiGEaJ79KSkpbN26td06iE2+Oiy9Deiq9Ewd6M8WDzNRw+LIyMhw74Zqs9lQFIWwsDC2FVTxRdpuFhVFUzdsLDR73x8V4sM5w8KZPtyMpX8o3h56APLz89HpdHh6emIymfi///s/irO3E7BnNYbaEsabIcjQSL3TyV5bBav31+F0OEi3lbAv502S7vvDKY3OOV5SkBNCCHFc2nPo6hEUBSY/iK6miKk+ocQUtexMqGtwcG/ya6QdqKcubAg1mqfrcT4m0DTC9dXcet5YzouJYHC4v/tSpRbrDzezL/pqfli/iqFjJ2EKP1hM9A2D6HgAdOHD2Fanp2L5R5SUlpGdnU1gYKAM+RZCnLGasj/VmsL98Rphq5+E7Ph2uaRHURSSkpJabLBQ7PDk2a++ZGmuH0UOH6AUgFClhj9eMJbLRvXirX++hHW/HUvCsY9FZrOZG264gVWrVjHprLMw71wMeesw9R5HosUCQGxsLD4+PixZsoSyMsl+IYRoyv6mkQIPPfSQa6RAO5ykUPzDGTTtOhr3rGFA/wnMG34rxjATc+fOxWq1Mi7ewhP/WUJ6fgP1YUOoPon3/c2zf+LEibz77rukpVq5b7xKlL+J/DInl1x3Ad4+vixZsoTkFY2Y/Bpwegbxf/yPxv+tx2vgWR1++apOk/2hxWlUUVFBUFAQ5eXlBAYGdvZyhBAnqMNmyB18bpvNBrjeBGTnF7KlSOXrjTms2VtGdUOzlnQPhalDw5k+zMQIo8KQvr2Oaz1trv/ghhL4hpFvs3HLLbdQXFxMdXU1ffr0YcqUKdIlcQok+4Xo3lRVpXj/NsJWP4muuhD8zXDZa+Af3i7PvWN/Hj9uL+GHHRVkHqhw3xbiY0DJWYdz1xqi/OHtBfMx++tdm/8UHf8lpe7s99FQvvozVNnA34x6yT+x1+rcGztI9rcvyX4hujdVVdm6dSsPPfQQNpuNiIgI3n777XY5SaE6Hdj3bUP1CcUUbmb/ARsbCx18kbaHdQfqqGk89L7fx0PB0jeQC0dGMdKkZ+gJvu9vvpN2ZISZBa8+D35hmMLNR2T/yIGRJCeUMzgyEF07HuvaIh1yQgghTo6qunYj0gF+p9bSraoqzzzzDIs++RxnRAxeAy3UBvVDUw4dpnxoxLtkB/GRXrz6yJ/w8fI44d+jKErrbyIUxX2wNZvNTJkyBavVSnx8PLNnzz6lXZ+EEKInUH1C0aLGQ246lUFDqa5oxOyrnnQ2OlWN5dsLefqDH9nXGAj6g3mvOvEr24OxYgdnD4tA3wdSC8CSkIAp633IW4cSNR7zCXQtuLNfVV1z6XLTIWo8in845kDXc0j2CyHEkYxGo/sKmZiYGBwOB6p68tkPB9/3P5vMok+/whkZh+eAeGoDokHRu+/T9L5/XIQnvfSVrP/Cyo58C1efwEmSpuxXVdX9GhIsFkz9Y93PcUT23zkL844P0TVt8OB79JEIp0o65MRpJWfKhOi+Wgx3TUggaYonyuZPXDeOvAam/PWkinIl1Q18snYHr366gmr/3uj0h4pwaoUN76Iswhvy+ei1uXh6eJyWIdsd2Ql4JpLsF6L7ap798ePH40cNCz76Ag0dN9xwA4899tgJ5eT+4mr+m57Dp+vyKKioc//cYd+Hc9cqgst3UnwgG5PJRL9+/ViwYAGKohzR3XbSXQvNOqJRlBbfq3Bk9h9+f3HcJPuF6L6aZ/+4ceOoqalh6dKl6HQnl/1N9hdX80nKLhZ8l0adf2TL31mah1fRdqJ1JSx6/j4UfxOqhru77VQ69A5/b9/8ezgs+1UVtaoQe42GKbxjT8xIh5wQQojj0ny46/b1q2jspcerutB14/41rg8sx/nhqLS6gR8yC/hmSz5rdhfjVDUI6osO0JUfIKhqH6HV+9HKDpCXm4tdp+Pdd97h0UcfPS0FsjY76YQQ4gzTPPtXrV5NQ0MDBbZCNE1j1apVxzVjrbbByXcZ+XycloN1b4n75yG+HkTU51K0fCEVhQfoHRWNV6SJ+ooS7HY7ERERmEwmDAbDEd1tJ9210KwjGlWFlS8d6pib/GDL13LY7R09S0gIIbqK5tm/Zs0aGhoaKCw8sewH0DSNnYVVfLelgO8zC9iWf3AswcFinK54HyE1OQRX72ffZisVVZXc9LswzClPo0QnoE66v11mWDd/b9/aDrLNX4sKJL86v0N2mD2cFOSEEEIcl+abOgwdm4DHIE+oOViQ6zvR/eGore6y8tpGfsgs4OvN+azeVeQqwh0U2yuQC+MiiI8w0CdkLCaTCbvdjs1m48EHH6SsrIzU1NROGa4t3XJCiDNZ8+yPj3dtgFNQUADApEmT3B+OWsvKjLxylqRls3TDASrrHQDodDBlsIlr46M5Z2gYHmvm0TAwiIbwKfjOeIyt27K4//77sdvteHt7U1xc7Mr9g5v/tGu3Wk2Rq9hWZXN9bXZiyT03LyfNNTfvsNuFEKInO5Xs1zSNrfkVfLsln+8yCthjr3Y/r17RYekfipq9gYL070kYMZRnX3+WrCxX9jsrCogLqsJRno+nLh2ltsS9+U97vRdvXmw8fPOeprl5KSkp7h1fO/LzhxTkhBBCHBdFUZgzZw5ZWVkMGzbMdUAce1uLGXKHn3G6/68P8+t2O19uOsDy7XYanIcGtMZEBnLRyEguGhFJvzA/4NBBHWDBggWkpKSgaRpms7n9d3Y9Dq2dQZOinBDiTNJa9s+ePRvAPWOteVaOTpjI4HOv57/puS02aIgO9eGacdH8flwUvYJ9XD+sKoS8dXg1lqMr3AzVRXz++efk5OQAHJn7zbvb2oNvWKtdd02vp2ln2WkDw9GdhllCQgjRVZxo9ickWLj89nv4LtPGd1vy2Vdc434uT73CpMFhXBAXwbnDzTRWlTJz5rNU2QvYsKEGu93uzn4dGlUhw/EI8nfncntfudK82Nj8ONP0epp2lj0dnz+kICeEEOK4qKrq3o7cXZwKjGhxH7vdToo1lZxGf3Ly/Fmc/DO1zXZJGhzuz6WjenHRyEgGmPyPeP6mg3psbCwZGRnYbDbMZjMvvPACMTExp70YdrQzaEIIcSZoLfsjI1vO/SksLGTZ5n3khSaSWRWD9uVWwPUhbEZcBNfHR5M4wIii6Fo+uW8Yau9x7PptCda8EjK3v8KWjEz8/f0JDQ3lzjvv7Njcb6Pr7lD225iXZibulicx9R0ul6sKIc4Yx5v9v23azQH/OLaXDeSd19e4b/MyKJw9NJwLR0QwfVg4Ad6HNmNTfUwkJCSwaNEiKisrefXVV8nMPJT9w2cvQBfo0WGzOxVFabXrrin7T+fnDynICSFED9XmpZYnOaD6aMUpTdPYnFvO5+vt7I6bSR0HD7qNKlEhPlw6qheXju7FUHMAOp3umM+vaRpxcXHodDosFssJHQzb8xLTts6gCSFEV9VWBp5sNh4t+8trGvl8Qy6LU7PZM/BK92OGhPtzXUIfrhjTmxA/z7afXFGwD7uFp1/5he25xYSbM1tk/4mcADnp7G+l66559idYLBilGCeE6OI6MvtTrSkU79+Gqe9wNJ2OrIJKvtmcz1ebD7B/0NXux3h7KEwfFs6FcZFMHxaOn5fh0OcO9dDnDkVRuPPOO1m5ciUlJSVkZh6W/RGRx525J/v6Wuu6O/x9/+loBpCCnBBC9EBtXmp5kgOqVVVFVVXi4+NJS0tzF6dySmr4YkMen2/MazYfwoMQHwPnDAnh+gkDGR0dTGFhIWjVaJp/mwW5ww+Cc+bMobi4+IQOsO19iWlbZ9CEEKIraisDTyYbVaeD4uztGKMGt8jmsLAw1u0vZbE1m683H6De4eqC9vZQOGdwCJfFGTln1AB0Oh02m438ikOXN7XGFG5m6LjJlDkk+4UQ4mS0Z/Y7HA6ysrIYMmQIFovFfel+xa/zWKRN4qvy/uxuNhPOy6AwsV8g0weHcIVlEL6eBmw2GxUldnzCTSir5rX6ucNsNjNlypQz/n2/FOSEEKIHarOj4bAB1mpVIfZa3VEPOi3nQyTw6utvsN6ucsMCKyl7Du2W5+2hcH5MBJeNjmTVJ/NJ/TCFjzfE8qWPD0uWLAE46jbprR0Ej9UdcfhZsY64xFR2XBVCdBdtZeDhP7fZbCiK0mb2q04Hy5+9FL/SrWSExDDnkS/ILihidW4DF7+25tAuecCwiABusPTh0pGR/Gvei7z6cQo/x8bi00HZ31o3hGS/EOJMdlzZn7KW7etXMXTMRBR962UgR2MD111yLqs2ZBEbN4J3lnyO34hz+MfGnWTsbJqhWY2nXmHqUBMXj4zk7KEmXn3pBZZ8nsKW2Fh8fbz58YvFlNQpzLr+ch4YtLfVjXEk+12kICeEED1Qm5daNhtgrfYeyysvv8yytAwSLIltnlVyzYWzklPvTW6eHx8t2OKeC6fTwcSBRq4YE8WMWDMB3h7YbDbmWVPYuHEjqamp+Pr6UlZWBnDMbdJP5CDY2lkxucRUCHEmaysDD98t7+WXXyYzM5PExNazvzh7O36lW/Gnhn1l5Tz0UQrf76qhusEJuDoiLhnVixssfRgTHezuhktJ6djsb6sbQrJfCHEmO2b2p6zlyrC9lC+8id++jmXaY18dWZRTVYo/n8ONkbvxN07kV4/JTP3HyoM3hqFHZVJYNZdMm8j5cZEEHpwJ1zz701Kt/C1Rz+Oj6kjPh59Wr+MP8WcRoNO12DiniWS/FOSEEKJHarPlummAdVUh1SteZ1Lpx3j76/jOSqsflvJKq1mYkkf2iDuo1LxcP2xU6Wf05apxUVwxNorIQC/sdjt+nnrAdfCPi4sjPT0dDw8PPD09CQsLw2AwtNgm/VS1dVZMLjMSQpyp2sr+pp/bbDZefvllFi5ciMHg+hjQWvb7Rgzke5+LWO0Yynb9QNhaCcBAkx83WvpyxZheNFSVYTIFuccQnI7sbyv35RJTIcSZ7FjZn5X2GyXvXINnYyO1eenY923DPHCE+/F1jU5+3biTz3YO5Dfzv3FgoClFE/qFcsnICH430JOQMDP2omL8D77nh5bZHxHowVizgzBvA2d5KXj3HoffBY9DbckpbdDQk7NfCnJCCNFDNT/rdESbt6LgX5ZFVLAn0EBd6Aj3h6UGh8ov22wsScthxY5CNHSAF76eCpeO6s3V46MY2ycEnU7X5hmr5ORkADIyMkiIj2f2jVeAXxjmiMh2O1i2dVZMLjMSQpzJjpb9iqKQmZmJwWDA4XAQFxfXolCWV1bLh2v38e7y7dTxO9CDQdExIy6Cmyx9SRwQiqZpreb+4dk/fvx4rrjiCkwmE5GR7ZP9R+uGkOwXQpzJ2sx+IKrwV7z9nDgdsCLXg2E+oaiqhnVvCZ9vyOW7LQVU1juAvgAMIZsrzAVcds0sevWOdj/nsbI/M2MLWm+VvhEa/aLimfq7J12deIdtnHOienL26zRN0zp7EeLMUVFRQVBQEOXl5QQGBnb2coToUY62u1JycjIpKSnExcWRnJyMQVFg5UtoOWlUBQ/Db/Jd7K8P4KP0XD5dl0txdYP78YbSfZird7P4+QfpG9Wrxe+02WzMnDmTgoICIiIiePvtt1u+GSi0Ycp6HyVv3QltInGqr1l0LZL9QnScE8n+pg9OKSkpxMbGcu+99xIREcHaPaUsXLuPX7bZUA9+MlDqygkr3857j91JzIAo9/MeLfebfq/NZmP+/Pmkpqa2y6Dt43m9ouuR7Bei4xx39s+5F/3X95K/ayP5pbV8FnQHHqMv46cd5eSV1bofZw7wRN2zlquc3zI9uIDh067C/5Ln4eClrced/W+9xY4Nqxk6dhJJjz4q2X8M0iEn3FasWMHf//531q1bR35+Pp9//jmXX365+3ZN03jiiSeYP38+ZWVlnHXWWfznP/9h8ODBnbdoIQTQ+lkrcLV4q6rqnu2Qnp4OwNy5c1EmP0hjeQG/fb+Uj/75LWuqI93PFx7gxZVje1OU+hVZGSuwWCxER4ZDVWGLlvNjnrHy10PeOvcmEs2HubaH7n5WTAghTsXJZH/Tpauvv7mAq+b8k9re8ZRpPu7nnDDAiG9eGgUZP5JoSWBInwhsNpv7Q9CxZvY0dUykpqa266Dt5s8vuS+EOJOdSPbr0Hjo3AR+LRnKfz3i2FwZAKkFAPh7GbhoRCRXjO3N+D7BzJ2bwmprKGf188e3ci+V3z+N3wWPo+gNx5/9aWkUFJRQ5kiV7D8OUpATbtXV1YwaNYo77riDK6+88ojbX3zxRf75z3+ycOFC+vfvz2OPPcaMGTPYunUr3t7enbBiIUST1nbQW7BggXuAd79+/UhLS8PDw4OMjAw27szlhz3V/C8tm+KaPgDo0Jg2KJjrJwxi+rBwDHoFdcZQ7PZbMYUZW922/JizG5ptItHaMFchhBAnr63sb+qAi4mJIT09HYPBQEZGBna7nVq9P/9Zkcsn1bGovbxAA18PhavGR3PLhL4MCg9AVROw26/BaDQyd+7cIy5ROtbMnp4waFsIIbqq48r+devwiB7Jt+W9+Oy3ITQ4Xe3POk1lhCOTYXVbuPueF+kb1dv9vElJSRTv34Zx9RMU7NpM7rp1rFrXwF8efU6yv4NIQU64XXjhhVx44YWt3qZpGq+88gqPPvool112GQDvv/8+ZrOZL774guuuu+50LlUIcZjDD4CqqrJixQpKSkpYvHgx0dHRDBk6DF2vWMoGTub3726haV6B2auRa4MyuTbGl97n39viklL32aiqg9uVt9LpdtQzVk2bSNQUndIwVyGEEEdqLfuXL1/O1q1bSU9P55ZbbuHWW28lIzOTqHHncN/nO1i7vwJNA/ReeNaXMTagkjcfuo0grQJ8/YBDuW6z2docpH20ToWeMGhbCCG6qqNl/7rt+xlz5V2E3vo6tTpvKgCcGkPN/kwOb+DcHU9hrNmLZgqnt7+uRQe0oiiY+g6ncmsMuWXppBfoWLZrCzdK9ncYKciJ47J3714KCgo499xz3T8LCgrCYrGwdu3aNgty9fX11NfXu7+vqKjo8LUKcSZqfgA0Go0kJyezf/9+Ghoa8PAP4UBQHI19LTR6BoJ68EH5W6nP/BkMZfzxq/9S6fREBVo9dJ5Kp5uitOtlqqLrk+wX4vRoLfv37t1LeXk5QUFBZGzbwWX3Pku6qZAfiutgn+tv0ZmzidDiLXz272R8vb0ISHvVNV7gsFmfp9Lt0FMvLxJtk+wX4vQ4PPufevY5djtC4ex78Y6OY9vB+wV46entyKdq84/s+K+VjVWVGM8J4JZzxuA0j+a5V+eTmpbWctanouB3weOsWtfAsl1bSLAkSvZ3ICnIieNSUOC6zvzwPy6z2ey+rTVz587lqaee6tC1CXFGUdU2u82adzSkpqZS7RkKcWfDoEQaFVfcB3rrqd7yM/a1n1Nt2weATdMYMuYsRo4cyYQJE1ofvi2dbuIESPYL0b7aHGatqig1RZhNJmx2O6mpqdTU1KD4heAZ/3v2DJ/O879ku+7rqKd26zLKUr/AUXqAPE1j6pSVTBk7jCfHFjM4MhBdKx3Q0u0gjpdkvxCn6LD3+UfbuMFut1Pi9OYf/9vAp1WxaInj8ATQVHrrK3n4mqmMMMKMc+8lLy+P2lrXBg73fFzMm+l1hPWpISc3j4CAgCNmfSp6A3959DlulOzvcFKQEx1qzpw53H///e7vKyoqiI6O7sQVCdGNqSqsfOmIOW7NNTpVUg40UhB3Ix4jgtw/H2z0ZPbZQxlv1nPBufdClR0PDw8aGly7qRYWFrJv3z4URWl7AKt0uonjJNkvRPtpbXi3oijgdMCvT4NtG0THY5p0P73jLGzyGU3ogARQDNQDUSE+XBkXyht/u5WSnL3oGhrQNNfQgsLCQjbtCsBqNtC3TzBerXRAS7eDOF6S/UKcgsPe56uT7if5uSNneFbW1DPzqdfZUhtErW+E67EGb9SqItRdaxios7Hknf8QGRlJfn4+4Mrx5u/7t+4vYqDBdVtISEibmzRI9nc8KciJ4xIR4fpjt9lsREYe2onRZrMxevToNh/n5eWFl5dXRy9PiO7vKJ1vbjVFbc5xK66qZ7E1mw+t+7FV1IMuCEVTCSjbydRIjVceuA/l4Jm2G264gVWrVpGYmMgPP/zA3r17CQgIoF+/fjKAVbQLyX4hjk+bnW/N2AttbF+3EltB8aEuBpMJfn0GNixC1XmwrCKKBVvXsFY3DsMg1+MilEqeuH4K58dGokOjMv3KVrO/b7/+7ItOxOOq2a5jinRCiJMk2S/E8Wk1+w97n2/ft809D9pqtZK2PZvvdlaxaPUuGnVDwRfQnJw9OIybJvbn+4WvsFWfS2JioruQZjabW33fHxjgz5jBvRk6dhKz//AH93w4cfrptKZTZEI0o9Pp+Pzzz7n88ssB16YOvXr14sEHH+SBBx4AXGe9wsPDee+99457U4eKigqCgoIoLy8nMDCwo5YvRPfSdEYsJw3Mw2H646Bv5XxJKx1yu4qqeXvVPj5bn0u9wzUcLszfi5sS+3B9fDTUVbTZ5m4ymVBVlaysLIYMGUJpaam0pYsOIdkvxJGaOt9SUlKIi4sjOTkZg8Fw+J1QV/ydXb8twZrnYF/01SQ9+ihKTRF1n/0f/9vnxTt109ijuj586RUdF42I4MqYYKaM6CfZLzqVZL8QR2oz+5u9z1d7j+PZ5XV8+NES1F4jCUu8nAL10N9QmKOQgYW/EhnZh3lzn3GfdG/z8tZCGyZfHapPKFlZWQyzf4NzXwoeAyaiTPmrnIjpRNIhJ9yqqqrYtWuX+/u9e/eyceNGQkND6dOnD3/5y1949tlnGTx4MP379+exxx6jV69e7qKdEOIk1RS5inEFm+HAekAH5zxx5MHx4Bw3rcrGqr2VvP1eOr/tsLtv9q4txBJcw5t/+wPengfjPcjniF/XvAVdURTi4uKAI2dECiGE6Dh2u52UlBQ2btxIeno64JrB1aIwVlOEkreOwZGB9OkTRPnUKyitaWBRSikLtl5FBb4ABHgbuCGhD7dO7Eev4CNzHyT7hRCiKzhq9h+c15xlq+PrfW/juPBxVK9AClRQdDB9UBDjtjyLpcFKXYAf4x9KcR8z2rrEVAHM2z+A3HSUqPHEjbkFNm/A0Fjm2syn2RU34vSTgpxwS09P5+yzz3Z/3zQD4tZbb+W9997jb3/7G9XV1cyePZuysjImTZrE999/j7e3d2ctWYiewTfM1Rl3YL2rM862tdWDY4ND5auNecz/IZWsStffnU4HUwYEk/3Te1Ts2UBxRATlpVfhLR+whBCi62k2nsBkMhEXF0d6ejoGg4GMjIwjZ3g27XCdk8aXOxVeeP5ryo2xONADvhjqSjGVZrLo2f9jQHSvTntZQggh2ta8e62t7A8PD2d9TjkL1+TxXUY+jeYEAPQNVYSWbuOcft7ce+HN/Lw2j0q9F9nOEAY26DnmO/7DR96MvcV1XGm64uawuaHi9JKCnHCbNm0aR7uCWafT8fTTT/P000+fxlUJcQZQFNdlquhcxbjoeFSfUOw2GyaTieoGJ0tSc3h71V4KKuoAb3x1DVwTupvbr72G6Kgokgt+xVqTLzPghBCiqzps7IAy+UGSk5MByMjIIDExEaPRiO1g9iuKAopC5sDZvLojgR/rKsHo6oQYbPKhd8VW7Bk/kmiJp1/viM58ZUIIIdrQ2sY8zbM/3jKBVTl1LPjgZ7YVNbgfN65PMNOjDXz95hvYC/LJsEfA7FvZ1+dqfli/iqFjJ2EKP44T8E0ndpoKcH7h7k68o86uFqeFzJATp5XMkhDiKA52Tqg+oSQ/N5dV67bgNWIGe5QoquodABh9DdzRO5er1e8JGzzePffheAaDC9FZJPuFAKoKYek9ri4FfzNc9hr4h7vz22g0Mneua0e9hAQL593wR95YsZflzUYTBFbuZaKxgdefuBedTie5L7o0yX4hXJsgzpw5k4KCAiIiInj77bcxm82UVNWxYFkWn24pcm3IBnjSyCW9Krn9iouJ6R2EzWbjjTfeYNmyZUyfPp3HH38c4MSz/3g2jxOdQjrkhBCiq1AU8A9n/fb9fJbjTemQG6HRADgYaPIjsnwrxanf8XltNWv89QwbV0/SFNdsCNmaXAghurjDuxQOXibUlN82m40Uq5VsRxC7CiN5Z0EqADo0Ast2cm3j10z33UmNEouOP6Moesl9IYTo4kwmExaLxd0hV6Xz5fWlGXySnkttoxOAYK2cm5QfuUb3K+E+MXgGnUdycjJr164lKyuLiooKDAYDqqpiMBhOPPsPfsYQXY8U5IQQ4jRrq5tt64EK/rN8N99sPoAaGgOArngP50SqPHX91fxh9kscyMmhoKCAoshIyp2pR84bEkII0SWpgH3ozZjG3ILiH96iS8HhVFmd10DeiNuo1FybMuhRuWyEiYz/vUpj3hbGx+QRoBhQyrZRnL0dU//YTnolQgghTsSsWbM465Lr+SSjnHNfXkHTNYrDIgKYeVZfAr++i8EVKTSisSZPY3iVE6vVyr59+8jLy0Ov15OZmUlWVpZ7Qx7RM0hBTgghThNVVbHZbMyfP5/U1FT3HIkNOWW8vmw3v2YVuu87sV8g2d8voC43k4L8CBTdNVgsFjRNIywsDC8vL2JjYzEajZ34ioQQQhzLEdmfkEDSX2aj+IdTr2p8ui6PN5bvJrukBvBBcdYTX7mcmd6/khh0Oa+OGY61oZxcnARRS5nfQMZGDe7slyWEEOIoVFWloKCAp978mFXFPlT7R7tvO3uoiTsnD2DCQCM6nY68yDe5csZkSkpK0Qfu5Zc7wWKxoKoqdXV1VFVVMWTIEIYMGdKJr0h0BCnICSHEadA00HXFihVkZ2fjHxDALxk5bPrPKtJzKgHXdua/GxHJXdMGMjwigGT7b1gdxVgsFsxmM0lJSdjtdkJCQnjsscfIyMhg7ty5JCUlyfwgIYTogg7P/sAAf/rlfELFfzfyqeF3vHWgn3t2UKifJ7dP7EvVqoWc07iUqGBPAsqySPrLv7DX/oGQ4CBeePyvWDfuJvX5FyT7hRCii3I4nMx+5t+sLvGl3m8I+AOqk4DS7ZwbBf+49YEW+a3oDZQ5vLDX6jAH6lAUxf2+PygoiAcffJA9e/bwwguS/T2NFOSEEOI0sNvtWK1WiktKUE1DqB51CcUBvdmXU4lB0fH7sVH8cdpA+of5uR/TdCBufmlr05yhzMxMbDYbVqtVLlsVQoj21k4DsJuyv6SkBIDoiFD2m4dxzp7JFKt+QD0Rgd7cOWUA1ydE4+tpQJ32FNXf6/Ev3YYuOh6dfzjmQMWV+Zl7KbAVSvYLIUQHONVN0lRV49uMfF7+IYvd9QPAD3A04G/fTMPm7/DSO9iZH4HdfkuL/Dabzdx4442sXLmSyZMnYzabW8wX3bdvH4WFkv09kRTkhBDiNAgLC6PXuPPYXRpAo6+ZRsBTr+Oa+Gj+OHUgUSG+RzymrY0aDh8OazKZTsMrEEKIM4SqwsqXDm2+MPnBlkW5EyjWNeX1mrT19Bt5AbsMfVlf5xriHe3TwF0zxvD78dF4GfTuxyh6AwEXPnnE75DsF0KIjtPU0dyUsYd3oh2tWOdUNb7Zks+/ftnJzsIqADxwEly4gXP7GLjnvlm8/bbOPbLm8PxWFIVHH3201eeX7O/ZdJrWNFJQiI4n25+LM42maazcUci8H7exMa8aAC+DwvUJffjj1IFEBHmf1POe6hk8IU4nyX7RrVQVwtJ7oMoG/ma47LVDu9Mdq1jXjKqq7M0t4Kvtlbyzai8V9a5CXD+jL3dPNHN5whA8PE7s3Lhkv+hOJPtFd2Kz2Zg5cyYFBQVERETw9ttvu0+Mt1WsUx1Ovl63g1dX2dhtd73PD/Q2cO3ocO46ZxiNNRXuvD6V/Jbs77mkQ04IITqApmms2V3MvB+3sy67DABvReWmiQOYPXUg4QEnV4hr0lb3nBBCiFPkG+YqtjUV3XzDDt1WU+T6eZXN9bWm6FCxrpnymnrumPs+G2tDcRpceT/Q5Mf/TR/MxSMjMehP7gOVZL8QQnSMo3WiNY0fKCgowGq1UlhYyLZSePGzVWyrdO2MHeTjwR1n9aNozSesXbAWdUvLLrtTyW/J/p5LCnJCCHECjucMlXVPMf/4aQepe10zg7x0Dm4K2MAfeu0hfNpL4H9qxTghhBAdSFFcnW8HLxlVAbvN5sr9pmJdThqEDwOf0BYPrap3sHDNPt5cvouKxl5gAK+6Eh69cjw3TBqGXtF1zmsSQghxVM03UmgqxtkOZn9TsS4lJYXw2Anc8/lu0veXAT4E6Oq507SV22+dSY1DYeYra92FO5n3Jo5FCnJCCHEcVFXFZrMxf/589/yHpKQk0FSKs7dj7DOUjPwq/v7DdlbuLALA06BwQ3w0f/L+kfCirUd2WgghhOiaFAX8w3E4HCQlJZGRkUFiYqKr22HS/Th/forq3an4GV5CP/Vv1DhUFq7Zxxu/7aa8zgFAkK6OgOyVnDfUyI2TbkSRYpwQQnRpTZ1orWX/5bf9ia/Ko8jUhcP+Mrx0Dm4LyeAPpq14hA/EL9iEn06ReW/ihEhBTgghjqFpbsSKFSvIzs4mICAAq9WKrSCfrPl3UlJWyiKf61mvDgRAh0ZIcSbnR2k8fskMFGLaZbc+IYQQp4+qqiQlJfHee+9hMLjeMtvtdoxeTtK+XoiPs4KKzO1sKJ/EBxm1FFU1ABCoq+PJqxK4ZFQvSoonycwfIYToRpqyf+F772IO0LPK4MNfFqXyZUYRGMLRVCfTGlbwVO80+kSE8dae3nzz6ToS1s8lKSmpRZedZL84FinICSFEM61dkto0N6KkxHUJanBwMLGxseTlF/Bu1XhWesajqQpoKv2w47H9J0pzd5KRH4HdfrurVb2VGUNCCCG6hrayPyMjA4PBgMPhIDY2FlVV2bq/kF9311ITPZUvvK6kOqUcAI+GckL3/oSp0c5Zf5mEh0EvlyoJIUQX1lb2Z2Zs4f/i9RT1PY9vA65ge2Yx6HTU7lhN5apF3H5xGUE+BnZXhPP1umpy8vJRtRT3JaqS/eJ4SUFOCCEOamsHpeZDXseNG0dprYOfiv355JMDqHoLAIMq11G0ZTUGTydjxo4ls7GCmJgYHA4HqqrKGTIhhOiijpb9iYmJAMTGxuLn58esO+8kdPT5rB3yMg7vEAB0deWYClJ5on8mpj47KfEbiKOxQbJfCCG6sFazHwjzVokaO50v6q/DrhgB8K8tIHDvMuzbrESFqKiKB7Y6HaWOKnR1peTn5xMQEEBDg2S/ODHyf4oQQhx0+A5KdrsdcM2TmDNnDk888xweoy/la208JWEjUVGw9AngvcvNTDY5qSnYy969e/Hy8iImJoYvvviC6dOn8+yzz6Kqaie/OiGEEK05Vva/8MIL/PnPf+bXbTay+l7BSsdAHN4hBHkpxOv3Y/j+WdiylEEehUQG6vGyb+bqi86W7BdCiC7siOwvtLH1m39x7avf8X3jcOyKkQhDFddXL8Zn9b8JcZby6aef8uUvayBqPPlVsHpfA9tzilEUhQ0bNjBt2jTJfnFCpENOCCEOanW7c1WlvtzG7fM+J7XGhMPDF/SeeNcWcnZIOa//8c8oisLg6Eje/+BDioqKWLx4Mb169cJms6HT6Vi5cqXssiSEEF1Ua9nftJHPW2+9xW+ZOdQMOhdbv4sA8MDJn88bxh2TBlBWZGPKkn+wI7+EbzbVkRilZ/W+Brbtt+Mn2S+EEF1W8+wfkzCB/6zK5f30AagoeNFAhD2dx6PSiTbaiBnjZF+0hbi4OFf326z5XDFjCttzitEbGgFwOBwUFRXJ+35xQqQgJ4QQBx2+3blO0/jp07d4bksgexv7ggd41pfz2OWjOHfoOMzh4e6WdEVRMBgM6HQ69Ho9iYmJFBYWAjB58mTZZUkIIbqow7MfIDk5mZ9SM8kNHYs64ApQwVOv45rR4dx3YRxGf28AKg5mPzodb27zp3LI+XyU/RPhZp1kvxBCdGGKovDII4/wwcrtvLYqj6L0QkAh0bGO2Oz/sjJHISCggn6DetG3jwmPq2Yfet+vN1Du8ESnKBiNRs477zx+/vlndDrJfnFipCAnhBAHNR/smnmgkuSvNpGyvw8AQVRhLEhjyoBgbpx83RGzIcxmMzfeeCMrVqxg7NixPPvss9x///3u22SWhBBCnGaqelw7XB8+1Hvzrhw+zfWhLOZG0Lk27BnqUcI7D1xF7xC/Fo89PPvnPPsss+8vdt8m2S+EEKdXaxs1tCYrv5w5/9vIhrwqAPqEeKGs/4SSHCuLihvo06cP1SFReAT7oYuOb7FBW2vv+4uLJfvFidNpmqZ19iLEmaOiooKgoCDKy8sJDAzs7OWIM4jD4SArK4thw4a5uhkO0zTYdeX6DJwxF7Hb6Rri6qWozDRm8IdRBuribsIU3vZB1uFwkJSUREZGBomJie7B4EKc6ST7xWmnqrDyJdScVOyefTFeMReDh2crdzs01HtMwgT84q/k3dX7qHe45v/005fy/I1nkTCsr2S/ECdIsl+cbk2ZnpKSQv/+/Zk3bx6eni2zv67Ryeu/7uT1ZTtRUTDg5L4Zw7njrH689MLzWK1WEhISuPPOOzGHm1BqS1o9sSPZL9qDdMgJIXqcw8+MORwOZsyYQUZGBnFxcfzwww9HFOX25xXw5V4V+6DrwekBwBVjevPgeYPp7WkB3zCCjnGQLS4uJjMzE5vN5h4MLvMjhBDi9GiR/TVFqDmp7Nywmv3Fv/DWO2ks+frXI7LfbrezNjWN/R792FYxFOfyPQCM7xvCHyeYmT6y/zE/YEn2CyFE52me/Xa7nZSUFFauXMnPP//Mpk2bWLZsmTv7U/eW8PBnm9ljrwYUPO1Z9CtJ46r7XsXH06PF+AJ39jfrjGtOsl+0BynhCiF6lKYzY3fccQdz5sxxd8ZlZGRQVVVFRkYGWVlZze6v8em6XK77YCv28PGg9yBCqeSLP03k5WtH0zvUz3UgPo4zXk3DYSMiIg5tCiGEEKLDHZH9XsHYPfuyv7iOtTmNrNqQ1SL7ATRNY53NSU7crVQPvRCnwYeBJj/m3zKeT/44gXNHDzyubgfJfiGE6ByHZ39ISAj9+/envr4eVVXZvn07WVlZlNc2MuezLVzz5lr22KsxBXgx3WsPg23LmDw21p3biqIc9yWnkv2iPUiHnBCiR2k6M7Zx40bS09MBeOaZZ4iLi3N3yA0bNgyAdftLefrrrWzKKQMgOsSHu8/qxdUTBqPX60/4dx8+GFza1oUQ4vRoNfufTuatd9JYlZFFbNwId/YDbM4t49mvt5G6rwTwJtTXwAPnD+Xa+D4Y9CeW3ZL9QgjROVrL/pdeeolNmzaxfft2RowYQY4awh3zllNYWQ/A9Ql9ePjCYQR4Tcduv+akc1uyX7QHKcgJIXoUk8lEXFwc6enpGAwGMjIyKC4u5v3336e4uJiYmBiKqh3M/W4LSzceAMDPU8890wdz+1n98PY48UJcc01n1oQQQpw+rWZ/SSmvvv2RO/sNBgMHymr5+w/b+XxDHgDeHgqzJw/gD1MH4ud18m+LJfuFEOL0ay37S0tLWbJkCXvzCvl4l8pdizcCMCDMj7lXjsAywOh+/KnmtmS/OFWyqYM4rWS4qzgdmg9ZTUhIQKfTkZqayviERMInX8try3ZT0+BEp4Orx0Xx4IyhhAd4d/ayheixJPvF6dBW9lssFu7760O8tXIfb63YTV2ja8OGK8f05sEZQ+kV7NPJKxeiZ5LsF6dDa9n/U5Yde59zqMMDRQd/mDqQe88ZfMon3oVob1KQE6eVHJhFRzl8I4em71VV5c477yS7wY+62Etp8AoGYGyfYJ64JIYIzwZpMxeig0n2i45yrOzPLyjAZ+hkGoZfSGFVIwAJ/UL404QIpozoJ9kvRAeS7Bcdpa3sL66q5/q/f0Z58GAABhi9efm6cYyKDj7iMUJ0BfJ/ojhhr7/+Ov369cPb2xuLxUJqampnL0mc4ZoGus6cOZPk5GRUVXW3kDd4BFA56noqxt5Cg1cwYf6e/OPqUfx3diJfvvdai8cIIYToPo7IfqcDpboQs4+GOdzEgPFnUzvhj+RGn0thVSNRIT68dsUA4mw/81LSnyX7hRCiGzo8+x0OBzabjV93FHPT4u2uYpymMsqjgG/+PJkRQXXkH8jjmWeekff9osuRGXLihHz88cfcf//9vPHGG1gsFl555RVmzJjB9u3bCQ9vfUtoITqa3W7HarVSUFCA1WrFZrPhUOGzbZX8+7fd1DuD0evgtrP6ce+5Qwj09nBvUd70GNmqXAghupfm2Z9qTaHq2yfx3fkVJbog/m6YzVf1w9D8wMdDz93TBjBLtxRd5ipKc/fwVYGnZL8QQnRDzbM/JSWFB+Y8xpe5Xmh94wEYYvbnkenRTIm7EFb+g12/LWH1/no+WuPAzz9Asl90KdIhJ07IvHnzuPPOO7n99tuJiYnhjTfewNfXl3feeaezlybOBKoKVYWur80033Y8ISGBJ//zEee89Csv/7yTeofKhAFGvvvLFB67OJZAbw/3YxISEggJCSEhIUG2KhdCiC5KVVVsNtsRHQ3Ns39afBz56V8xvyiG6bb/45O8EDTNNSdu2YPTuMcSjHd+Gp6NZVh66+kXHiDZL4QQXdjxZL8xdhJL62PR+sajqU5C8lN5+5ohTBs1AKW2hMY9a9BVFzLIu5RQbxU/Pz/JftGlSIecOG4NDQ2sW7eOOXPmuH+mKArnnnsua9eubfUx9fX11NfXu7+vqKjo8HWKHkpVYeVLkJsOUeNh8oPQbGbEnDlzyNqfz6vLc/hpRyl4gaGxmicuG8FNk4eh0+lazI4AaBqhKaM0hWhfkv2ivTRdmmS1WrFYLCQlJbWYFzRnzhyKi4tJ31/Kzf8dTKEhEoBY/yqevulcxvUzuj7UFTox9R6HLjedXHwpb2yU7BeinUn2i/ZyrOz/8/1/5amlm/lssx18wVF6gKqf/821vz+P3pGuzjfVJ5T68JFo2fvZV+rExxiGTtFL9osuRQpy4rgVFRXhdDqPaO81m81kZWW1+pi5c+fy1FNPnY7liZ6upshVjKuyQW46alUhtmqN+fPnY01NI2DsRWTo+lFV70SHRmjRFn7XR+XGSVe5i3HJycmkWlM4O2EE18/6P9LS0igtLSUtLU1a14VoR5L9or20NpIAYP78+aSmphIXP4mqwefz9eZ8MERicNQyxSeHtx66B4OHhzv7U1JSGBEXy72zHuXlJY9QUlom2S9EO5PsF+3laNm/LCObooG/o1LzAmC43kb93k8Zd+W5PPfcc+7CXfJzc7GmrCMhdhKX3n0H3o8+hs1mk+wXXYoU5ESHmjNnDvfff7/7+4qKCqKjoztxRaLb8g1zdcblpqP2Hscz897gl19/5UCtHuKvx9HQG3AyKjqYZy6NwewZ32IXJbvdTqo1hQv9tzK+JBO/9R5YEhKwpqZisVikdV2IdiTZL9pL06VJVquVhIQE3njjDZYtW0a+rRCPuBlsrRqGujkfRQc3JPThlrGhDIq+skX2p6SksHHjRtLT01E1GB+fQFpammS/EO1Msl+0l9ay/9fflpMXOgZ1yGWgKUQEeDLv2jEkDgjFbr/oiPf9ruzfRFr6OqrwJSFBsl90PVKQE8ctLCwMvV7vPkPRxGazERER0epjvLy88PLyOh3LEz2dorguU60pwlbRyKI/XUBFn0l4Jf4OnaLgiYPHLxvFDZa+KIruiIebTCbOThjB+OJMegXo8Svdxuwbn2DWnXdiNptl+3Mh2pFkv2gviqKQlJSE3W7H4XAwffp0inRB+E69j8bQKADG9QnmqcviiOsddMTjTSYTcXFxpKWloSgKGRkZPP/888yePVuyX4h2Jtkv2svh2T/tshuoHX0NhrB+AAw2FPPJfdcS7Ov6/+3wbjfJftFdyP+J4rh5enoybtw4fvnlF/fPVFXll19+YcKECZ24MnHGUBTwD2fNvkoazvkb3qMvRqcoTO7jw8o553PThH6tFuNcD1X485ynKfUfyIEKJwt/yWTmnx9iwYIFp/lFCCGEOKZmm/goioLZbKa8zknj2OsIuPwJ9KFRBHopvPj7EXzyx4mtFuPAlf3PPPMMQ4cORVVVsrKyePjhhyX7hRCiC2q+kYOiKISZwvlog53Gs+93FePqq5gz2cgPT9/kLsa1RrJfdBfSISdOyP3338+tt97K+PHjSUhI4JVXXqG6uprbb7+9s5cmzgD2ynqe+irTNSvILxRDfQVnB9p4849/Pq4zXcUlpby2yZtqewBb99kwR3iCbH0uhBBdy2Gb+KhnPcCSdXm88H0Wat8EAIYa7Cz+63UY/b2P+XSlpaUEBgZiMpmw2+3k5eVhlewXQogu5fCNHG770/08+L/NWPeWgN6AX9keLoms5M4Lrz6u9/2S/aI7kIKcOCHXXnstdrudxx9/nIKCAkaPHs33338voSY6lKZpfL4hj6e/3kpZTSOKDm6b2JebR4fSt3fEcbedm0wmEiyJpKRArH843t7eMkdCCCG6mmab+OzYtYs5W1axLrcKgOGRATwwtTfTR154QtmfmJgIQEREhGS/EEJ0QU0bOeQXFPD99jI+enUFNQ0qPh4Kj140nHP6jSM8PFyyX/QoOk32/RWnUUVFBUFBQZSXlxMYGNjZyxFdRNMW5s2HsR68gbz8PB754QDLdxQBEKrUELLjG6aNGujeAv1kfpfRaKS4uPjI3ymEaHeS/aI1bWW/6nRQ/M0zvLfTizeLRuDQFDxwYsxfy4UDfXnsUcl+IboDyX7Rmray3+Fw8GDSE/xSYaYyaCAA4UoVQVlLmTJmuLzvFz2SdMgJIU6LNj94Hdae3nSwVR1OFi1+h+ezTFSrHuhUJ3G6bJybfsBuO8B2xwHshTbMEZEntI6mWURw5ABYIYQQ7euEs19VufuZf/FL+RAavIIB6KUV4Zf1DYX7tpNaFHVSlxtJ9gshxOlzMtn/p2de5xfHaJxBvqA6GanLpnHjdxzIyyWlvlyyX/RIUpATQnS4tg6+cKg9vaCgwD3XoVbvz9/+u47U7F4ADFV3U7/uS1RvL0bGxRLbax+W3nZMWe9D+F9dmz0IIYToUk40+z39Q3j00/V8VzcEvECrLsVv+7cEGcqoqqykoKCAsLAwjEZjJ78yIYQQbTlW9qdaU2goySPVqmG32wkIMfLo/9bzY/0g8AC1NI/ArZ/hCFAk+0WPJwU5IUSHa+2Dl9lsRlVVVFUlISGB1NRUEhIsfLuzmhd/2EBtoxNfvZO/hqfRp3Qdr/h4kWBJZM7/zcT52XY8G8vQ5a1zzRryD+/slyiEEOIwJ5L9aQUOnvxqOUVVDYBGaHEGgfuX4+ehEBc3goyMDCIjI/H29qa4uFg6HYQQootqrejmzn6ng/vGq/iXlVEd0ovcGj0PvL+SfcU1ABjtGwncvxzfQA/i4uIk+0WPJwU5IUSHM5lMWCwW95kyk8nU4uxZfHw8T/79n/x9WQ7vfL0NgAkDjLx4ZRzR3omoPqHEFR2c+wAYBp7l3n0P37DOfXFCCCFadTzZ/+w/XmPeilze+WgjAIPD/Zl7ZRzRPvEYjQ9SXFyM0Whk7ty5LZ5HCCFE12QKM3J/vIZfqavoZgozurN/+7qVPD66kN4Do3i9NpE33rKiatAryJsXrxrJ4MDxGI0PSfaLM4Zs6iBOKxnueuY6fJaEzWZj5syZ5BfY8IqZTmnUWdSqenz0Ko9cFMeNif1QFF1bT+bqjPMNk8tVhegGJPvPXG1nfwFew6Zh7z2ZRp0BHRr3TB/MPdMH4WXQH/N5hBBdn2T/GaqqEO2Lu2ksP4BHUC90l7+OrVpj5syZ2AryuX5cEN+FXstOLQqAy0b34unL4gjy8TjiPb5kv+jppENOCHFaNB+qCq7Oidj4Sey1h1DsHwUqWLyz+XvfNPqMtEBbxTjXk8llqkII0Q20lv0x8ZPZaw+i2D8aAEN5Lv0KV3PTfX9vtRjX2vMIIYToonzD0EXH46k7dDWLyRcSEix8t6ua14Mn4tT06BpriMpfxSP3PXKoGLfypUNXwUx+ULJf9HhSkBNCdKjWzmxpmsbnGw7wjTqGan8HPh56Hh6cy83KMpRouQxVCCG6u7ay/6O0HL5xjqLa34m3h8JIXTY1OV8xPSEOU5gM7BZCiO7Mnf2T7kepLXF3utkr6tjZ+3zya4oA6KVU4L/rc8YM639os4aaIlcxrsrm+ipzosUZQApyQogO09ouS6U1jSR9nsH3mQUAjOkTzLxrRtM/1AdqLpXLUIUQoptrLfsPlNfx8KdbWLXL9WEsoV8oL141kj4hXlR/n4d/6TZ0q+bB5AflGCCEEN1QW7urfrsln0c+30JZTSNeBoU5Fw7jhvgoHntsIxkZGcydO9d1X98wV2eczIkWZxApyAkhOszhO+x9bt3J3F9yKKqqx6DouO+8IfxhygAM+oMfvpqdBZOZEUII0T01z/4Uq5W3ftnKa6vyqKp34O2h8LcZw7ht4sE5oVWFBJRlQXUhWk4aRfu3Yew7XHJfCCG6mcN3V92bm8/rKXY+W58HQGyvQF69bjSDwgOw2WxkZmZis9lISUlh69atxMTEoEx+UOZEizOKFOSEEB3GFGZkekIcP6fraRx5JQ8s3QXAELM/864ZTVzvoFYf19YZNiGEEF2f0WgkNjaWBr0vZXFX8Pwv+wEY3zeEv189iv5hfofufLAjQstJ47fd1cxb8jcSLImS+0II0c0YQ0O4Z1QdIVVlrA8axy2Ls8grq0PRwV3TBnLvOUPwVICqQkxhRiwWCykpKdTV1fHQQw+RmHgw++UyVXEGkYKcEKJ9Ne2O5BOKsmoe0yPKWDruZvbX+qDTwaxJ/Xng/KF4e7Q+uBuO7Kyz2+0y0FUIIbqwpq5mo9HIc8/NZVVOPYXDbqDR6YGXQeGvM4Zy+1n90R++YY+iwOQHKdq/jXlL/kZ+gU1yXwghuonm2f/PuY+TWLWPL/0uZ1HDuWgNdUSH+vDyNaMZ3y+0xaYNStR4kh6Zw9ZtWTz00EPYbJL94swkBTkhRPtpdqB1mobxRqael22/w4GeyAAPHp3RnwvHDjxm14PJZMJisbg75Ewm02l6AUIIIU5U867mQbGj+LU8nIo+YwEYbvblqQsGMH5otOsS1dYoCsa+w0mwJEruCyFEN9E8+2NjY1m/M4eP+z6ITe0DwMUxRp67eiyBPp6uBxy2aYNSW0JMTAyJiZL94syl0zRN6+xFiDNHRUUFQUFBlJeXExgY2NnLEe2tqhCW3kNeWQ33FV9Bak0EAOOVnQzxqGTzuuO/BFVmyAnRc0j292w2m42ZM2eS3ehPTdyVODz80FQnoQdSuHiABxvWrzuu7JfcF6Jnkezv2ZqyP7+gAM/hZ1MQcRaa3gO9o5Yp3jnYN/7SMvubnbgnarx7Ex/JfnEmkw45IUT78Q3jK/10HskzU6l6ojgbMO36kvKqHNLQUVpaetzt6IqiSMu6EEJ0A35BIThGX0WFw9XZ4FlXgse6jzB6NZBiO/7sl9wXQojuw2QyMTLhLPbbgigO6AtA35ptKDtXkOuoPTL7D44oOHzTBsl+cSaTgpwQol3UNDh46sutfLwxGoBYsy/DyzPIarSTMHkKmqaRlpYm7ehCCNGDZOSV8+clG9hzsBh39agwfHasZ32QQkKCZL8QQvRUv+2w84NuPJUBDXjqHNyl/4oJyi+sTryGKnxbz35FAdm0QQg3KcgJIU5ZVkEF9yzewK7CKnQ6GGnIx/HLlwTEj2P+/Pnus17Sji6EED2DqmrMX7mHl37cTqNTwxzoxZiGDLYt+g/x8fGS/UII0ROpKnXlhTy33M77KdkAhOhquLH0TS6KKCLi3JtIuPAJ0CmS/UIcB/nrEEKcNE3T+CBlP5e+tppdhVWEB3jx2pVDcKz/nNyc/aSmpqIoivuf2WyWg7IQQnRVquqaBaqqR/15fnktN71tZe53WTQ6NWbEmll43VB2r/6G/Px80tLSJPuFEKKbUFUVm82G2iz7W/sZqkrWt//i0ld+dhfjrh0dTui6t1mSVsLTG8OpHf8nFL1Bsl+I4yQdckKIQ1T1iLkObSmtrue+j9L5bVcZABP7B/Hq9eMI8fVgXl0dBQUFhIWFYTQaT8PChRBCnCxVVbEX2jBlvY+St67FsO3Dh3B/G3IjD3+6hYp6Jz4eeu6bGsXtU4cyd+5csrNdH9Di4+Pl8lQhhOjimopu8+fPJzU11b0BA+DePbXpZ5qm8e9vUvnX2v40aHrC9DW88PsRrP76v+Tu3wvA4DGXYQqXWXBCnAgpyAkhXNrY+ag16/eXcMsbv1GleaGgMt4jj/Kv/sMbhRZmzZqFt7c3kZGReHt7U1xcLINahRCii1JVleTkZLavW8njo+0MjgxEl5vuOjnjH+76mptOXUUxz1j1LCrZCIBRV800/V6+fOU1dv8US0ZGBgEBAYSEhDB79mzpihBCiC6sKftXrFhBdnY2AQEB7g0YAKxWKwUFBVitVrbtzeUP76wi1xkE6LEoWUyzf8JPH09hS0amZL8Qp0AKckIIl4Mfuqiyub42fRhrRtM03lm1h7nfZeHQvFCqi+m1/wdKawvdOynNmjWLxMRE91k16ZIQQoiuy263Y7VasRUUYzU56BsdhFf4MPAJdd3BN4xdwRO5e4eR7fWun3nvXUlI6QY2ayqlpaVomkZcXBw6nQ6LxSInYYQQootryv6SkhIAgoODiY2NxWg0oigKFosFq9VK1LhzuOmDTEqdQeBsxJS3EmfZOt4pbCTcnCnZL8QpkoKcEMLFN8zVGdfUIecb1uLm8tpG/vbJJn7YagNgeN0mNnz+Jp5DBnLWlCmkp6e7D8ZJSUkyyFUIIboBk8nk/uC1Lyoej2gn2LbBqnlokx7gk/UHeDxlKHWNKtRVUrvsDTxrD3DW9dej1+tdlzklJDDnz7MortNhCpeZQUII0dWZTCYsCQlsX7+KQaMuoqa2joyMDObOnUtSUhJ/e3gOyUs38n56AaDiLM3Da90ifnfRNPT66dSlphIfH8+sWbNkXpwQp0CnaZrW2YsQZ46KigqCgoIoLy8nMDCws5cjDtfGDLktueX8afE6ckpq8dA5eSjoF0bkL2VOSgA+YX1YsGABiqJgCjOi1JYc1ww6IcSZQ7K/a1NV1XUSxUdD+erPUGWj0ieKJN09fJnp6p7wrdhP/ucvoNaUMWrUKD7++GPMZjP2Qhth2xbi2LsWjwETUab8VfJfCAFI9ndpqoq64u807llDffhIbnxjPfkFNiIiInhm3r95+uccNmSXAVC/9RdqVn/AqNjh7uy32Wy89eabZKT+xgjL2Tz62GNSkBPiJEiHnBDiEEVpcZmqpml8aM3mma+20uBUiQrx4fVhGYysPMBv9TH4mXQkWBJdZ8XguGfQCSGE6DqauhtQVYgaT8bOPdy973z215SgV3Q8cN5g7CvWsTjQGwIjOOecc9zdECZfHbuWf4yuuhAtO5tBY29FCYzo7JckhBDiaGqKUPLW4dVYhmdZFmcnjODXVB3h42Zw86JtVNU7CPA2MF7dzprt3xAYFtoi+9FUgjbPZ2ZYFVmbdmIrmEVkr96d/aqE6HakICeEaFVtg5NHPt/C5xvyADgvxsxLV40iwGsKRdnnMPnawcSUlB66LLWq8Jgz6IQQQnRdmk7HR17X8OTerTQ4NXoH+/DP68cwrm8IjsmPcMUVl2M0GomMjHR3QthrNKx5DvoZVPaVOQiq0TBLI4wQQnRtzUbV6KLGc9dV95L32SY+3WwHHIzrG8Kr140mIuActl417YjsV2pLGGVsIEgPXl4NritkkIKcECdKCnJCiCPsLarmrg/XkVVQiV7R8dAFQ7lz8gA0TTtiG3R3e/oxZtAJIYTouqrrHTz6RYb7JMw5w8L5xzWjCPb1RFVV5s6d2yL7m5jCzeyLvpof1q9i6NhJmMJlqLcQQnR5iuK6mqWmiL01Ptz9Zipb8ysA+NO0gdx/3hAUHUe8729i6jccrfd4Gkoy0UJjMfUb3lmvRIhuTQpyAnCF7TfffMPGjRvx9PSkrKzsiPtkZ2dz1113sWzZMvz9/bn11luZO3cuBoP8b9ST/JBZwIP/3URlvYMwfy9eu2EMiQOMABQWFrbYBt1utx/aUanZgV1myAkhRPexw1bJnxatZ1dhFXpFx99muE7CKIoOOLQbX2vZrygKSY8+Khv5CCFEd6MofLnbwZxPV1Pd4CTUz5OXrx3N1CEmAGw2W9vZrzcw7bGvKM7ejrHPUBS9fB4U4mTIX44AoKGhgauvvpoJEybw9ttvH3G70+nkoosuIiIigjVr1pCfn88tt9yCh4cHzz33XCesWLQ3h1PlpR938Mby3QCM7xvC6zeOxRzo7b5P8934LBYLJpOp5ZMcNoNOCCFE1/b5hlwe+SyD2kYn5kAvXrthLPH9Qlvc51jZ755BJ4QQoutTVerKC3l6WSGLU3MASOgfyj+vG0NE0PG/71f0Bkz9Y0/r0oXoaWSXVdHCe++9x1/+8pcjOuS+++47Lr74Yg4cOOB+0/3GG2/w0EMPYbfb8fT0PK7nl92WuqaS6gb+76P1rN5VDMAdZ/Vnzu+G4aE/stPBvRufdEIIIY6TZH/X0+BQefabrby/dj8AkwaF8cp1ownz92r1/pL9QogTJdnfBakq+79/lbtSjWytM6LTwT1nD+LecwZjkPf9Qpx20iEnjsvatWsZMWJEizPgM2bM4K677iIzM5MxY8a0+rj6+nrq6+vd31dUVHT4WsWJyTxQzuz315FXVouvp54XrxrJxSN7tXl/6YQQQhyLZH/XVlBex58WrWN9dhkAf54+iHvPHYL+4CWqrZHsF0Ici2R/1/fjhp08sKoflaonRn0tL18ziimjBrd5f8l+ITqWFOTEcSkoKDgijJu+LygoaPNxc+fO5amnnurQtYmToKpQXcjSjBIe+nY/dY0qfY2+vHXzeIZGBHT26oQQ3Zxkf9ekqirfrdvFo9/upbTWQaC3gZevHc05w+XDlhDi1En2d02qqpKXX8Cbaw7w4Tob4Mk430Jet5QSMeLKzl6eEGc06TvtwR5++GF0Ot1R/2VlZXXoGubMmUN5ebn7X05OTof+PnEcVBXHb38n+ZV/cu/SvdQ1qkwdEsYXf5pIsK4GVVU7e4VCiG5Osr/rcTqdXPv4W9z9SRaltQ5CdDUsvXsiZw81YbPZJPuFEKdMsr/rUVWVOU/PZcrjnxwsxsEdZ/Vl8f9dgG7U9UjyC9G5pEOuB3vggQe47bbbjnqfAQMGHNdzRUREkJqa2uJnNpvNfVtbvLy88PJqfR6NaB8nOtuhuPAA96wMYm1tHAB/Mm7gvitn8vy8F1tsay5zIoQQJ0uyv+OdSPbXNDj484eppDmiQQFLzUrOqfwW78aJJCe/ItkvhGgXkv0d70Tf9/+wfjefVAxCM/mjNtRiWPcRM//vn7z42gLJfiG6ACnI9WAmk+nIXTBP0oQJE0hOTqawsJDwcNcumj/99BOBgYHExMS0y+8QJ05VVZKTk4/7gLrtQDnX/CuVSi0aH62OR3ibqGqNoprb29zWXAghRNdyItmfU1LD7A/S2ZZfCaqTa8sXcrXuRxr9g6G6SLJfCCG6iRPJfk3TeHf1Xp75OgvN059G+36Klj6Pv1aN3W6X7Beii5BSuAAgOzubjRs3kp2djdPpZOPGjWzcuJGqqioAzj//fGJiYrj55pvZtGkTP/zwA48++ih33323nAnrRK0dUNvy01Ybv//PGio1L5SaYnTfP8N7v2UzL10BnYLFYiEiIqLVbc2FEEJ0HW1mv6pCVaHrK7B2dzGXvb6abfmV6B01+FnnE7T/V6pUH3bVBoNfmGS/EEJ0E21lv6qqLUYP1DY4uf+/m3j6621oKBjyNlL6SRKe9aUYjUZMJpNkvxBdhHTICQAef/xxFi5c6P6+adfUZcuWMW3aNPR6PV9//TV33XUXEyZMwM/Pj1tvvZWnn366s5YswH1AtVqtJCQkoKoqqqq2OFumaRr//m03L/24HU2DSKWSwH1f4Agz4u3tTYIlEbPZTFJSkmxrLoQQ3UCr2e90oKyaB7npaL3H877H1Tz9zTacqkZcr0BiS7eQ4a/ya90YMm16ho2bjDkiUrJfCCG6iday3+FwMHfuXHfX3K1/uo8/friBrfkV6BUd4w3ZVJasoc/4MSiKwuTJk4mMlOwXoqvQaZqmdfYixJmjoqKCoKAgysvLCQwM7Ozl9AhNZ8Xeeust0tLSWrSw1zU6+dv/NvPlpgMA3JzYl0cvGkZZSTFGo5Hi4mI5EAshOpxkf/s7PPunJ8Rx34DdNFQV81j5pfy3dDAAl4/uxfO/H4mnXofdbpfsF0KcNpL97e/w7I+NjSUjIwObzYb/wPGUDL+cijonRj9PXrthLJb+IZL9QnRh0iEnRDenKAqKopCWlnaohb3QhqY6mf3pPjbnlWNQdDx+8XBmDPTFQ6+450TIvAghhOieDs/+ZakaV8QlcP+uKDbURaDoYM6Fw7njrL4UFRVhMpkk+4UQops7PPs1TSMmNhZbyAj2R01Cq3MyMiqIf98wBo9G1+ghyX4hui4pyAnRA5jCjExPiGNZqkZCQgI263+5M60XNocvwT4evH7DGH5d8gYzn5PdlIQQoqcwGo3ExsaiaRoDxk3lkrRBVGleeOJg/m2JTB5sOqGNf4QQQnR9zbN/bLyF1Q19KYoKA+DqcVE8fWkML734vGS/EN2A/GUK0d2pKsqqedw3YDeL7xpHwoVXcW1KX2wOXwZ5lfHFbUMJqreRkpJyXJs/CCGE6PpUVWXu3LlkZGQQGjeFH9URVGleKNVF9N3xCUMCVbZu3SrZL4QQPUjz7B8QN5b0wMnsUcNAdRJ5YAX3nWVi987tkv1CdBPSISdEd1dTBLnpUFXI4qJYnl+5Fw0PJvsf4F+WMv61cCEpVit1dXWYzWbZTUkIIbo7VaV4/zas1hT2eg0kk1hoVIlUKgjK/pKJ40bx1ltvkZqaKtkvhBA9hKoeOtGSW2sgqzEOZ2ENXjiI3P8t02N7M3/+fMl+IboRKcgJ0Y2pqoq9yklQ5HieyPXg49IhAAwzFPL2PRdTWgepr86isTQPn5BePP/CC8TExABgs9lksKsQQnQnqopacYCaZS8TUJlDyKhp1DhdmR5SnMn5vev44xuvATBr1ixyc3Pp3bs3L0j2CyFEt6WqKnl5eTz//PPs3bsXu19/ymPOA70HwbpaPrvvfPy0RFRVPSL7hw0bJrupCtGFSUFOiG5KVVWSk5NZk7aBsriryVcDQVPx2/ED+sZ9lNb/DqMxhHtG1RFSVUZ1aC9ihg8DkJlCQgjR3agq6ooXKf3t3zQ4HPxZfYA0dRg6NMx5K2nc9gvr8iNQ7voDISEhVFRUkJ+fT1hYGMOGSfYLIUR3pKoqzzzzDK+++irl5RWETb8Dn4G/A8CjcBuRRavx0yZjNptpaGhokf1Dhgxh7ty5kvtCdGEn9RdptVrbex1CiBNkt9tZuX4rO/pcQr4aiK+ugb94fcuAxr0kWiwYjUb+OfdxQqp20ytQz9SBvii1JdjtdqxWq8yVEEKI7qSmiMZdyyls9OEGx1OkqcPwpp4+e7/G70A6EQcvTTIajTz22GNs374dRVHw9vamuLhYsl8IIbohu93Or7/+SlVtA8ZLH8Jn3GUAKFk/oVu9gMRxozGZTKiqekT279ixQ3JfiC7upDrkJkyYwKBBg7j55pu58cYbGTBgQHuvSwhxDPn1nuQMuxan5kEY5SyM/IyYUB033v4ixr7DsdvtLEvdgre/jvE6J0EhMQT4hmHyBYvF4j5bJnMlhBCiG/ANIzPsAmbuMlNKAKGUY9zxLaXZWZjNZvdlqXa7nYyMDDw8PHA4HMTFxblzXrJfCCG6F5PJROLZM9gz6Gr0pv6gOuiVu4yG3FWE9Ilm9uzZKIqCzWY7IvuHDRsmuS9EF3dSBbkPP/yQRYsW8cwzz/Dkk0+SmJjIzTffzDXXXENoaGh7r1EIcZCqqtjtdjbandy7ZBN1mgeDwnxYGJdF72IFosZj6jscFAWTyUSCJZHvrFAXOoLxFzwOioICJCUlyTwJIYToJlRV5eM1O3gyfQj1qAw1evDOHRfzzr93Y20ow2KxEBMTg3Iw+xMTE9GhYYkbyJxnn3HnvGS/EEJ0H6qqsipzP795JqA31RPgqfDmzYn8smQz1ooILBYLZrMZwJ39mqYxYMAAnnnmGQwGg+S+EF2cTtM07WQfXFRUxJIlS1i8eDEpKSl4enpywQUXcNNNN3HppZfi6enZnmsVPUBFRQVBQUGUl5cTGBjY2cvpVlRVJfnZZ1m2p5w95mmgU+itr+DbpCsJ8vZw7bbqGwbNDrZNBTw5CAshOpNk/8lzOp1c+8R80hujQKfDv2IfV0aU8eSjcwBazXjV6aD6+6fxL92GLjoeJj/Y4tgghBCng2T/yVNVlTuf/Ce/1vZF03viWVfKZSF5vPDYX4HWs9/hcJCUlERGRgaJiYkyM06IbuCU/kLDwsK45557WLNmDTt37iQpKYmsrCyuvfZaIiIimD17NqtWrWqvtQpxxlJVlYyMLWQVVbEnYjroFDxz0gje9BF1lWWuD1r+4Ud84FIUBbPZLAdjIYTohhodTv68cBXpjmjQ6ajd/D261fNZn7oWu93eZsYrtSUElGWhqy6E3HTXCRshhBDdgqqqPPe/tfxSPxBN70lDzha8VvyTbWkrj5r9xcXFZGZmYrPZZGacEN1Eu31K9/HxwdfXF29vbzRNQ6fTsXTpUqZOnUp8fDxbt25tr18lxBlFVVWefvY57vjPL6z2nQrANQ1LGV+1mkRLvMyDEEKIHqi2vpHznviIb3ZUoWkqNas/xJn6EWZT2LFnAfmGQdR48De7vvqGnb6FCyGEOGkOh5NLHn+PBevLQKdQn/kLDT++jDk08JjZbzKZsFgsREREyMw4IbqJU7pktbKykv/9738sWrSI5cuXoygKF154IbfccguXXHIJiqLw+eef88ADDxARESG7swppXT8Ju7MPcOmLX1HtH4WiOXnG9CvXjYugaPitmMKl+00I0fVJ9p+Y8ppGbn17DRvzqkB1oE9bRJRqY/r06cyePfv4Op9VtdVRBkIIcbpI9p+YukYndy20smxXKQD6jK/oXbmNc04g+2VcjRDdy0lt6rB06VIWLVrE119/TV1dHfHx8bzyyitcd911GI3GFve96qqrKC0t5e67726XBQtxJimsqOOez3e5inHOBs733cf1sx9G8Q/HLAdZIYTocQ6U1XLrO6nsLKzCEwe99n/D2dNimT371RMbQdA0ykAIIUSXV1LdwJ3vp7NufykKKr1yfuG8+Ehmz37ihLK/6XJWIUT3cFIFuSuuuILo6Gjuu+8+brnlFoYOHXrU+48aNYobb7zxpBYoxJlqt72KW99JJbe0FqOfJ/MuG87kuMvkbJcQQvRQWQUV3PZOGgUVdZgDPHj3tokYDYnS6SCEED3Y/uJqbns3jb1F1QR46XnjpngGBSZI9gtxBjipgtyvv/7KtGnTjvv+CQkJJCQknMyvEuKMtCG7lDveS6O0ppF+Rl/ev8NCH6NvZy9LCCFEB0ndW8LMhWlU1jkY7F/He73+R+9dG2WHVCGE6ME25ZRxx3tpFFc34Kerx5zxOb8uSWNC0w6pMn5AiB7tpApyJ1KME0IcP1VVWZq6i0e+2UNto5NRUUG8fVs8Yf5enb00IYQQHeSnrQXcs2g99U6N+Gh/5vt/RHBdDuRWuz6IyaWnQgjR4yzfbuOPH66ntlFlaLgvrFhIce4erPWl2O12zCYTrHzJtVt21Hg5QSNED3RSBTkhRPtTVZU7nvo3v9X1AZ2eqUPC+PeN4/Dzkj9TIYToqT5bl8MDn2xCQ0cffRkLZ56Lr9UKuQ2yQ6oQQvRQX2zI5f6PN6CiEK2U8vHss/lX9SqsjppDO6TWFLmKcVU211c5QSNEjyOf9IXoIv79Uya/1fUDnY6gsh3cN74PPh5yFkwIIXqqd1fv5amvtgI6vPI34l+Uwp5do4iZdD9KbYlcoiSEED3QoexXGFa9jiTdeyi/bSfpkSewFxUfmh3nG+Y6MdPUIScnaITocXSapmmdvQhx5pDtz4+kaRqv/rKTV37eCUBo0WaC9/6Mj7c3iYmJJDXNkBBCiG5Ksr8lTdN4+eed/PMXV+7HGmxoGz6lvq4Ob8l+IUQPIdnfkuZ08tK3m3h9dT4AI/V53Fv4KOHeTryM0Qy6/3uUwIiWD5IZckL0aPJXLUQnUlWNJ7/MdBfj7j1nEAvvvRhvLy9yc3NJSUnBbrd38iqFEEK0F1XVeOLLTHcx7oHzhvDlU7fy4gsv4CXZL4QQPZKj0cGc/3zkLsY9eN5g3vjT78h2GClpMGDNdWKvaaVPRlFcl6lKMU6IHkkuWRWikzQ6VR78ZBNLNx4A4PGLh3HRYH9CQkKor6+noKCAsLAwjEZjJ69UCCFEe3A4Vf72v818tiEPnQ7+enYfZk/tT1FREUOGDJHsF0KIHqje4eQvi1L5LjcEBZWnwldx/bgx2Ko1PtwfgW1PMREDTVwfZurspQohTjMpyAnRgVRVxW63uwazgvu/G5wady9azy9ZhehQ6ZX9C4uemMen3t7ExcXh7e1NZGQk3t7eFBcXYzabO/mVCCGEOF6tZX9QiJH7/ruJ7zIK0OtgkmEP37z6bz59wXWZqmS/EEJ0b61lv39QKHctWseKnaV46lQeNnwEW7dwwe/TQKeQk5uHT1AkXt4+kvtCnIGkICdEB1FVleTkZKxWK/Hx8eh0OlJTUxmbMIFdEdNZs6cEnepAn/IuVeV72VVQQGSEmWBDAyPixqDT6Q7tsiSEEKJbaC37U9LWUTHyWnKdQSiohO/8mpQtv+Ht7U1BQQFms5n6+nrGjh0r2S+EEN3JwRlvqk8oyc/NbZH9a9M3UhJ7DTYtAC+tnruUL/l1cyGZ+xUO5GcSHh6O0+nEZDKRmJgouS/EGUgKckJ0ELvdjtVqpaCggFWrVgFQXFnLHruZmpoSFGcD/hsXUW/bhik6GlOYkVv727FE2YkY50n1vW9ijoiUod5CCNGNHJ79quJBdt8LaXQG4aXXEbH7W6r3rQPAZDJhNBrJzc0lOzubMWPG8OabbxIZKdkvhBBdnqrCypcgN53q4GGkWtdRUGBj1apVOAw+ZPe/BKcWgK9Ww9MNL9NHPUDlsEsodXgREurKfkVRGDp0KA899JDkvhBnIPmrFwDs27ePmTNn0r9/f3x8fBg4cCBPPPEEDQ0NLe63efNmJk+ejLe3N9HR0bz44oudtOKuz2QyER8fT0hICBMnTmT8pLOpscyixi+SQG8DF/ntoY9XHTfeeCMffPAB33/6IVdP7I8/NWT98iEfLfhXZ78EIYQQJ6h59o+fMJnKcbfSGDoAD5y8e9t4zo2JZFhUKDfecAMffPABH3zwAX369KGqqor333+ff/7zn539EoQQQhyPmiLITYcqG/6l25g6PpaQkBBGTZhK6ehbcAb2wptG/ua1lChnLlUhw5nz7D9455133NlfXV3N//73Px577DFUVe3sVySEOM2kQ04AkJWVhaqqvPnmmwwaNIiMjAzuvPNOqqureemllwDX1uXnn38+5557Lm+88QZbtmzhjjvuIDg4mNmzZ3fyK+iadDodAHU6b9L9J1BXW43Rz5MPZ1kYaj4Pu/0mTCaT64yYqlJrHk3u5s2kF+hYtmsLN9rtMktCCCG6GZ1Oh1PvzY+OYRSrfgR46Xn/jgmMiQ4mcYoXjVE+eAzwRjGbUYFx48axZcsWDAYDGRkZ2CX7hRCi6/MNg6jxkJuO1nscNbvraPQM5PvGGKo0L8L9Pfhw5iSWvLWJb3blMsKSyDS9AbPZjKqqkv1CCCnICZcLLriACy64wP39gAED2L59O//5z3/cBblFixbR0NDAO++8g6enJ7GxsWzcuJF58+ZJQa4V7suWqhr5rLwvjXXVRAZ58+EsCwNN/gAtD7qKgt8Fj7NqXQPLdm0hwSKzJIQQoltRVex7M1m+JpX9Ay/HqfoR4mNg0Z0TiOkVCFWFKHnr8Gosg7x1UFOE4h9OcnIyABkZGTJHSAghugtFgckPolYVkrG3gJ9TnyF38O9RNS+igrxY8seJeDRUkpqWRkFhFbVpae6im6Iokv1CCCnIibaVl5cTGhrq/n7t2rVMmTIFT09P989mzJjBCy+8QGlpKSEhIUc8R319PfX19e7vKyoqOnbRXYjRaKRS86J83DUoXkFEh/iw+M5EokN923yMojfwl0ef48aDOzTJLAkhRHd0Rma/qqKu+Dv7ly2lfPgtOL0i8aGRJbMnMTQy0HWfZt0URI13fQ8YDAbmzp3r3p1Psl8I0R2didmvAs++8hYffPED9WfdheIdRJCulv/ddTYRwb6oqjcWiwWr1XrEhj2S/UIIKciJVu3atYt//etf7u44gIKCAvr379/ifk0dXgUFBa0W5ObOnctTTz3VsYvtotbvzOPA8GtRPPzxrCvl31eNpHewNzab7agHXUVRpF1dCNGtnZHZX1NEwY71/K3uNoq8euPRWMU7dyQwNDIIVVUPfeCa/KBr7pBvmKu74iDJfiFEd3cmZr/dbufntEzqJ/0JxTcYj2o7i++dfrAY58r+OXPmUFxc3Or7f8l+Ic5sUobv4R5++GF0Ot1R/2VlZbV4TF5eHhdccAFXX301d9555yn9/jlz5lBeXu7+l5OTc0rP113stFVy92c7cXj441VXwu9DchjeN5Lk5GRmzpxJcnKyDG4VQvRYZ2L2250B3Fp4Dft0vQlQK7g0YB+W4X1RVbVl9gP4h7coxgkhRE9wJmZ/kcOLwtjrUXyD0ZXlcZUxj+EDolpk/9y5c6UDTgjRKumQ6+EeeOABbrvttqPeZ8CAAe7/PnDgAGeffTYTJ07krbfeanG/iIgIbDZbi581fR8REdHqc3t5eeHl5XUSK+++tuVXcNMCK8XVDQyLCOCVy0YxpG+vQzPlCgqwWq0yuFUI0WOdadlfWFnHDW+nsqvKm4gAD/51ZSLjhl6LoijYbDbJfiHEGeFMy/6MvHJuejuVOjwYFu7LK3+4kCF9e0v2CyGOmxTkejiTyXTcA0Lz8vI4++yzGTduHO++++4RZ3EmTJhAUlISjY2NeHh4APDTTz8xdOjQVi9X7WlaXHLUyhkuVVVZmbGPez/fRVltI3G9A/ngDgshfq6ZeyaTqc0ZEkIIIbqmY2W/rbyWa99cw76SOiKDvPnozkT6hfm5b5fsF0KI7udY2b85p5QbF1iprHcyOjqYhXckEOTj4b5dsl8IcTx0mqZpnb0I0fny8vKYNm0affv2ZeHChej1evdtTd1v5eXlDB06lPPPP5+HHnqIjIwM7rjjDl5++eXj3mW1oqKCoKAgysvLCQwM7JDX0hGa2s6bDqpJSUktDs6qqnLf0/P4qnoAqt6LUVFBvD/T0uLA3HQ/GdwqhDjT9NTst1fUct7cbyjTfPDTNfD1/efS3xTQ6vNI9gshzjQ9Nfszcsu48rXlNGAgXKnip0cvJ8j3yM5AyX4hxLFIh5wAXJ1uu3btYteuXURFRbW4ralmGxQUxI8//sjdd9/NuHHjCAsL4/HHHz/uYlx3dqzLTVdk7HMX43xqCph36ZgjinEgg1uFEKI7OVr2l1Y3cP1baynTfFDqyumV/TW+6kTgyIKcZL8QQnQfR8v+bfkV3LjASgMGDGXZGA/8SF3lNIJ8j8x4yX4hxLFIqV4AcNttt6FpWqv/mhs5ciQrV66krq6O3NxcHnrooU5a8enV1HYeERFxRNv55uwS/vzpdlS9F77V+VwVVkD/qNZn6gkhhOg+2sr+8ppGblyQwq6iWnxoYGD2N0wZM1wuSRJCiB6grezfXlDJDfNTKK9zEKarYvCBn5gYP1ayXwhx0uSSVXFaddfWdWi97XxzdgnX/3sZ1XgzUJfPm7PPZ0DfKGlLF0KIZnpS9lfUNXLj/BS25FWg1VYQvfNTPp7/KpGRkZL9QgjRTE/K/p22Sq59ay0l1Y047XsZkP0Ni99bINkvhDglcsmqEMfp8LZz185KVqrxZhQ7eFF9hSDNgqL06cRVCiGEaE/Ns7+q3sHt76SyJa8CtbYC51ePsbOqnNLSUnr37t3JKxVCCNFemmf/rsIqrp+fQkl1Iw223dj/+xh1vp6S/UKIUyblfCFaoaoqNpsNVVVbvb2pGFdRrxKn28Ob+r9j9NFhNBpP80qFEEK0l6Nlf22DkzveS2NddhmKo44r9jzH/AkFPDsjhGFDh3TCaoUQQrSHo2X/vqJqbpifQlFVA161doo/fRJnbSW+vr4MGSLZL4Q4NVKQE+IwTTsrzZw5k+Tk5CMOzpl5Zdwwfy1lNY2YlCouK3qPCiWYkKl/QAmQ2XFCCNEdHS37Gxwqf/wwndS9Jfh7GRi6+2MuMubSz+THHeePwFBf1nkLF0IIcdKOlv15ZbXcsCCFwsp6hpr9MW5eDPXV+Pj4EBsbS2lpaSeuXAjRE0hBTojDtLazUpMdBRX8/l+/UVHnJFSrwLhlCW9tgKe3RFE0/DaQGRJCCNEttZX9DqfKnz9az/IdRejURqbVrUJfX8GOmkCqNB9qQmPBN6yTVy+EEOJktJX9hZV13Dg/hQNldXjWl9Jnz1ICvRRCQkLw8/NjxIgRspmDEOKUyQw5IQ7TtLOS1WptsbPS3oMt63V4oK84QHjOt4yKGUKm1sjQcRZM4bKtuRBCdFetZb+qajz86Wa+z7Rh0Br5W92/GK3bTemYgby+KZYG40jGX/C4nIwRQohuqrXsL61u4KYFVvYV16BWFmH77AmWOmsYOnQoY8eOZcSIESQnJ8tmDkKIUya7rIrTqrvstnT4zko5JTVc8+Za8svrCNHVEp65mNHDB/PMM89QWlraYudVIYQQLXXH7NfpdDz11VbeW7MPPSrJHu8ww7mCWn0g5iHjKJn0FMa+wyX7hRCiDd0m+50OirO3Y+wzlOpGjRsXWNmcW46hsZqqpU9Tkr2D0NBQxo0bxwsvvEBMTIxkvxCiXUiSCNFM01BXALPZjKIoHCir5fr5KeSX1zHQ5Mf3D13I6OGDycjI4IUXXsBoNGK329vcAEIIIUTX1lr2z/tpB++t2QfAiyMPcM0QhSJ9OLkVGst3V+PwCu68BQshhDhlqqpiK8iHlf/AtOYp6pe/zMz30ticW06orwfX+m8jUFeHv78/AQEBJCQkyAZuQoh2JZesCsGhA/Li+f/kt7QMEiyJJCUlUVTVwA3zU8gtraWf0ZfFdyZCbTmZmZkUFBSwfPlyKisr2bp1KxaLhaSkJDljJoQQ3YSqquTn5/Pqq6+SmZlJYqIr+xes2su/ft0FwNOXxfJ7y4XY90/igY//Sk1xLvsKt9Nv1a1MnTpVcl8IIbqZ5tmft30DT4wpom9EMH/YG0RqVSkB3gbeH53FoKJ1DJrkyWub+hIcEkphYSGzZs1yHysk+4UQp0oKcuKMp6oqzzz9NL12L2aMVwk+/gF8Z4Wd2Qe4+7Pd7CuuITLQkw9nJmAO9Eb19yQ+Pp7FixdTVlZGTk4OAQEB7kGwZrPMkhNCiK5OVVWeeuop3nvvPYqKiggKCgLgnd+28dyP+wC466ze3GTpA4qCse9wxsVbeP/97dhshdTU1uHl5SW5L4QQ3YjqdPDS0w/z7/f+i72omOCgQM43mXjF4wpWVPXG11PPyzPCiN29ABrLOauvFz+XhJFdUscnn3yCh4cHgGS/EKJdSFlfnPFsNhvff/YBvdQDBOrrGOZfyYTxo3jgy73sKqzCT9dAQNo7vPv6PBwOB3a7nVmzZtGnTx+Cg4MBCAkJabEBhBBCiK7NZrPxwQcfkJOTQ21tLeXl5YTETmHuz/sBGOFhY+Wbj5KcnNwi+/v3709QUBBOp5O4uDjJfSGE6C5UlarvnmJ87nvc3LeQ+tpaPBor+NB4N99WDsRDr2OKksWryY/z2+5qND8TEeMv5qGn/05AQAAeHh44HA7JfiFEu5EOOSE0FdXpJDXPiaW3nn16M9bQ88k4UEGIj4GwTR9RnL2D5ZV29+WpCQkJTJo0ibS0NOLj45k9e7Z77pAQQoiuT1VVnE4nmqah0+kIG2Yh1WMETqfGRTFG9n78b/Jyc1FVlaSkJDIzM0lISGDy5Ml4eXkRFxcnu+wJIUR3UlOEh20TRh8VS5TCs2d7ciDmOr7URaHTwZMz+rP4hdfJzc3lJbUXq2oiSc1cT3yCBxaLBZ1OJ9kvhGhXUpATZzZVxbzjQz64OohfM2pJ3hoEFyaRd6CaAG8DH8y08OnbKSzOTGtxeWpqairz58/nj3/8o+ywKoQQ3YmqolYV8vaCBXh6ehIYGEhI/zg8z7uXBqfG9GHhvHTtKC5eWEdBQQGBgYFkZGRgs9kk+4UQoptSVRVbRSPbchqgTs+Ocg8qh83gS78rAXj6/GiunTiYd+oOZX9Kxh7JfiFEh5KCnDiz1RSh5KYz2L+OvuP8SY+fw8+lQfh46Hnv9njiooIxzp7NqlWrKCkpoaqqyn15qnTECSFEN6OqsPIlGnevYnjeLmqrK/EMicDr/Pupx8C4viG8fsNYKkqL8Pb2JjIykoCAAOLi4tDpdJL9QgjRDamqSnJyMsuXL2ff3j14qwrFpol4x90CwF8CfuVmXTi2IpNkvxDitJKCnDiz+Yahhg/HmbOOR+pu5uf6cDz1OubfMp5xfUMBMJvNTJkyBavVKpenCiFEd1ZTBDlpeJZs54KIMnYlePJG5N+oV7wZYPTm7VvH4+Opx8tkIjExEavVisViYc6cORQXF0tnhBBCdEN2u52UlBS2bt1KeXk5HtEjCJr6RzSdjhuDNnNvSDrkmTGNvVWyXwhxWklBTpzRVODZNXq2l13Lau8E9DqN164fy6TBYe77KIpCUlISdrtdDshCCNGd+YaBOQYOrKcaH34adD86QwR+ugY+mDWNYF9PoPXcl930hBCiezKZTMTFxZGelkp43wE4L3gQnd5Af30JTyUq6A6YIWo8in+4ZL8Q4rSSgpw4s6iqq0PCNwwUBbvdztf7VQrNk0DTePyC/pwfF3nEw+SALIQQ3Zeqqoc+YE1/jPLKau63hrDHMBAftZoFt4yjd4hfi8dI7gshRPfWPPuTn32G4c5M5umup0LvA7Ys3nnqGgxRvVt8NlBAsl8IcdpIq484cxycHcTSe1xfVZUfdtdQaE4AYIJXDjdPGd7JixRCCNGemmYHzZw5k+TkZJzoeLHxatboRuOpNfCc94dY+vgd+4mEEEJ0G4dnf0VJIQt9rqNCH0zvxv1EbH4Xbw8DKAr4h7u+CiHEaSYdcuLMUVMEuelQWQD7VvO198U88dVeAGYlRvLIpRfK5ahCCNHD2O12rFYr+fn5rFixAs9RF7N4QxE6NP7R6zcuGnUWin94Zy9TCCFEO2qe/b+tXE1a4GT2NoYQRhnXlL1P+aVXSyecEKLTSUFOnDl8w6D3ONj8X1ZURHBf1m40TeGWCX1JujQWnU7X2SsUQgjRzkwmE/Hx8SxevJjy4CH8Z80BAB67KIZLxiS4L1MSQgjRczRl/6LFH1Ea83vU/GoCvA18cNNEQv2nYwqXDdqEEJ1PCnLizNA0O27MzWzI2skf8y+iUVO4OCaUJy+RYpwQQvRETfODZs2axY8b95E3+HIAbhhr5o7JAzp3cUIIITpE8+z/fJ9CmXkUOtXJCxcPYfig/p29PCGEcJOCnOj5mmbH5aazK2git+ddQo1mYLKxinnXzUBRpBgnhBA9TdP8IKvVyuDxU7APvRww0F9fytNXXtDZyxNCCNEBmme/75iLKTOPBWCqTzYXjL24k1cnhBAtSUFO9HhqVSGNu1dTXOvglqxIyhoNjOrlxxt3noenp/wJCCFET2Sz2VixYgUl1Q3srIymwcOV/Uv+cD4Gg76zlyeEEKIDNGV/gT6cyoYo0MHdk3rzwO9kVrQQouuRVBI9mqqqJL/yFgtTDnBD7pUcaPRnQJgf786ciJ+PZ2cvTwghRAdQVZW33nqL7NwDGOKvot4jkH76IhYOS8fHQ4pxQgjREzVl/95yJxWxvwedDmXPamrWfdnZSxNCiFZJQU70aHa7nbVp6/i77lb2aREYfQ0svCOBUD8pxgkhRE9lt9tJTUvDY8LN2HwGEEwV7/r8k+CCla55okIIIXocu93Omg1bcU6chc7Di8bsTZT89AarVq3Ebrd39vKEEOIIUpATbpdeeil9+vTB29ubyMhIbr75Zg4cONDiPps3b2by5Ml4e3sTHR3Niy++2EmrPT5GYxi1I6+mMaQ/HjhZeIeF6FDfzl6WEEKIDmQymTCMuZyq8BHocfKGcQn9A4E+E127qgohhOhxfANDsMdcheYdhEdNEb4bl2AONzF58mRMJlNnL08IIY4gA7SE29lnn80jjzxCZGQkeXl5PPjgg1x11VWsWbMGgIqKCs4//3zOPfdc3njjDbZs2cIdd9xBcHAws2fP7uTVH0nTNJK/y2KvMwSDouPd2ycQFxXc2csSQgjRwT7fcIBNjZEAPP/7USQO+w9ogH84yAwhIYTocZyqxn3/3USJ6kuIr4HPH7gSrznnA2A2m2V+nBCiS5KCnHC777773P/dt29fHn74YS6//HIaGxvx8PBg0aJFNDQ08M477+Dp6UlsbCwbN25k3rx5XbIg99aKPby7eh8AL109ksGBKqqqygFZCCF6MOueYh7+bDMAd00dwJQ+3qh+Jsl+IYTowZ77dhs/byvE06Cw4Jbx+Kg1mKQQJ4To4iShRKtKSkpYtGgREydOxMPDA4C1a9cyZcoUPD0PzV+bMWMG27dvp7S0tNXnqa+vp6KiosW/02HpxjzmfpcFwCMXDmPL1+8yc+ZMkpOTUVX1tKxBCCHOVJ2V/fvslfzhgzQanRoXxkVQn/Y/yX4hhDhNOiv7P1y7j7dX7QXgpatG8u0H/5bsF0J0C1KQEy089NBD+Pn5YTQayc7OZunSpe7bCgoKMJvNLe7f9H1BQUGrzzd37lyCgoLc/6Kjoztu8Qet3V3Mg59sAmDmpP5cNswfq9VKQUEBVqtVhroKIUQH64zsr6ipZ+YbP1FW62RUUA0PT40gNVWyXwghTpfOyP41u+w8tjQDgHEeB4g3K/K+XwjRbUhBrod7+OGH0el0R/2XlZXlvv9f//pXNmzYwI8//oher+eWW25B07ST/v1z5syhvLzc/S8nJ6c9XlabdhVW8ocP0ml0avxuRARJvxuOyWTCYrEQERGBxWKRoa5CCNHBTnf2O1WNexensbvai0h9BfMjvyY6SC/ZL4QQp9Hpzv6ckhru+nA9Gjq88jdTt8HVSCDZL4ToLmSGXA/3wAMPcNtttx31PgMGDHD/d1hYGGFhYQwZMoThw4cTHR1NSkoKEyZMICIiApvN1uKxTd9HRES0+txeXl54eXmd2os4TvbKem57N42KOgdj+wTz0lUjsdsLMZlMJCUlYbfbMZlkjpAQQnS005n9AH//YTvLdpXjpai82W85Pqa+4Bcm2S+EEKdRh2a/qkJNkWunbEWhqt7BrIXplNc5CFOqMRWvJS42Vt73i/9n777DojrTPo5/5wy9wzAMCNgLAlYENJZYkpiyiW7KpldLzKasMdkkBE1TZNOTfTdlo6ZuTO/NFGNXqiUCYleKMAy9l5lz3j+QiSh2pej9uS6uXZh2Zi7zO3Pu53nuR4guRRLqHGc0GgkLCzvmz6E94Q7V0nOhoaEBgFGjRrF69Wqamprs9/n1118ZMGAAvr6+Z//NHENto5Vp76WSV1ZHT4Mbb90axYvP/cvePwJkhyUhhDgXfb0pnzdX7Qbg2WuH8luBDze9kU7CwkRAsl8IIbo8VYU1L8A398GaF1CtNuZ8spnt5iqMns589dDlDI4YSEZGBomJkv1CiK5DUkoAkJyczH/+8x82b97M/v37+f3337nxxhvp06cPo0aNAuCmm27CycmJadOmkZmZySeffMKrr77KnDlzOvTYbarGAx9t5o+8CrxdHHj7jhHYaiukf4QQQpzjtuSW88gXf+6oOirYid9TMigoNEv2CyHEuaK2GPLSoNoMeWm8suwPfsky46jX8ebNw3Cy1pCZmYnZLNkvhOhapCAnAHBzc+PLL79k0qRJDBgwgGnTpjF48GBWrVpln3ru7e3NL7/8wt69e4mKiuKhhx7iiSeeYObMmR167PO/z+K3bWb0qBgyP+XDN1/BYDBI/wghhDiHFZbXMu3dFBqtKp6V+2hI/VyyXwghzkVu/hAyAjxMfK+fwL/XHgAgYP9yfvzgdcl+IUSXpdNOp2O/ECepsrISb29vKioq8PLyOvknOKx/xNtr9/LM91kAPNi4GKcDm1lf35cX3nwfY4BJ+kcIIUQncLrZr6pqqzyva2hi3NNfYVHd0VUW4pO6GH8fD95//31MJsl+IYToDM5o9gMZu/cxdUkGVvTod67Ee+9yDAaDZL8QosuStBJdh6qirn6ehk9noK5+nuVZhcz/obkYFxeYynVemVzZo5anhhZizH4fBekfIYQQXZ2qqixYsIBbbrmFBQsWYLPZePiT9OZiXFMtDhuWUFlaRE5ODosWLQIk+4UQoqs7PPtLahuZ8dlurOhxLN6JkvEdFRUVkv1CiC5NdlkVXYZaXcSulR+jqzGzd18tDzIYTYMbo0OZaciE/WHYivegd/dFl5/ePJPOI6CjD1sIIcRpMJvNfPjhhxQWFrJnzx78YqbwQ1YJOjR65P1G9EWjSU5OpqamhpSUFCwWCyaTqaMPWwghxGk4NPt379nLVsN4Ciob8dTVE1K0msirrpTsF0J0eVKQE12GpVYjOb+JcC8X5jbcSo1OZXQfA89MjURHODRW4VCeB401EBzVvKxVCCFEl6dpGvX19ZTovHlpRQ7oFB69NIwpA6J48803MZvNAMTExEjvICGEOEe0ZH91r/Gk5lbh6qjnk3suwld3gWS/EOKcIHN6RZdhDDBxIPhKHtU/RJHOQG+nCl6f2h1HvQJ1pWDZDs4e4B0CUbeDTFkXQoiuTVUxueuYOuUqvE2heF/+EKpOYVI/X+6+sA+KopCeno6Hhwfdu3dnxowZslxJCCG6OFVVQVO5acpF+A0aj9uIvwLw+MU9CO/mLdkvhDhnSHKJLkTHvr7XsEvpia++nndGmvE2BDbf1LL7kmcg9BwN7rJUVQghujRVhTUvoHz3AE9faqT7jc+gc/PBR1fHKzeNQKfTYTQaiY2NJSgoiHHjxslyJSGE6OJUVSVhwQJ+e/JSxrjuwOuiWQBEOpi5ecwAAMl+IcQ5Q5asii7jpV938FOGGUe9jjdvGkqPgX/9cxacosDYh1vtwCqEEKILqy2GvDSoNvPsRj3FOm/cnfR8ft9kPF2dAFAUhfj41aHm4gAAwhRJREFUeNlZTwghzhEWi4XtG9cSG1TN0w3/oEHnRFQ3Fz665zZ7xkv2CyHOFVKQE13CF+l5/GfFLgD+dfVgYiNCjryTosgmDkIIca44OPP5y62lvFsyEIBXbhhG3wDPVndTFEVmRwghxDnCaDTSf9gYXi6fRK4uiEDnJv57x0ScHFtftkr2CyHOBTKcILqELXnlANw7oQ/XRLVRjBNCCHFuURQy+swgrnAcAA9M6sfF4XLxJYQQ5zJFUTCMu5FtzpE46XW8cdc4/L1cO/qwhBDirJAZcqJLePqqCMb09eeigXIxJoQQ5wNN05j3bRYNVo0JA4zMntSvow9JCCHEWaaqGmn7ygB4ekokw3r4dfARCSHE2aPTNE3r6IMQ54/Kykq8vb2pqKjAy8urow9HCCFEOzjV7DdX1pPwwzbmT4nE283xLB6hEEKIM+1Us9+mavy2zczkiMCzeHRCCNHxZIacEEIIITolk5cL/75xWEcfhhBCiHakV3RSjBNCnBekh5wQQgghhBBCCCGEEO1ICnJCCCGEEEIIIYQQQrQjKcgJIYQQQgghhBBCCNGOpCAnhBBCCCGEEEIIIUQ7koKcEEIIIYQQQgghhBDtSApyQgghhBBCCCGEEEK0IynICSGEEEIIIYQQQgjRjqQgJ4QQQgghhBBCCCFEO5KCnBBCCCGEEEIIIYQQ7cihow9AnF80TQOgsrKyg49ECCHan6enJzqdrqMPo91J9gshzmeS/ZL9Qojzz4lkvxTkRLuqqqoCIDQ0tIOPRAgh2l9FRQVeXl4dfRjtTrJfCHE+k+yX7BdCnH9OJPt1WsvQhRDtQFVVDhw4cFIjhZWVlYSGhpKbm3tefpk5EfIZHZ98Rscnn9Hxne5ndL7OkpDsPzvkMzo++YyOTz6j45PsPzWS/WeHfEbHJ5/R8clndGxn4vORGXKi01EUhZCQkFN6rJeXl4TFcchndHzyGR2ffEbHJ5/RyZHsP7vkMzo++YyOTz6j45PP6ORI9p9d8hkdn3xGxyef0bGd7c9HNnUQQgghhBBCCCGEEKIdSUFOCCGEEEIIIYQQQoh2JAU50ek5Ozvz5JNP4uzs3NGH0mnJZ3R88hkdn3xGxyefUfuRz/r45DM6PvmMjk8+o+OTz6j9yGd9fPIZHZ98Rscnn9GxtdfnI5s6CCGEEEIIIYQQQgjRjmSGnBBCCCGEEEIIIYQQ7UgKckIIIYQQQgghhBBCtCMpyAkhhBBCCCGEEEII0Y6kICeEEEIIIYQQQgghRDuSgpwQQgghhBBCCCGEEO1ICnJCCCGEEEIIIYQQQrQjKcgJIYQQQgghhBBCCNGOpCAnhBBCCCGEEEIIIUQ7koKcEEIIIYQQQgghhBDtSApyQgghhBBCCCGEEEK0IynICSGEEEIIIYQQQgjRjqQgJ4QQQgghhBBCCCFEO5KCnBBCCCGEEEIIIYQQ7UgKckIIIYQQQgghhBBCtCMpyAkhhBBCCCGEEEII0Y6kICeEEEIIIYQQQgghRDuSgpwQQgghhBBCCCGEEO1ICnJCCCGEEEIIIYQQQrQjKcgJIYQQQgghhBBCCNGOpCAnhBBCCCGEEEIIIUQ7koKcEEIIIYQQQgghhBDtSApyQgghhBBCCCGEEEK0IynICSGEEEIIIYQQQgjRjqQgJ4QQQgghhBBCCCFEO5KCnBBCCCGEEEIIIYQQ7UgKckIIIYQQQgghhBBCtCMpyAkhhBBCCCGEEEII0Y6kICeEEEIIIYQQQgghRDuSgpwQQgghhBBCCCGEEO1ICnJCCCGEEEIIIYQQQrQjKcgJIYQQQgghhBBCCNGOpCAnhBBCCCGEEEIIIUQ7koKcEEIIIYQQQgghhBDtSApyQgghhBBCCCGEEEK0IynIiXalaRqVlZVomtbRhyKEEKKdSPYLIcT5R7JfCCGOTQpywi4xMZHo6Gg8PT0JCAhg6tSpbN++vdV96uvruffeezEYDHh4eHDNNddgNptP+DWqqqrw9vamqqrqTB++EEKITkqyXwghzj+S/UIIcWxSkBN2q1at4t577yUpKYlff/2VpqYmLrnkEmpqauz3efDBB/nuu+/47LPPWLVqFQcOHODqq6/uwKM+e/bt24dOp2Pz5s0dfShCCCHaiWS/EEKcfyT7hRAdQQpywm7ZsmXccccdREREMGTIEN59911ycnJIT08HoKKigiVLlvDSSy8xceJEoqKieOedd1i/fj1JSUntfryFhYXcf//99O7dG2dnZ0JDQ7nyyitZvnx5ux/LsWiaxgsvvED//v1xdnYmODiYhISEjj4sIYTokrpC9j/11FPodLojftzd3Tv60IQQokvqCtkP8PPPPzNy5Eg8PT0xGo1cc8017Nu3r6MPSwjRSTl09AGIzquiogIAPz8/ANLT02lqauKiiy6y3ycsLIzu3buzYcMGRo4cecRzNDQ00NDQYP+9srLyjBzbvn37GD16ND4+Pjz//PMMGjSIpqYmfv75Z+69916ys7PPyOucCf/4xz/45ZdfeOGFFxg0aBClpaWUlpZ29GEJIcRZc75n/8MPP8ysWbNa/W3SpElER0d30BEJIcTZd75n/969e5kyZQpz5szhww8/pKKiggcffJCrr76ajRs3dvThCSE6I02INthsNu2KK67QRo8ebf/bhx9+qDk5OR1x3+joaO2RRx5p83mefPJJDTjip6Ki4rSO77LLLtOCg4O16urqI24rKyvTNE3T7rzzTu2KK65odVtjY6NmNBq1xYsXa5rW/D6fffZZrU+fPpqTk5MWGhqqLViwQNM0Tdu7d68GaJs2bbI/fuvWrdqll16qubu7awEBAdott9yiWSyWox5nVlaW5uDgoGVnZ5/W+xVCiK7kfM/+w23evFkDtNWrV5/kOxZCiK7jfM/+zz77THNwcNBsNpv9b99++62m0+m0xsbGU337QohzmCxZFW269957ycjI4OOPPz6t54mLi6OiosL+k5ube9rHVlpayrJly7j33nvbXP7j4+MDwPTp01m2bBkFBQX2277//ntqa2u5/vrr7cf3r3/9i3nz5pGVlcXSpUsxmUxtvm55eTkTJ05k2LBhpKWlsWzZMsxmM3/729+OeqzfffcdvXv35vvvv6dXr1707NmT6dOnyww5IcQ57XzP/sMtXryY/v37M3bs2JN4x0II0bWc79kfFRWFoii888472Gw2Kioq+OCDD7joootwdHQ8jU9BCHHO6uiKoOh87r33Xi0kJETbs2dPq78vX75cA+wjUS26d++uvfTSSyf03BUVFac9UpacnKwB2pdffnnc+4aHh2vPPvus/fcrr7xSu+OOOzRN07TKykrN2dlZW7RoUZuPPXykbP78+doll1zS6j65ubkaoG3fvr3N57j77rs1Z2dnLTY2Vlu9erW2YsUKbejQodqECRNO5K0KIcQ54XzL/kPV1dVpvr6+rY5HCCHOB+dj9q9cuVILCAjQ9Hq9BmijRo064tpJCCFayAw5YadpGvfddx9fffUVv//+O7169Wp1e1RUFI6Ojq2ap27fvp2cnBxGjRrVrsd5oqZPn84777wDgNls5qeffuKuu+4CYNu2bTQ0NDBp0qQTeq4tW7awYsUKPDw87D9hYWEA7N69u83HqKpKQ0MD77//PmPHjmX8+PEsWbKEFStWsH379hN+H0IIcb7rStl/qK+++oqqqipuv/32Ez5+IYQQzbpS9hcWFjJjxgxuv/12UlNTWbVqFU5OTlx77bUn9T6EEOcP2dRB2N17770sXbqUb775Bk9PTwoLCwHw9vbG1dUVb29vpk2bxpw5c/Dz88PLy4v777+fUaNGtbmhw9nSr18/dDrdCTVwve2223jsscfYsGED69evp1evXvYlQ66urif1utXV1Vx55ZU8++yzR9wWFBTU5mOCgoJwcHCgf//+9r8NHDgQgJycHAYMGHBSxyCEEOerrpT9h1q8eDF/+ctfjrosSgghxNF1pex/7bXX8Pb25rnnnrP/7X//+x+hoaEkJye36/WSEKJrkBlywu6NN96goqKC8ePHExQUZP/55JNP7Pd5+eWX+ctf/sI111zDuHHjCAwM5Msvv2zX4/Tz82Py5Mm89tpr1NTUHHF7eXm5/f8bDAamTp3KO++8w7vvvsudd95pv61fv364urqe8Hbpw4cPJzMzk549e9K3b99WP231tAAYPXo0Vqu11Ujajh07AOjRo8cJva4Q4sxTVRWz2Yyqqh19KOIEdaXsb7F3715WrFjBtGnTTuxNCiHOKsn+rqcrZX9tbS2K0vryWq/XA8i/OSE6yOnkfqNVpcFqOwtHdYgOXTArzjtnopeEpmna7t27tcDAQC08PFz7/PPPtR07dmhZWVnaq6++qoWFhbW67y+//KI5OTlper1ey8/Pb3XbU089pfn6+mrvvfeetmvXLm3Dhg32nZgO7yWRn5+vGY1G7dprr9VSUlK0Xbt2acuWLdPuuOMOzWq1tnmcNptNGz58uDZu3Dht48aNWlpamhYbG6tdfPHFp/X+hRAnx2azaYWFhZrNZtNsNpv2zDPPaFdccYX2zDPPtNoNTZwd51v2t5g7d67WrVu3495PCHF2SPZ3rPMt+5cvX67pdDrt6aef1nbs2KGlp6drkydP1nr06KHV1tae1mcghDhxLdnf1NR00rnf0GTTfs82aw9/ulkb/NTP2qepOWf1WGXJquiSevfuzcaNG0lISOChhx6ioKAAo9FIVFQUb7zxRqv7XnTRRQQFBREREUG3bt1a3TZv3jwcHBx44oknOHDgAEFBQcyaNavN1+zWrRvr1q3j0Ucf5ZJLLqGhoYEePXpw6aWXHjEa1kJRFL777jvuv/9+xo0bh7u7O5dddhkvvvjimfkghBDHpaoqCQkJJCcnExsby/Tp00lOTqawsJDk5GQsFssJLSfUNI0d5mqcHRR6+h97ZpQ4O7pK9kPzv7t3332XO+64wz5DQgjRfs5U9ouO11Wyf+LEiSxdupTnnnuO5557Djc3N0aNGsWyZctOesmsEOLUHJr9ERERZGRkYDabj5n7jVaVdbuL+fGPAn7OLKSy3mq/bc3OYq4bEXrWjlenadJhUrSfyspKvL29qaiowMvLq11es7q6muDgYN555x2uvvrqdnlNIUTnYTabmTZtGoWFhQQGBrJo0SIWL15McnIy0dHRzJw5E6PRSElJCUajsdUX7SabSureUn7dZua3bWZyS+u4dWQP5k+N7MB31PVI9gsh2tvpZH9bNE1Dp9O109GfGyT7hRDt7dDsN5lMREZGkpmZSWxsLHFxcZSUlGAwGDAXWdhZqfDD1kJ+yTJTUddkfw5/D2cuiwzkisFBRPf0Q6+cveyXGXLinKWqKsXFxbz44ov4+Phw1VVXdfQhCSFOkKqqWCyWE7pIOh6DwUBERASaphEbG4vJZCI+Ph6z2cyiRYuYPn069fX1uLi4MHLkSO6f8wird5XwW5aZFduLqDpklMzZQcEqfWA6Ncl+Ibqujsz++Pj4Vq+pqhqZBypZnm3m9+wiro8O5eZY6f/bWUn2C9F1na3sHzly5J9FOD9fXkmYy/dZpZR49KbWtx82Bxf744yezUW4ywed/SLcoaQgJ85ZOTk59OrVi5CQEN59910cHOSfuxBdweHLjA6/SDrZ50pcuJC87I0MihxGXFyc/bkURSElJYX8/HwKK+vxibiQfWYj7yYsx6b+OXnc4O7EpIEBXDTQxJh+/rg5SZZ0ZpL9QnRNZzr7ExISSE9PZ/jw4UfN/oKCAgIDA+1LmTx8DKzbVczv2UX8nl1EUVWD/TkN7k5SkOvEJPuF6JrOdvbrFD17qxRe/Oh/LKsdSmUvT/v99dZapkb14LrYPu1ahDuUJJU4Z/Xs2RNZkS1E12OxWM5Ynx9LkZmeuZ8xvlsx+0oLKSl+EFNgEJqmUWJzwWnYFOr7OODiGkB9y4NUjZ5+Llw6qBsXhwcyNNTnzxO0qkJ1Ebj5w2mO4ImzQ7JfiK7pTGa/2Wxm6dKlFBYWkpebw0N334qpVwQoCkajkdjYWDRNw2AwoPcw4DVkAo/8sI8Nu9NptP2ZH+5Oesb2MzIhzMggg4Kqqqc9e0OcHZL9QnRNZyv791XrqPtgHckHmg4OrphAB55aFS4lu3CrzGFCRAh3jx+DyeSLclgx7kzO2jsWKcgJIYToVFoullpGyoxG46k/l5uO2GAHdDUK/m6O7C2u5q20TJZtLSC/ogHoBq6g08HgIA8uG9yNXau+Inv1apoaYhk2Of7PE7SqwpoXIC8NQkbA2IelKCeEEGfImcz+FooOZkXU4L0qHjV3NJaw2/A3BnDVHfehG3QF6/dXk1VQxY5GYEcxAJ66Bq4Z2Z9J4SZievnhqOhISEjggzMwe0MIIURrZyr7NU1jh6UWa8QVeE0ajNXLyHfbqwHwdNZzqX8xf3FIZXCoN56XPI5l/3ZefusDpk+ffkTbgjM5a+94pCAnhBCiU2gZiTIYDEyfPp3p06djMplO6wTY5GIgN2I6P+2sZ0V9X0r+t8N+mx6VCQMDuSQ8kIkDA/BzcyQrK4vvUlbZd2Mym80oB2dUKLXFzcW4anPz/9YWg0fAmXjrQghx3job2W8ymbj55pvZmvQ7lw8uh4ZKlv6azH+W2qgyDKRGc7LfV4fGEOdCjKWbSftjF0Eeeq69+VnC+xhQFMV+PpDdWYUQ4sw5U9m/t7iGbzcf4Nst+ey21ED/SegBR7WeaOtmDOYUthWpeI0dy9jZcSju/qhrXqT8tw8Izs5j6abmPnKHfuc/k7P2jkcKckIIIU7Y2Zq+raoq8+fPZ82aNaiqiqurq3206mRfs6bByqodFpZlFPJ7dhHVDT3ttzlqTdTtTkXL20yY0YGEB9/CZDJhtVqJi4sjIyODuro6fHx8iIqKYtGiRaSkpDSPjj0ehxIy4s8Zcm7+Z+z9CyFEZ9be2R8XF3dar6coCg889Cjfpl7DK5s3s2K/C3W4gB+ggaujwrj+Rib2cKb7LzPwr8mlGIUy116U1jnw6KOP2s9BZ2PmnhBCdAWdNfvNlfV8t+UA3245wB95Ffa/OzkojO9vZHyQjci190HJHvKVRlbudifJyQlL3d2YlFIadq3FpyGPG8JsWJuq2dOjO2+99Rapqan23VjbK/elICeEEOKEnM3p2y09HwoKClBVld69e6PT6TCbzSxevPior9nyRcHZw4fft1v4KaOQ1TssNFj/3Ak1wNOZyRGBjAhy5OHbplC8fx8ODg4M/vvfMRqNWK1WZs+ezaeffoqDgwMeHh4EBZrQ15WQkrmHvPwDaJqGpbgE09iHm2fGSQ85IcR5or2zHyA+Pp7MzMyjvt7RLhLNlfX8kmXml8xCNuwuwapqgA8Atpoymvalc9FAE4vmPoSjXseDs/9Bt907GBEIGeUu5JXVYykuwdvbm9WrVzN9+nSCgoKIj49vl15CQgjRWXS27K+oa+LHrQf4InU/6XlVtLSM1Cs6Rvf156oh3bgkwoSXiyOoKpX1k0n7+k2S8mzsK6rmsmsjmr/326ys3l7MMFSaVIg06VmxbSPLfi5ulf3tlftSkBNCCHFCDp2+nZSURFZWFuHh4Wf0JKXT6XBxcSEgIIDY2FiAo75mcVU9s59/m80lUOsZisqfx9Hdz43LIgOZHBnI0BAfFEVHQUEBChpOTk4YjUbuv/9+zGYzL7/8Mp9++il1dXU4Ozuj2qxc3y2XmPq9BPm6MC+tEj8/P6xWKyqgyDJVIcR5pL2zPzIykoyMjLZbByjKEReJN909m1+yivg5s5DNueWtnrev0Z1RPTz4+IXHKc1Kxmj0J/H1lZSXFvPyyy/zyaefUV/XRLCPE42OztTW5VJRUUFpaSnV1dW8+eabzJo1C5PJJMtUhRDnlY7I/syMrTSWHSAlWcNsNmNVYWuJxjdbDrAiu6jVpjtR3X2YEu7F5cP74u/lCjQXEc1mM0ajkZqoe5g792My9zYSYGr9vf/993byzyiNyACFjDJXNmbvp7yiss3sP9uDMDpNtqMR7aiyshJvb28qKirw8vLq6MMRQpyElougpKQk6uvrcXFxOaIJ6uk894IFC1izZg1jxoxh5syZ9oufQ1/Twd0H/6GToPtwknaXcMh5mV5+Llw5LJRLIwIZGOSJTnfkbknz589n7dq1XHDBBej1etasWUNOTg5VVVVYrVauu+46evi7cG3V2/g7q1jqFaavDSK/wkqPHj0YN26cNPQ+BZL9QnRdx81+VT3lmcNtZb/RaCQxMZHk5GRiYmLQNM2+jCg+Pp6ioiJuvu9RDigBqN0G0eBiaPWcw0J9uMR1O5ewnj59+qOOmcP8BQnHzX5nZ2f+85//YLVa0ev1DBgwgKamJrp37y7Zf4ok+4Xouo6X/aeznLXN7Pc3sGbhVFzLtrHJayJf2cawq9EbVe9sf5xzfSn6vI2E2gr4fHp/PMuz7RutqdBqsCYuLo6EhKNnv2pt5L7rL6HcMYB//+f1Dst+KciJdiUnZiG6NlVVycrK4tFHH8VsNhMYGMiSJUvOyMwBq9VKVlYWBoMBk8lESUkJBoOB7fsP8MPmPN5b8Qc17sGg+/Ok6KerxaFwK2N7evL8vIeOe8Js+fKgqiozZsygoKCA6upqQkNDiYqKIiEhgZJ9mTS+dTE+Do2UNuiYvbk/WXnleHp6ntH3ez6R7Beiaztq9huNp737dFvZ7+vjze6tKXgF9uLuWfdQUFiId6/BjLzuHlbtLie/otH+eAdFx6g+BiZHBHJJuIkApRK+ua95Ax4PE0z5D6qb/3GzPyMjg9GjR1NXV4der2fYsGFUVFTg6elJUKCJt//vOYw9Bkq7gpMg2S9E13a07DcajSQsWMD2jWsZMHwM8XPnnlzRSlWxVhaStb8Ig78Rk8lE+h9bWfH7T3xd2oNC1cd+V4emaq4f2ZvJA/z4/cv/kZaWysSYSB7svRtdTZE95801GtOmTaOwsLDVcbaV/d1DQ3g4Fi4e6EuhQyj9p71F7WHZ7+HhgZ+fH++//z5BQUFn/sNteX9n7ZmFEEKckwwGg73RaXh4ePNSTlU9rdGjllG4pUuXomkaQT370RgwkHLP3tR5hTYX4TxCm19fV0NPhzIqM1cxdmgYMxbec8JTyhVFwWQyoaqq/T1ER0fbZ+QpioKxVwSr3IYzoG4T7p4uvDf7Il7Z6ETKwRka0tBbCHE+ajP7q4tQTmP36cOzPyQkBFcXZ64J2Ee4dz2rvCegDbmayv5ulDh5smdjEdC8S/boPr5MGd6DiwYG4u3meMiTOjUXBw/ZgOdEsj8yMpKYmBhSUlJwcXFh3LhxeHh4kJ6WypxoDf91T0FO9CkVHYUQoqtqK/vNhQX0zP2M8UHF7MstwFI0A1PgCRatVBV19fPsWfkR32fWs6R6NPq+F9DoHggMAcBZraO7YzVNu9Zz4cBgdJnbmP/WOkaPHs2iRYswBRjRrX2pVc4b3ThiI4ajZf+sW64mYMMz6GqKCHSHS0YP4+d1m+zZ7+7uzscff0x1dTWLFi1i7skWHE+CzJAT7UpGyoToug7t2xMVFUVtbS3ffPMNOp2Om266iXnz5p3yycpsNnPj7dPYWqbg2GckjiGR6BS9/XbnmkKuv6A/Vw0LJdjbmRkzZrQaATuVGWuHT7U/9HeqCmn6bBpOtlp0HibUK/+Nuab5dNke/STONZL9QnRdx8z+G29k3nhXlPz0U5ohZzabueWWW0hJSUHTNJxdXOgZGUVkRH+2uEZTqvja7+vmqNCneiMXWjfgU1/AlfO/P/oF4DGW0R4r+wsKCrjpppuorq4mKCiIRYsWodQW470qHuemCnQHZ2KcTNHxfCbZL0TXdazsn3bDlUzV/YauxoLmHkDfOT+heAWe0PPWlxfy03vP8nG+kVRdJKru4Pd91Ub93o04711NfX42Hy/9kLCwMFRVZeLEifbv/StXrmyesdZGzh9rGW2r2wB19fM07VmPY+8LKOh7EzfdfIs9+xcuXMicOXOwWCyEhITw9ttvn7XVMTJDTgghxAk5tLnr+vXraWxspKioCE3TWLt2LRaL5aRPVjUNVn7NMvPtlnz2Db0b90M2ZnCps+BWvI3KjJWU5O/m01/88L7pr/zj8flnZCvyllEzaGMnqcfjcO434c+RN3d/Fr+aeFZ2mhJCiM7smNm/bh2WWe9jGnHnKfWQMxqNjBp1AbsrgdDh6LoPx+LkwYqDtzvZanGtzGGQj5U37r+RgtcfR1dThGLww+h6jDkFinLUotmxsj8uLo6LLrqo1fklceEieubuJTbYgb7jL0dx8z+p9yiEEF3RsbL/t/WbmfWPK3Eu+gPH3hccd8MzTdPYmFPOFxvz+H7LASrrL6LlK7+udB9+lbvxrdpD+vpVlNbU4O7uznPPPcfgwYO577777M/TsioHaDPnD833wx2R/asb2L6xjgHDG4gbE9Qq+8PCwtA0jcLCQvz9/TEYDG0+55kgBTkhhBAnxGg0tpruDVBYWAjAmDFj7IWx4zV5rW+ysXK7he+2HGB5tpn6poMnVhScai30d6nmpQdvxpN6zOah3H//eor3NXFLDzOjSz6i7hdn4h9/AktxyRnbivzQLx3JyclYikswjX0YaotRXf3I2pZNUlKSfde/Uyk+CiFEV3Tc7A8wQctMs4O727WZy4fMZlDRsSm3jG83H+CzpqGoE2Lsd3N31KEUbMV5/wZy/kiiStHxq6qSQAkJl/4NdfPHOOj16DZ9AOP+eVrLRw/P/pKSEuLj47FYLBgMBrKzs0lKTuZbsxMDLAZenHUbJhmMEUKcB46V/aPHjMXjsniUulJUVz/MR/nef6C8ji/Sc/ksLYecsgb734O8XQiu2YFl83Jiw3uz4D//Ijs7mwcffJDc3FxKS0vZvHkzGzduRNM0brzxRj744AP0ej2LFy8+rVU5cDD7U1IoLCyl3JrSZvY7OzsTGBiIi4sLJSUlMkNOCCFEx1IUhbi4OLKzswkLC0NRFGbOnAn8uYzziJlmB2eS2VSN9buL+WbzAX7OKKSqwWp/3p4GNyb29Wb1/16mfP82Gnx9cVf/yuK33yYpKQlHR0cG9vBndI9Kuvu54FG2DV1d6Rk9MR76pcM+605RUN38W+0wZTKZpI+cEOK8cjrZby/CufqhrXmJrTv38r0tlu9Lu3GgsungKziha6rDo2IPT9x5JVt//YxP1nxIg6bRv19fduzYgaOjI1szMim9+18Yc5Kgrgzy00+6Z93h2sp+RVGaG5Yfkv0BpkAGRI1sLj4KIcR54ISy39WPVxLmsiJlKzGxzTuwNto0ftpawEdJe0jNraKlQZoDNi4KM3LL6L708bQxY/rL1BQWsqmhAovFwldffUVeXh4AYWFh9uzPzMwkMTGRdevWUVpaSmpq6mkPjJ9I9jc0NBASEsLIkSPP6vd+KcgJIYQ4IaqqkpjYetnm4bsOHTrbICk5mZVb97Imp57vthRQXN16ZOzKId24cnA3IoO90DSNBVv78WFGClVVVbz66qtkZmZiNpsxmUy88sEX9Mz9As/ybHSh0c1Lo84gRVHsI2OHjvC1vJ+W43j22WcJDw+X5apCiPPGMbNfVaG6CEu1rfUsY4vFvgPrzl07+aZxBN8dCGF/U8TBZ23CQ2/j4kGhVG9bxaqv36JRs5HqV0xmZqZ9d7u3336b//znP2RkZDBy5EgMPQZC7uhWjbxPh2S/EEK07VjZr6oq5sICXNNeZ0zpxzh76PjyjwBKP0rjt51lVNX/OfDuUpWLfn8qTXtT2Z1uYkXuOEbGxRETE8OHH37Y6nv/0bI/PDyccePGnXa7mhadKfulICeEEOeooy0dPd6S0qM5YllnG6NTRqORgdHjMO+vJdc0iLs+yrbf5uPmyBWDgrhycBA93K2YAgLsr6/T6ZgxYwZr1qyhtLSUzMxMIiMj0el0xMbGEjloMMqgwUdt0n0i7/t42uo7cfgImlyQCSE6u3bLflWFNS9AXhrG4ChiY2JITkkhNjaWRgcP3vhtK9+uD2JbfYT9uVxoZJLLdq703Mn4gBpc/vJvCi68ntvW/9Bm9gcHB5OYmNj6uA+2Ezj8XCDZL4Q4n7VX9rfMiN6evob7h9SwxuNivukeQ67Sjd1bLQA4N1Wi5KRj3bmOpqoi6m02nJycKC0ttbcHONb3/rayv60C2um8v86S/VKQE0KIc9DRlg8ddVnRCTyfqqpER0eTmppKdHS0/W+KolBW08j3fxzgy035bKqLgABAAxdHhYsGmriwhxuxPTzpFmg6YrSt5fVNJlOr0a+4uDhKSg7rE3ecpUmn+v6O5lhfAIQQorM5k9nfcpFjMBha9RGyZ39tcfNMtWozSn46f5/5En6xU/k5u5Qlz688+Cx+OGJjnPNOxqop9KveiObSndEmP/tsZ5Mbx83+VhdNbTTyluwXQpzP2jP7C8xF/JZZQIHfxdxYP6B5l1QFXBQblw4K4RrHdfhtWsR6l3peqNWorq2lqamJsLAwvL29W81wO5nsb6uAdi5kvxTkhBDiHHS0Ua3D/242m+09E9o66aiqitls5s0332T9+vWMHj2a//73vyxZsoRpM+8mcPjF6HuPZOUOC0225iYRig6ClErYl0JMsDOe2U48Nu9D9Ho9U6ZMISsrq83NEdo6CR6vP8Tho2InMovvZJ3IcQghRGdwprLfarUSFxfHpk2bGDt2rD2bFy1axIwZM+y7UTcGRfPbtiK+Ng9n5b//wKoebBakaZiUKiypP2Ao28x1kwPwq9lDmlnHsp3OLLn9KYw9BoKioMBJZX9bsyEk+4UQ57M2M9BopGT/NlKSkygsNJOUlERWVtYxZ30dK/tv//scXCMnUejSE3PPK+yPGeJiZrJ1BYOqk0nZNIYA13QaKvLo7aTQL7gPKZkVODs74+XldcQSUMl+KcgJIcQ5qc1NCg77e1RUFAsWLGDv3r2MGjXqiFGlllGnlStXsmnTJqxNTVQX7SVy3OV8netMWb9byWpwg21FAER08+Kvw4IZ1c2BhXOmsSotkx0NDXg7WsktrkWnKGzcuJERI0Y0T0mPicHoqjUvezr4uidzEmxrVOxo71sIIc4HZyr7H3/8cV5//XWamprYv28v1112Ib4h/UhJSWm+8Nm2lwc+TGPl7kFUN9gOPlLDucZMzbZV1G9fR0m5mbq6OvL1el7wCeDCEVeSUr2HEdExWF38UIGWVz3R7D/abAjJfiHE+eyIDPQ3wJoX8M9NZU60xospAdTU1nLPPfcwceJEnnzyySOKcodn/969exk1ZiwFSgCfFAVQMyAKmoCmBnzdHJk8wJfbx/YlOP1FKlb/TIPWSMOWL/jUpjLcpJJyQKNO58bf/vY39uzZw6BBg+ybQ7SQ7AedprXseyHE2VdZWYm3tzcVFRV4eXl19OEIce5p2dHOzR8VjtproaCggOuvv57U1FScnJwYO3Ys77zzTquTotls5q4772BfZhq7KxQuv2ISBUETKHDoZr+Pm66RW8YMYEJPN2IHdkcB1NXPs335//gmPQ/QMcTQRFKejZdSFWbdcw+JiYmUFFswZr+Pkp/e3Jh77MPH7AvXFrPZzLRp0ygsLCQwMJAlS5bYe1vIMqPORbJfiLPr0NyDU8h+o9F+7jBbLNx4442sXLkSNI0nJrhxaYSB3b6j+cQ2kf2NblTofezPG+zjypSh3ShI+pZvP/gvhYWFANTX1wPg4uLC3//+d3s/oEWLFpFysNfcyS4vOlruH/4ZSPZ3DpL9QpxdR83+2mL45j6oNqO5B5DZ9x4uvOI6+3+TW7ZsITg4uNXjLYdkv943GK9hl+IRMRGd68H/djUVXdEORhptLH5mNu4uTqiqysvPPEbsgbdxUxow18C0b+rQgCqbM/f8/e8kJCQwb948+wYNp7Ks9FzOfpkhJ4QQ54pDGmwTMgJl7MNHPVmVlJSQnZ2Npmk0NjbSu3fvI0aVPDy96B/iidZvNrUug9moaz7JueisTA4PYNIAA5OH9uK5Z/9FwhsHR6z+MQMlP50BwX5cjY3q6mrcdE14e+tRRkwhPjERBwcHTB56yE+HanPz8dYWH7c/3OGONiomy4yEEOeTtmYOnFT2H5xJ0XLu8B35ALt27ULTNAIMXtT2u5gnXC9kR2Pv5hfUgye1xFo34u3uybMPP0pJSTHT/rMaHx8frFYrNTU1KIqCo6MjN9xwA4kHs19RlD9n2Z3C8qJjzYaQ7BdCnE+Omf2uftT4hOGhaehCo7E6+1BfX4+qqtTX11NSUkJQUFCrx//jwYfY1eRLwA0Lcek+yP46Wk0ZVw0y8sfX/2Xn5iR+t9l4RldiH2RZmZaJq4cnA9w1NllUqjVXHBwdue2W5uwvKSkhMzOzzXY1J+pczn4pyAkhxDlCrS6iafc6nJrK0R1S5Dr8hB0XF8eXX34JgKOjI8OGDeOll15CURQ0TWNrfgWfpeXxzaZcKv1utz9/X3UfM0JyuTzcH8+JV4Ki2E+u9our2umYQkag5KXRd+JlVNdUU5D2Pdv3N4L/ISNXbv7NM+MOXgDi5n/S71eabgshRPPMgdWrV1NWVtbmTnjHzf66UvvmDOSlsWNLMo3GAQSMuBWXPtF8qncEQEFlQlgAl7MB0+b/8EehjZ+qwykpKW51sXTllVdSU1PDN998g81ma5XPp7u8SHJfCCGaHTP7FyaSkpzOhJhBPHD9bL5OWIirqysAMTExhIeH2/uv5Vc28fV+hU+eXYEy+i5cAE21oeZvxZq9koE+Gi+++CPzdv9Odvo6HBwcyMjIsOdwTOxIfkqGmrBwyv00Avd82yr7W3I/JTmJCTGRzYNAJ+lczn4pyAm71atX8/zzz5Oenk5BQQFfffUVU6dOtd+uaRpPPvkkixYtory8nNGjR/PGG2/Qr1+/jjtoIQRwcJTslbfombuH2GAH+o6/HOVgkevQhqerV69mypQppKWl0aNHD9zd3fnggw9I37qNrFoPPkvPJ7uwyv68froqxjeuJbAkndVF3uzQ9eOae56xLy894uIqwAQBD0NtMYqbP3VFZuYvTmF7XgkmS9qfo2KK0rxM9eASqZNdrtqiq4+KCSHE6VBVlbfeeoucnBwArrrqqlZLl46Z/e+/x+4/kug3OAaHkBHs3LWTz6vH8OUvjbhcPNv+Gs61RUToC3ht7n0EGbxQbVG8klPIil1biYkdab84OvRiyWw2s3nzZkpLS0lPT7dn/5m4qJLcF0Kc704s+838tKaRi6Zmt8r+JUuWsHL1Gmq8e1E++EbKVJ/mJ20CfWMVdRnLccxNJby7ieAhobz++us4OTmRkJAAYF96erTs37R5yxHZH/94HDXLnsGjbBu6tS+dUquaczX7pSAn7GpqahgyZAh33XUXV1999RG3P/fcc/z73//mvffeo1evXsybN4/JkyeTlZWFi4tLBxyxEKKFxWIhOSWFbwudGGAx8OKs2zACFrMZX19fwsPD2bFjB1VVVXzxxRfExMSQnJJC8LCJXL7gc6q9+6BzaJ4F4eSgcGlEINeNCGFkTx92benGP5/cw6YtW0hN30Q1biQmJqIoytEvrg4uPzUGmBgQNZZyaxuzIRTlpJepCiGE+JPFYiE1NRUPDw/8/PyYMWMGAAUFBaiqyogRI/joo49aZX9KSgrRI6JY/uTlGJQKXnO5mNyw29lSEHHwWRvxc3ci2l9l56//Y3vy76yzWnnFqaI5+/UOzJ67kJsPy/1DL5ZMJhPjxo07J5cXCSFERzvV7A8bPpIJD7yIrUcseo9awAcdGuMHBHBzbA/G9PElaUMgzz2Xz5YtW9i8eTNPPvmkve1AyzLVk81+pa4Uz/JsqCk65VY15yopyAm7yy67jMsuu6zN2zRN45VXXmHu3LlMmTIFgPfffx+TycTXX3/NDTfc0J6HKoQ4zKEz1QZExeLrZyAuLo6MjAx7Y22bzYa3tzcbNmcRc8M/KHUYRWZlIxhAB6glOdwzeTDXRvekT2iQ/UQ7YPgYIiIHkZqW3mqaesvJ91gXV+fyFHMhhOhoh89SNhgMPPbYY3zzzTdA86yJ0NBQysrKSEtLIzExkTvuuIMvflnJr2VXsdElhgadCxTU4aBTmRAWyHUjQhk/IAAHBeL2/U7mOusR2X+8oppkvxBCnD0nk/2paWnc+I8n2RU4gS/2VECEDj3gaSvncm0Nf3H5g1FTP8XB1wSqyrjhYSwbFEl6+pHf+085+89Aq5pzleyyKtqk0+laLVnds2cPffr0YdOmTQwdOtR+vwsvvJChQ4fy6quvtvk8DQ0NNDQ02H+vrKwkNDRUdlsS4ixoad5tMBiIj4/nnXfesd8WGNSNWu8eOA+cSI1Pbzi4QYPWWEvDjnVou9fR1+DMRZMmkZ6efsTud1arlfj4+NPaIUmcPyT7hWg/h2f/kiVLqKqqwsXFhejoaKKiosjIyKC6CaqMkZR6DwCvPy+oumsHuNIhlSE1G8jwvZzZDz6I4hEAiiLZL06KZL8Q7ed42T84Kob1BTZKfCNocv2zb1tDbga1W5bxD1M6t0UqgMZu9xEMvvddTDuXouSnY+s2nPhlpWzNyDxz2a+qp92q5lwkM+TECWnZwv7wirjJZLLf1pbExESefvrps3psQpzLDt8h72hbex++bfnWrVupq6vD6uhOwMgp1IWNx+rkhfXg/ZsOZFO5+Sfqtq/D1liP0WjEKTCCjz/+GE9PzyN2QTraNHUh2iLZL8TpOZ3sb2howGazodfrGT16DBNunEXe71lk7qsCpfmrv9pYR232GozmZG6PLKe3UwnbqtwJqPmRps+zce4zGsY+LNkvTopkvxCn50xkv6MhFIfYm/hZ342abrbm+zfWUZPxO9Wbf6TRsh8/Pz+W2XwYH1qGwd0BJ8sfzLvnBh4ZXku/IC/0BzayMP7fWOp0Zy77pVVNm6QgJ86quLg45syZY/+9ZaRMCHF8be2Ql5iY2Gp7c6WNGQyPPfYYAYPG4u0Zg77HMHSKA02At6sjkwf48NULD1O6YzNNjY2oTY3odDrKy8vtxXVfX982d7+Tvj/iREn2C3HqTjX74+LiGDRoEGlpabgZAgkecw2/Oo/mvXfTm59YccBq3kXNH79QmbkSrbGOSgcHXqztjY+TNyHBwSwIq8SpqbxVjx/JfnGiJPuFOHWnk/0RgwaxydyET8Ql6LuFk20DbDZ6+DqTv2IpRak/0FhTQVNj8/f+qqoqqoz+bC5rYqS7ni0lGn8cqCPZZKVHdx+cQ0ageARg8pJBmLNNCnLihAQGBgLN2ysHBQXZ/242m1stYT2cs7Mzzs7OZ/vwhOjy2hoBO3SHvOTkZLKzs1v93nL/xx9/nHfeeQdHd2+K/Yfw60uryNENxqFX83OblGoeueYCrhjcDSe9Dvftk1i71pmRI0fy888/s3fvXjw8POjWrRtjxoxh1qxZ9j4RQpwKyX4hTswZyX7H5g15iouL+cu0OawnjFwMlOr0UNmIp7MDU4d1o3LTT2Tl/crIy0fys95iz/6gbsHN2X/3TEw7/ocuP116/IhTItkvxIk5U9lvU5z4z69ZJPlNxvnicQDo0Lg4PJDbL+jJyF6+LKhfx1rb4CO/9weHUDl0NL1uuYbfln5NQGMq+0JjcLx2ZvNMNrkOaBdSkBMnpFevXgQGBrJ8+XJ7Aa6yspLk5GTuueeejj04Ibq4lhGxpKQkIiMjSUhIwMHB4YiGrf379yciIgJN05pnsBl8Kclaw9crU9DF3opj2FjMDk5Q1oCHswNTh3bjsv4ejBrYo1Vxbd68efaT+pNPPklWVhZffvkl69atQ6/XSzFOCCHawclkf2REON76BsKiYvD19WXVqlV8+eWXVFZW4ujujWPEJdz0v2z2FNeArnlJ0PDuPtwY052/DO6Gq5Me9aoILJbbj579gUEogf+UHj9CCHEWnUz2h4eHU19fT1RUFFarlT/++IOvvvqKGsUdzyF/YVf4xbyyKhcALxcHroowcPfEgYQa3O2vd6zv/YreAVOfQcydN0haE3QQKcgJu+rqanbt2mX/fe/evWzevBk/Pz+6d+/O7NmzWbBgAf369aNXr17MmzePbt262Td+EEKcGovFQlJSEps3byYtLQ1o7sNy6E5FBoOBxMREMjIyiIiI4JZbb+Hr1x7jg6JeNE78J24Hn8tbq+KfU0cydXgIHs5tR7yiKPaeE0ajEZPJRFpaGmVlZaSkpLTqHSeEEOLsOOHsX7iQiJKfuH0QBA6p57JLJ7Plj63UOhvwnHQP7uEXsllxguIa3J30TB3ajZuHeBHeq3urotoJZ7/0+BFCiLPmhLLfz5dXEubyzddfYbWp1NXVsfSjj7D59aJ26M0Ye0eh0ylYgX4BHtwxuidThgRRU1GG0de11eudaPbLd/+OIQU5YZeWlsaECRPsv7f0gLj99tt59913eeSRR6ipqWHmzJmUl5czZswYli1bhouLS0cdshBd1qFT1Y1GI5GRkaSlpR11e3Gz2UxycjIHymrJ3tHA1/9JpdFhEgAOWHHKTaUiYxXBIV5cPGfCUYtxLa99eI+KQ0fkDu8dJ4QQ4sw4lezfvnEt44OKsVY0svnnD9lTOxDnKx7HI2iA/Xn7+rtyx5g+TB0ShEfKK5CUBnkjYOzD9qKcZL8QQnQMe/b7GzC6agyKjDh69huNVP30FGNKP6a+RwUL1lqxuPfGc/T9OJp603LlrSvI5JW/T+GqmP5omtYq3w/dFVWyv3OTgpywGz9+PJqmHfV2nU7HM888wzPPPNOORyXEuefwE2N8fDwJCQkA9gatBoMBs9mMwWCgpKSEnFo9tUOup8zqDTo9NsBPK+c217XcGFLMK1pP/ij3YuTIkcc9sR7eo6KkpMQ+IidT1YUQ4uw4lew3GAwMGD6Gjfsr2eU4hOXu49HGe+EIYLPiUb6LcUHwfw/ORq/XQ3VR84YM1eZWGzOAZL8QQnQE1WbllYS5rEz5gwejYXwfdxIujQJuZ2tGpj37CwoKADC56/Ao24avrw/lYeMJDLsY3P2an8zaiGdJFr6WzUyKjuTK6H7odDqKioqO6DfXMuNNsr9zk4KcEEK0s8NPjC0nzcTERPsSpYULF7JqzVoqffpSHTSCOjcT4Ac6CNBVomb/zhWDu/HA3feiBISRoFNO+MR6eI+KlsfIVHUhhDh7TjT7V69ejaqquLi60jt6Elq/y3m3LgrbwTFTNxqZOsifey8dioN1ZOvcd/Nv3pAhL+2IjRkk+4UQop2pKjXLnmFM6cf4emu4l+loqgjGSadjYfy/sdTpMBgMJCQk8P7776PX65ly4x14Bf2Fj5tupsa9edMepaGKgQ5FPD9rCv17XklJSUmr7G8r31tI9nduOu1YU6KEOMMqKyvx9vamoqICLy+vjj4cITpEW7MkDi2iZe/J5Yp/JNLU8wIUd18AdKqNHjoLul2r2L9pLZWVlQwePJhffvkFB4eTH1tpa3cnIc4WyX4hjp/9BQUFjB8/ngJzEQ69Y/GJmYrqE/rnExTtpO6PZYR7W/n152VHz35VPerGDJL9oj1J9ovzXnUR2tf3UrBrC3nlDTT59OOCvr7oQqObWwoA5r2ZjL5kCvl1eryi/4rrgDGg6AFwriuh8Y8fqcpcweDIiGN+7z9Wvkv2d15SkBPtSk7MQjSfFM1mM0CrHU33WKp5e91ePkvLpcHaHM226lKUPeu4KsKPPVlb2Lt3L7t370av1+Pp6cny5cuJjIzssPcixImQ7Bfi6NnfYtueXP7yj3/R2HMU+oODMYqm4lW2nfo/lrF30xrJftGlSPaL856qoq5+nsY962gMGILHpfNQ6svts5e11S+wNmM3c7N7sd9jkP1hw0M8KFn7CUV/rGSPfO8/p8mSVSGEaCctF2OLFi0iJSWF6OhoZsyYwb5aR5as3cfy7CL7fX20KgpXLaUqcyWuzk64RNxJTEwMmqZRX19PdXU1kZGRhIWFdeA7EkIIcTxtZf/MmTPtRbldRc2DMV+k52GLuBw9zYMx1uzfuW5YEIZgZ5LznGgMDpbsF0KILsKe/avq2bmpjiFD67l5uAVTYBCg4/fNO3ljtZH02gjwAFSVuh3r8MxP5v++/h9vlwWxobInDfK9/5wmM+REu5KRMnHOOMaSoLbuowIJCQmsXr2anJwc3D29qPTqjT5iMg3uf/ZwuGhgAHeN6UV0d28efPBBPv30UxwdHRk6dCiLFy9GURR8fX3Jzs7GYDAQFBQkU89FpyfZL84VJ7Ls59D7QOvs9/DwoKa6isg+3TBGT6Gu52hWbrfYHxvZzQvHPatZ99F/cHRQJPtFlybZL84Vp5P9uTn7eWBYEwM9q9lZ78/anvdQ6DeEHeZqAJx0NqYEWPjynf9SvH87gYGBrFy5EpPJhMVikew/x8kMOSGEOIY2T8CqCmte+LNp9tiHjyzKHXYfy4Bbm3c2Kq/C1nsMFQMmYnPxwQroVCt/HRrEvReH08foYX+KV155BXd3d/vuey2zKVRV5ZtvvjlqHyIhhBCnp63sP14PuLbuM336dJKTkyktLQXA3d2d6MjubAu4mLSGHrDdgk4HFw80MX1sb6J7+mKzjSLeuVKyXwgh2tnZyH4/F5VIg41k/QV86n0VlqZAMFfj4ezAzbGhTBvmhX9AIJ5V+axZ483YsWPtuW8ymST7z3FSkBNCiKM46gm4thjy0tCqzTTuXofjsNtQvAJbP/jgfag2Q14aDgNuwnHYVCrqfLE5uADgjBWvos1c3NOJBTdcecTJ1cHBwb773qFfDI62U58QQojTd7TsPzR7V69ezfTp0wkKCmr12MPzefr06cTGxrI+NZ0+QyaT49SLZTU2AJxp5PqoYO6aEEFPf3f7c0j2CyFE+zsb2b8hJRXvIXfxiM5EYZNr850bqrl7fH/+fkkk3q6O9ueYO3dum7PwJPvPbVJaFUKIozjiBFhkhuoicPVDDY5iZ0Eln27YQ8Irb6GqausHu/lDyAgOOPbkmfLJjHktg01NQdgcXOju58ozUyLY+NTlfJ84iwVzHz3qSFfL6Niht7dsXx4YGHjE1uZCCCFOz+HZbzabMZvNGAwGYmJiqKqqIicnh7feOjL7W/LZZDIRERGB4uqFS/R15A+bRUpTdwprbBicrPzDkMr6ibt55poRrYpxLST7hRCifZ1I9ufm7OfD/76MarO2euzh2e/l40fIhJuxxN7HBmtPCptccaMR/9xV3Oqzk0evHNKqGAdt5/6hzy3Zf26SHnKiXUkvCdGVtBopi4khfpwzSn46hIzA3P9mHrrnTrbnlWAKDGLJkiX2aeUWi4UqXPnvqj18vSmXJq35xBoR5Mk9E/pyWWQQekV32scm25eLrkKyX3Qlh2Z/dHQ0Op2OlJQUYmNjueuuu7jjjjsoLS0lKOjI7Dcajaiqyuz4Z1hX4kqlIQKbTg9AL393ZoztzdVDg3BpKjt2D9K2Dwy1ughLrYYx4MiLNiE6G8l+0ZUcL/vvvON2php2MyJQY+DFt+F52VOo0Cr7H4ufy9oDKhXdRlKncwYg0MuFWRf25m8jQqgqLz3p7+7H26FbdG2yZFUIIY5CURTi4+ObT7SuGsp3D9iXqRqG3MKAqLGUNSURERGBwWDAarXy9/iFJFV4U+nTB9ABCsN0u7isYRlV5UO4PHIhymkW41qOTaarCyHEmXdo9quqyozp06gtziU5SWX69OmMGzeOpKTm7Pf19aWgoIC33nqL1NRU+kdfSG2PMSwjGvybL5r8tEoW3Hwhkw8djHEOOLmDOtiXVMlLwxQyAgIePsPvWgghzm+HZ/+0adPYv38/qtqc/ZeOHcGIkl1089TjVpqFeW8mb/7vS1JTUxkRM5KAkVfxTdNQmoI9AXDT6ombGsXfokNxdmgemHE7ye/ubS2jFecWKcgJIcQx2Buq2qxUeg+gcOcOkvNL2Ze3mEcfe4z4+Hg2bNjAA0+/xOZGEwd0UeDT/NixvbyY6bUB5+TXSSvUsXKHwi3S90EIITq9luxvbKhnit8uehgt5GHF6G8gLi6OuLg41q9fz6WXXoqiKOyv0iDiMjLqBkJ2KegUbPmZaFnLCAx0Jco08fRmRh/Wl5TaYvA4yaKeEEKIY2rJ/vr6ejIzMyksLKSurg6DwcB9jz7Fz/HrsZXv45ffMvnovdnszzuAY7/RZJf1wfp7Ljh54tZUyl/rvqVv404u6fWTvRh3KqR/3LlPCnJCCHEcqqqSsDCRNas3UF1UTZOjN6aCFLKysnjvx3Uogy4npykCdKBpKo07N+C6dzV9p17MqLvi+PfOUlbs2kpM7Ejp+yCEEF2Eqqo8+8Q/idVbCHDT8HasoyxvJ41OPrzzzjuUl5fjHBxGwIQ70AIHNj9IU+mhL+fFGZfy2ZurySh1ZeTIM5D9B/uS2nf3dvM//TcohBDiCKqq8vDDD1NYWIiqqlRXV5Odnc0HH3zAm29uxMexibJGBwJjIrFOuplGz+YCmSuNPDSpJ9Gr5uKmK0ILCMDodnqrYlr6x7XMkJPriHOPFOSEEOIQbfVmaxmdKi4ppaJao2dPH4wRFzD3dwtuVzZPHddUG/XZq7Bt/YnerrXU6z1ITUmmLG8ns+MXcHNxifR7E0KITuqo2Z+xGyf0DDNaUbv1wersQ5G5CJuhD/4XT8GlxxA0ms8BbpYsdNt+wd3PBZeaYSQkJFBScoayX1Fg7MPNM+NOtvecEEKINrWZ/UVmSnOycXZyor6hgf79+6OqKhs3bqSxqYkSUyQ+Y2/DGtgXAKWpFsedK+hhy2XkzQkMnHQ91r0bcOx9AcppzmRu1T5HriPOSbKpg2hX0txVdGZH2+7carUSFxfHN998g82vFw5Dr6LBp+fBB9loyF5J+fpP0dWUED/OmXG93Vi3v44Ao4kbx/XHuc9olHH/lAsocd6S7Bed2XGz/+uv8HGy4WHqic2/H3V9JlKkNfcI0mxN1GWtpG7jN+jrymhqaiIgIIA+ffowbtw45s6dKxdQ4rwl2S86szb7s2kq1T89TUHqt/y4xcKrmxzo1bsPrq6ulOt9KDDGoAX0a358Yx11m76jKeMXmmor/8z+sWOZ++DdzcU4yX9xHDJDTgghDmqrT4PRaCQxMZH1O4toHD0LTAOwAahWAiuyeH3231AauvPgg5vYl1FGlEnD26GBcT0cUW3F5GRVoMvNpe/w21G8Ajv6LQohhDhMm9nvb+DfC+eyedNGGpusVAUPpaD7OPSBA0ADJ72Oi3q7sfXTl0hf8xtNTU3o9XocHBwoLCykpKSE3NxcZsyYQVBQUEe/RSGEEIc5PPvNZjMf/vdlxpR+TLC3I7EhCj3zPcncb8ZrzC1Yuw0BwFHR4XYglV3fvUFjZUnb2T9zJkFeUowTxycFOSGEOKitPg2/b9nD0gMG6sKGA6DZrFi3r2Km8y/cGOFAX7OCMu6fvP/++4wdM5rUA2XE6KxsLdNTV9vAyFCVwgor3rUaJhkcFkKITueI7Pc3UP3T04yyLGWfX3eyxt4LweHoAc3aiH5fEldH+rDwzkfJv6QPo0ePtvca0uv1NDQ0oGkasghFCCE6r8OzX1VVFi39iroe5cR005Fa6c9O0yRcx0/CqncATaWfQylvP3Qt1Axi9O9LKKzSSfaL0yIFOSGEOOjQPg3FVmdmvJ/O8uwi8O6BZrNi27mGhk3fEmlyYvLISnr6h6Dkp0NtMQ4ODji7uPJSWgX9DvjiYghh9+7dfLLLxl+uv4ybA2RHJCGE6IwO79FDdRHLU7bwtvP9bO0djiPNhTjHnBQqkz8nyMeNjPpQLBYLDg4OuLq64urqio+PD6GhoezevRur1crUqVNlNzwhhOikDs/+goICSkrLmJ9jxTTyL+ij/oajoysA1ryt+OxbgbOPI05Nl6JK9oszRApyQohzXlsNW49mb0ktLy/P5/s/Cpr/oKk4H9hM0+Zv6RvgBX1DcXVxps4Ajj7u9t3uTG5w8803s3r1aoYNG4a7uzueXt5ERkayICFBeggJIUQ7O5nsVxQFk8nE1rwKFn6/kw2Nd4MDKGoTnpYMfApScVeaaOjbHRcXl1a73R2e/d7ezdmfINkvhBDt7lSyH0Cn0+ETOQHX8MvRezVvxuBUW0Rg4QYcS3bj4i3ZL848KcgJIc5pLQ1bk5KS6NWrFy+99BJOTk5H3O9AeR0v/7qDLzbmoR6caf6XQUE47/qN7WXJxFx3JTNmzMBoNDbvmudvQFdXCq5+UFuM4ubP448/Tk1NDRkZGcTExLB48WJMJpOclIUQop2daPa33Dd5Ww7vbizm50wzADo0TGUZjAtUeXDhNIzGxygpKcFgMNj/t+WCT7JfCCE6h5PN/pYc31ZYxdPf7sM68g70gBuNzLm4H7eOvYTyssvtmd9CURTJfnFGSEFOCHHOOfQEa7FYSEpKYs2aNfz2229s2bKFFStW4ODQHH/ltY28vnI3767fR6NVBaC7vpw3/n4FEcE+qOpQLJbbW42y2aehu/nDmhcgLw1CRlAy4FYyMzMxm82kpqYya9YsOSkLIUQ7OZnsb5FTUs1dL3/JriY/0OnQ6WDq0GAemNgHNzW6zew3Go2tduabPn26ZL8QQnSQU8n+lsLdurQ/UAf9hZ02fzQNnB0Uboky8eBlkXi4NBfyTCYTqqqyePHiVjuylpSUSPaL0yb/YoQQ5xRVVUlYsIA5M2/h8bjH8PX1pVevXjQ0NKCqKtu3byc7O5u6RhuvrdjF2OdW8NbqPTRaVdxqDuCdugivLR/h79AA/DmVvc0TbG1xczGu2gx5aRjddMTGxhIYGNhqSrsQQoizS1VV5s+fz80338xjjx09+1uUVDfw1LeZTHxxNbusBtDp8KrYzdJbI3j5+qH0MnoeNfsP35kPkOwXQogOcLLZ36Kg0MwPu+rY3u8Gdlibi3FXDunG7w+PZ95fh9uLcS3a3I374KYQkv3idMgMOSHEOcVSZKZnzmeM8ssnbWs6T8yDF154gS1btrB9+3YiBw1mS7UHdz2/gqKq5qJbWKAn/5zcn3WfbSTF1XriJ1U3/+YecgdnyCkeAa2aw8oomRBCtA+z2cyHH35ITk4OSUlJQOvsHzRoEGFhYVQ3WFm8Zg+LVu+hptEGQDelEtcdvzB+SG9iw7of97UO35nPZDJJ9gshRAc40ew/1PrdxTz5zQ4Kg0YD4K/U8PqMScT0Mhz1dY7Yjftg1kv2i9Ol02RfXtGOKisr8fb2pqKiAi8vr44+HHEOUisL2f78xTSU5FJcp/BOaRQvvPk+NpuNXzPyWZpVz86iagBC/Vx56OIBXDWkG4qiO6kmsH++oNo8U87NH+RELESbJPvF2VZQUMCYMWPIyclBr9czZswYPvjgA1RVpaSkhH4Dwvh84wFe+W0nJTWNAAwK9ubRS8O4oI/fSWf/KZ0vhDjPSPaLs+142R8eHm5frlpQUceCH7bxw8GN2/zcHLlndDB3XhiGg4P+uK8luS/OBinIiXYlJ2Zx1qkqtlXPseP3D0krgD0h11CKO78Ve1HjEQKAj5sj90/sxy0xITg3lkkxTYizTLJfnG0ty5bef/999Ho9N954I3q9nuSUFIKiLmG352D2FtcA0MPgxszYQK6/oP8JXYQJIU6NZL84aw4OiKuufsxfkHBE9qekpNh7vVlVWLJ2L//3+05qG20oOrh1ZA/mXDwAbzfHjn4n4jwnBTnRruTELM6WVqNWgFpdRGZRA2+sy+fHrNLmZt2qjZuiu/HIFUPwdtGjrn6epj3rcex9Acq4f0pRToizRLJfnC2HZj80L19q+fsNf3+UgsBRWH17AuDn7sQDE/uy77cPWLd2DWPHjmXu3Lky00GIs0SyX5wVqtrqOzxjH8JcZDl4k8odd9xBaWkpQUFB/P2pl3lxVT67Lc0DMi7V+Uz2r+DlJx6S7BedgvwrFCfttddeo2fPnri4uBAbG0tKSkpHH5I4z7XslDRt2jQSEhKoqm9i4e8HuO7dTH7cVgY6HYMaNnOdWxZP/3Uo9VWlWCsL2bXyY3K2pbFr5ceo1UUd/TaEEEKchMOzX1Wbd8rOK63lhld/JnfgjVh9e6JHZda4Xnx2ezgX93Tio6Ufkpqayocffmgv4AkhhOga1Oqi1t/hq5q/w1utVl595WWqzXuobtSoG3Idf/98B7stNfi6OuCQtpTC/z3Cso8WS/aLTkM2dRAn5ZNPPmHOnDm8+eabxMbG8sorrzB58mS2b99OQEBARx+eOE+17HxUUFjIz9uKWfr099TpXAAYqtvJk14/EB7giv6aN0lMTCQpKYnevXoSXd9EL0eVfeVWvGs1TDJ4K4QQXcahu94lJSXxz7i5fLW9Bq3/RHQOJjRNxaskm/cevpYfPvsfD7yWRM+ePdE0DVkgIoQQXZOlViM530pPB5V9ZVYWJ7zE5198SUV5GQ8MtzFpzMV87nEDu21ugIZvSQbRTgWszEmV7BedjhTkxEl56aWXmDFjBnfeeScAb775Jj/88ANvv/02jz32WAcfnTjXHa2ZqtFopPeICewu9aHELRAAraqIaY1LucewCT+dJ/rut2Ku15GUlMTmzZtJTU1lc/9+mDwNDB45EWOAqaPelhBCiGM4VvbHxsaSlJyMe/gEvqoPhHAfdEBDbgZq+mfcMGUSQd4urbK/X79+mEwmJk2ahCnACNVF0ktUCCE6maNmf4CJfaHX8fPGtQT3H8Lnn39BTk4OxpAerBh0P/uc+wEwwOBIY/JH7NjwC183Ndmzf+LEifbnl2WroqNJQU6csMbGRtLT04mLi7P/TVEULrroIjZs2NDmYxoaGmhoaLD/XllZedaPU5ybWpYmtWw3Hh8fj6IomCvqmP/tFr6vDwM3cHFQaNryPfnL34cLoNjUE8Pwv8LEJzDqFCIjI0lLS8PR0ZFCcxE6JQgZKxPizJLsF2fK0bK/5ULtkptmsd5jDCnmWnADrbKQ8pXvYWjI59prriEhIQFFaZ39RUVFBAUFoQNY8yLkp0PICBj7sBTlhDgNkv3iTDle9sc9/jglJSVYrVa++PYHvC+8A6eoq9in6HGlnofDSrn1ptuZN285WWus9uwPDAxkzZo1pKWlMXLkSPvzCtFRpCAnTlhxcTE2mw2TqfVMIpPJRHZ2dpuPSUxM5Omnn26PwxPnuEOXJiUnJ5N/oJAv/rDw2ur9NNG8S95fh3Xjn5cMYNG/U1hTF0v1sKH0e3gOildg80WWqnLfffdRXV1NdnY2eXl51NTUkJqaisViOeLfthDi1Ej2izPl8Oxv6fvz6n/f5adCFyp8+gPg4aznUtsartJ/RM2Ungy+dyVBQUEodaWorn5tZv/Ozetp6u6Kc1M55KVBbTF4SPsNIU6VZL84U46W/YsWLWq1g+rK7UVwaTyeLj4AjO/jxYJLI3B0dEZRlCOyv6KiArPZTFBQEMnJyfL9X3Q42WVVnLADBw4QHBzM+vXrGTVqlP3vjzzyCKtWrSI5OfmIx7Q1UhYaGiq7LYmTduhIWWjURDY0hlKuuQGgrzxAD0sSH/1nISaTqc0p7qqqMn/+fJYuXYqmaUyZMgU3NzfS09NbjbwJIU6fZL84Uw7N/piYGBqtKt/vqKY8eBQ4uoCmcdUgI3MvCsH422yaKg7g6N0N3ZT/g43vo+WmsmJXNX//aDeqRuvsj4khfpwzisyQE+KMkOwXZ8rh2W+z2VixYgWFhYV4eXnhH9yL7lPn8Mv2UgB0deWEmtfxycvzWLx4MUlJSdTV1ZGXlwf8mf1paWnU19fj4uIiM+REpyAz5MQJ8/f3R6/XH7ErjdlsJjAwsM3HODs74+zs3B6HJ85xiqIw7b6H2B+8mZ92lAGg1lXRmPY5Ea4VjL9wHEaj0X7fw0e7LBYLa9eupbCwEE3T2LRpEy+99BKzZs3CZDLJyViIM0iyX5wpiqIQHx+PxWJh3Z5SHvrfBrSezfnuXF3AZP8KXrnpchSA0GicdGnNxTUNyEujqeIAbqW5WCsrKKppI/uheWac9JAT4rRJ9osz5dDst1qtTJw4kcLCQhwdHfEZdil7e00ke3spig4G6s2oe7/lgugogOaVNPn55OfnU19fj06na5X9RqORkpKSI3rTCdERpCAnTpiTkxNRUVEsX76cqVOnAs2jF8uXL+e+++7r2IMT5yxVVSkwF/HTrhpe/nUnNY02FB2wey0Vq97H6O3Oy59/TmRk5DFPqkajkQsuuIBNmzZRV1fHnj17eOyxxxg1ahTx8fHt94aEEEK0TVXtxTEV7DOdD1TUM/+XXH7ONIOnCbW2AsesH/jkxUcYPGjQn9k/9uE/i2sAISNw1DRqfD2paErFZqs/MvsVRZapCiFEBzp0ZQvQapWLyWSioKAAAL13IJ4XzaIooLlVQYRXHf+6dRIRwd5YLFfYHx8bG4umafj6+vLHH39QX39k9ssyVdFZSEFOnJQ5c+Zw++23M2LECGJiYnjllVeoqamx77oqxJmkqioPPPMKv5UZqHdtvsAa1t2HZ64K56u301lTFs7YsWOPW4yD5pG2WbNmsW7dOg4cOEBxcTH5+fnSP0IIIToDVYU1L0BeGmpwFAmrG9iQmobb0L+QSXfqmmzoFR1hSiF1279g/LjY1sU4OLK4NvZhdLXFhFc2MWTd7ZL9QgjRyRy+NFXTNFJTU5tbCsyeieIRgMHfyOC/zSGtIRBNccBFZ2WO7xru6paLg+84OGxlzKEz626/XbJfdG5SkBMn5frrr8disfDEE09QWFjI0KFDWbZsmYSaOOPKaxt58stNfF8/AFxBb63nn5MHMH3CQEpKinn84O5KJzPd3GQyceGFF5KUlERQUBAuLi7ExsbaR9SEEEJ0kNri5o0Vqs007VlPyjY/tvf4K7amAMBGTE9fZo/tRsyASygpueLEsv9ggc7kpkr2CyFEJ3To5g1r1qwBoLyslJ65n9H0eTo7/Cfy8M5BbG8KAQUu6O1HYkgSPcpymtsTtMyIPkTLzDpVlewXnZ9s6iDaVWVlJd7e3tLcVRyVpml8s/kAz3yfRWlNIwA+pdu40Lec5+c/wbPPPnvEFugno2VavMFgkP4RQrQTyX5xXAdnyBXvyyCh4hK+OuALgLPWyDPXDGP7sg9ISZHsF6IrkewXx3PoDLno6GhqamrI376Jfw4qZpn7FbxVEYOKHnfqeSo4jWsH+aIbOwfqSk+o96dkv+jspCAn2pWcmM9fbe18evht9Xp35n2bxeodFgB8dHV47/wJ1bwDT09PBg0aREZGBoWFhfj5+fH+++8TFBTUEW9HCHESJPvPXyeS/UajEZ1Ox6epOSz8cRsV9TbQNNzNmwkpSWdoeH+2bt1Kfn4+ISEhvP322zIzX4guQLL//HWi2a8oCqqqYjabeeutt0hOTqYYL2zhl1Li0DyTzd28hZe9PmJ8fy+cfIJhyn+k96c4Z8iSVSHEWXfo6NfhsxtUVeXpZ+bzw65aykJGY0OPk4PCtNggVr31BAdycygoKCAwMBCdTkdkRDhledvJzali0aJFzJ07V0a6hBCiEzpe9s+fP5+1a9cy6IJJ5He7kOS9pQC41Flw2Pw5luxUHAID2WproLKykgMHDmAwGDAYDB35toQQQhzDiWT/urVruGT0cObMW4iid0BRFJLSN7PbO4rGHiMBcGyqxnvnT+Rs+J68y404eAcddZmqEF2VFOSEEGfdof0hDm2mqqoq36zeyPsFJrSQUACGh3jwwvVR9DS40bg5miTVhsFgwMXFhZGxsfxjWCNZ9Y1sLNLzU4o0ZhVCiM7qiOwvMmPy0KO6+pGRmcX/ln5MZbcYdtaGwd5SXB31PHhRPwpWbSTFQ8MUGYmLiwsRERF8/fXXNDQ0kJeXh8VikdnRQgjRSR2e/WazGUVRMBgMZGVlsfTD/3FrjyKi8rdQ/ZMzXpc/zbYyyIm4lUbNGQCf0izG+5TyY/Z66hsaeXaDlSueeBJTr4jjLlMVoiuRgpwQ4qwzGo1ER0ezdu1aoqOjMRqN1DU0ccOC99nSGAC+oaj11ei3fsu/73uWEKMH8OcuSfa+D64aum/vp7ufC4rSSL3fIGnMKoQQnVSr7B8xAmP2+2h5aazaXcMTG32xTpiNq08IALHdPXnhb8MJdalFHROHpbjEnv1Wq5VvvvkGRVHQ6XQd/K6EEEIcy6HZHxUVxaJFi0hOTqa+vh5N09BqLEQFqhicbdQe2MbTH6fwxR8lgDPdvJz41zWDGeAzAqvVyk/ffNk8u06noJ5AzzghuhopyAkh2kXLRZROp2NjThkPf7qZfU2BoAMlbxOkfoKj1sCSJUuYN28eiqKgKApGo/HPPhMAodEEAZ6+Axlx6ROyXFUIITqxluz30NWhy8ukoszCZ1VR5IaNB52Cj1bByIJPCXQeQnDGBshPRwkZgXHMHCzFJfZBl5tvvpk1a9YwduxYmRUthBCdXEv219XVkZmZSX5+PgcOHACgvKyGDbkOeLiO4MM911FBCWgaEY4WPpp9I3VVFZL94rwhBTkhxFlnsVhISUmhtKKab3IceOfNJDTAVdeEcd9vjAx1Y2OoibKyMlJTU1staT2iB8XYh9HVFuMpo2RCCNGptWR/WVkZK1MzGNp3Ak8XBZPj0NzcfaqyhodZSp5HI+9nVtDUwwvnpnK03FReSZjL7ykZ9uyfO3fuURuECyGE6DwOzf7MzEwiIyMB8PT0ZNu2bSiuXrzpeSdufhMAcKwvxW3rl+DSSMLT2WRmZkr2i/OGFOSEEGeVqqqoqkr3qInsqDTR6OwDwDXDQ4i/fABNNaMwGAwkJiaSlJRERESEvWH30XrPyc5KQgjRubVkf0xMDBvSNtE0eArTtjbPeAjyduHJkE1cUvYLpaUKOxv98e4zAodeBjiwkWqfMFakpFNYaG6V/TI7QgghOrdDsz8lJYXY2Fji4uIoKSnB19eXO+a+zPrG7uDiBZrKAC2PGB8Lm1ybiIyIIDd7I+bCUsl+cd6QgpwQ4qxRVZWnFyzk+xyFEv/B4KwjyNuFhX8dxISwg0U1DxcA4uLiiI+PJyMjg8TEROLj4zEajcTGxtpnyEm/OCGE6PwOnd3cbfgkSmPuwVzdBMDNsd157LIwPJ0mQM0t+FitZP7r32zNyGSheyzxs/+Nu7s/MRsTJfuFEKILOTT7o6OjWbRoESaTCUVRcPLw5eEvMlmvRIIL9PR1pk/JBgozk3CIiWHRW/8lYPsH7HYtJjnAyr7QGMl+cV6QgpwQ4qxZtXUfH5X2pNHfF4CrIv1ZcO1wvFwcj7hvSUkJmZmZmM3mVjsytYyqyVR1IYToGiwWC+tS0tnjFUVGY39obCLUz5Vnrx7MBX39/7yjZyAlZjMZmVmYzWaSkpPJyrma8PAA+6Y+kv1CCNE1WCwWkpKSyMvLQ9M0Zs2ahaIo/JJZyONfZVBc3YCig1kX9uGGQd78/e5XMJvNpKSk8LcrJhCYn06/IC96dPfB8dqZkv3ivCD/yoUQZ1yjVeWlX7Yz/ZNsGl180WrLCdzxFS/dEHVEMU5VVcxmMwaDgdjYWAIDA4mJieGtt95i2rRpJCYmygWZEEJ0ITvLNXb2uY7G7jEA3DayOz/PHteqGHd49ptMJurr63n00UdJSEgAsM+sEEII0fn5+vpSWVlJQUEB9fX16F09efCTzcz8IJ3i6gb6BnjwxT2juH2YL90CDEyMiSTQFEB9fT3/fPJfrNxdA+4BOPcZjSLtacR5QmbICSHOqG0HKpj98Ua2F9UCYN2ThDV5KYbIMEpKSlr1gTh804aW2XCqqjJjxowje8cJIYTolFRVJbfAzLvpJbyzbh+4+KBVF9OraC33PrgANyeHVvc9PPuzs7N59NFH7bOkJfeFEKLzU1UVi8WCwWBg3rx5bN++HUVRaDIO4NJX11Jc04Sig5nj+vCPiX144bl/kZKcxJxojdl93Lg5bCDT3ttGobmIl1JNRN72FMYeA2XjNnHekIKcEOKMUFWNd9btZeEPmdhQcNKaMOb8zr51X6BZrURERNgbvbbMeDh804aWgp2qqtI7TgghughVVZn9zMv8XG6iwcUXdDrUnWtoSP6ImJuuP6HsDw8PZ+TIkZL7QgjRRRw6uBIREcHWrVtxdPNEN/w6cnqOhZomevu788LfhjC8u699wKWxNB/3snKsFcEEeOuYGDuY31MyiImNxSDFOHGekYKcEOK0FVXW89BnW1izsxhQcCzeQY+idfQPNeESFsbw4cNxdXVlxowZ9m3MFUU56qYNiqJI/yAhhOgCrDaV577fwrd1/cFFwaGphmFNWZSWpzL8xr+dcPZL7gshRNdy6OCKqqp49Y3CdcAtWJ29AQ1D8RbGumkMDRkHYM/+lGSNGt9uOHq7owuNZvaNc7i5WPpFi/OTTtM0raMPQpw/Kisr8fb2pqKiAi8vr44+HHEG/JxZyGNf/EFZbRPODgrDlX1UpH9PfV0dubm5qKrK1VdfTVZWc9PuwMBAlixZYl+K1DLVXU7CQpy7JPvPTTkltTz46WbS95cB4FW+E9/dv3Bg307JfiGEZP85rmWG3PrkVPL9R1AZGAWAu1aHcc8yqvduPnr2+xtQ6krBzV9mxInzmsyQE0KcktpGK/O/z+KjlFwAwoO8+PeNQ+ntP5mMjNHcd999FBUVAbBp0yaioqLQ6XRHLEVSFEX6BAkhRBeiaRpfbMznqW8zqW6w4unswNNTwunrEMp9930p2S+EEOcBRVG48vb7+FmfQmWlFYCGzOX0bthG9LDBZNYFHjv7ZeMGIaQgJ4Q4eZkHKrh/6Sb2FNeg08HNw03ETxmCq5Mjqqry1VdfUVhYiKOjI35+fowdO5b4+HhKSmQ6uhBCdGXltY3Ef5XBD1sLAIju6ctLfxtKsI8L8+e/LdkvhBDnsJYZbr5+Bt5cvZdXl+/EpmpQV0HdqsV41+Zx4c03S/YLcYKkICeEOGE2m403fsvi36tzabRpBHo5M6xxK5vfe4MXsmPt/X9SUlJwcXFhyJAhvPzyy0RGRspsCCGE6KJaLsD2Vut58NMtFFTUo0PDaE4h0s2RYJ+RmM1m1q5di4eHB927d+ell16S7BdCiC6qrbYCLUtUV2/aRkXYFIpUDwA8Srdj3PYpDv7uvPjS55L9QpwEKcgJIewO3br88FGt0up6/pr4BfttPgBMDDMyfZAzCU/8htlsZvXq1UyfPh2j0Uh9fT1msxmj0Uh4eLiMjAkhRCd2rOxXVZX5CxL4Ya8Ni2kEGjq6eTrgsukjKvdlsDbPl4KCu1iyZAk5OTkATJkyxX5BJoQQonM6WvYfuntqy4Y8AJmZmfy0vZyC3teiqc64OymM0HYxtPhFhoY1ogWPIDJCvvcLcTKkICeEAP4c9UpKSqKhvg6Th56wqLHEz51Lek45932YjtnmA6qVoMIN9NRqWPjZburq6qmuqsSpqZy3/vtfZt59Ny4uLgQFBeHi4kJJSYmMkAkhRCd1aPbX1dWhV3RMHhPFnHkLUfQOZOzJ5xOLiVpTMAAhTXl4bPiRxtoqKisrKSsr45VXXiErKwtPT098fX2ZOXOmXJAJIUQndnj263Q6hg8fTmJiIiUlJfbdU5OTkykoKOD5f7/O8spAqkImNj9B0U4uNBRTsSOZEd1UAtwc6NHdsXmjBukNJ8QJk4KcEAL4c+vy/LxcbgjO44JAJ/bmmHnqk4l8uLUSm6rhpavHuPsbZvfeR0D9fvzc4Zv63jwco6O/Rw37878AbQYjR460j6od2shVCCFE59KS/bm5uezds4dHRikMz9tC9Y9OpPS+l39+sY1a92AUWyMe2d+TveEbnJycCAsLo6GhgYryctb+/CXjLr3avnmDDMIIIUTndmj27969G6vVSlJSEgCJiYnExsaSnJzMiBEjmP2v/5KsC0fx9gHVhvbHt5Rt+IxlBgPXXnM1+8oLMXk64NR7dPOuqUKIEyYFOSEEqCpGV43oESNwtVVyUd8ScHLlK25m85YKAKYM7cbTVw7k/55ZSUB9Dq62Kvq7aYTW1jG2jytKTTWB7nqUulLi4uKkkasQQnRyqqqiqipRUVGUl5cT5O1AVIAVdwcrT6y38fW6jQBEdPPCuONbPvv9YxoaGnB2dqZ///4cyM9jRiyM7lHJgOFWdLP/iykwSHJfCCE6scOz38HBgbq6OqxWK19++SVz5swhPj6evAMFTP/3t+xw744CWEtyGee0h7Q9q2lsaMBsNlNdU8vEJ38kyMsRxSMAJP+FOClSkBPifKeqsOYFdLmpjKWaHoFFVPv05XHrDA6ovmBrIrhgLXGzH6ahuoKUzD34uWn0c9PIrnbHovkSNGIETkVbWLe/kRl3/p0JEyfxxBNPyEWZEEJ0UocvVzpw4AAVdTpWlBpIM81hr9YXgGljenHHMF/uvH0TNpsNnU6Hv78/8fHx9AvyZnTxR/g4NrFvzWesy3bgoSee7eB3JoQQ4mjayn5FUdDr9fYfgH0ltdzz6Q52KN0BqN78E+47lvHsqhX8nzu8/fbbNDQ08PHHH+Pm5sZzzz0nxTghToEU5IQ439UWQ14aTRUH8KnIY7X3aBY0XI9V54C3rg7/vd8xfkhfAgKa+0HExI7kpySNFZXV1Os9iB05Co/L4jDvyeTGRybgaK0iKyuLGTNmEBwc3MFvTgghRFvsbQry88nPz6e+vh6nnsP5LOzv4OSBE1ZeuzWGiyOCUFWVcePGkZOTg81m45ZbbiE4OJgH5yZQ+FkjW396m3X7Gnk9Ywk3zZgt2S+EEJ1UW9mvKArdunWje/fuTJp0EatyG3n6u7XUNdlwxoptw3t4523hllubs3/hwoVUV1ezaNEiampqePvtt3nwwQcl+4U4BVKQE+J85+YPISNosOpJdL2OVLUfAJeaKvjXzL/SUD221dLTuLg4srOz6d+/P2VlZfbbLLUa9w1tYniAExuLGikptsiJWQghOimj0UhsTAze+gb8/PzY5z0YdcDFAAw0ufHf26LpbvAAQFEUHn/8caZOnYrBYCAoqGVZqkLRgFuZds9rHChvwsHRhsUi2S+EEJ2V0WgkOjqa+vp6fH19yc/PR6fTcdNNN3HT7dN4ZZ2Zd7/MAGBUbwPPXxtJaV6vVtmvKArTp09n0aJFaJpGdXW1ZL8Qp0gKckKc7xSFXQNmcXdKKrvVevQKPD4xhLsmXIpOrwd3V/tdVVUlMTGx1TboLYW68B4B1Az0wcVWhcHgSXgP2WFJCCE6KwWIH+dMfqCBh8v+yp6y5uLbbSN7EP+XgTg76O33bZX9MTHEz57ZvIueomAMMFGneKJ3qMTT01M28hFCiE5Op9Oh0+kYP34806dPR1EUCpucmfbxFnJKa3FQdMy5pD8zxvTiX4kLSU5OJjo6mpkzZ2IymVAUBZPJhJeXF5WVkv1CnA5Z6C0ASEhI4IILLsDNzQ0fH58275OTk8MVV1yBm5sbAQEB/POf/8RqtbbvgYoz7ufMQqa+sYHdJfUEernw6d0XMO2iIc3FuMO0THNv2QbdYrHYb3PwCiTm6nvpM3gUMVffi4NXYHu+DSGEECejtpj0Hblcvf+vJJd54O6k8H83DuOZqZGtinEAliIz29PXUFR4gJ65n9H0+d2w5gVQVYKCgnjggQe44IILeOCBBwgKCuqgNySEEOJ4LBYLKSkplJWVkZqail6v54dddfztv0nklNYS4uvKZ7NGMWtcb7ZnbyMpKYmCggKWLl3KbbfdRkJCAqpkvxBnjMyQEwA0NjZy3XXXMWrUKJYsWXLE7TabjSuuuILAwEDWr19PQUEBt912G46OjixcuLADjlicLpuq8fKvO/jPil0ADAv24M3bYjB5ux71MUaj0b4NemxsbOvRMEVBf+EjeEXf1bwMVhq7CiFEp6RpGu9trmbB3kuxajr6e9Tz5sxL6B3geeSdVRVj9vs8MdTCloAGhnRzwqmpHPLSoLYYxSOAefPmMWvWLNlZWwghOjmj0UhMTAxr1qxhcPQo4pflsjy7CIBLIwJ59trBeDrr7Rs/tCxtra6upqyszD4gbzKZJPuFOAOkICcAePrppwF4991327z9l19+ISsri99++w2TycTQoUOZP38+jz76KE899RROTk7teLTidFXUNvHAx5tYtaN5hluEg5nGn//LW+XRrZahHk5RFOLj47FYLG2ffBWleRmTEEKITqmu0Ub8V1v5clM+oMO/cjsjXWvp6f/Xth9QW4ySn06/IC96dPfGMWQIOst2CBnRPPgC9uVLQgghOj9N06hzD+Kb+oHUZBfhpFeY95eB3DKyBzqdDrPZTHJyMmazGZPJRGJiIl9//TUpKSmtBuQl+4U4fVKQEydkw4YNDBo0qFXoTp48mXvuuYfMzEyGDRvW5uMaGhpoaGiw/15ZWXnWj1UcW3ZhJTPfTyentBYXB4W4i7rz2QtvtFqGeqyTq5x8hRDHI9nfOeWU1HL3/9LYVlCFXgfGA+toyvyFjYGBR8/+gxv/6PLScA4ZAWPmQF2pzIQWQhxBsr/zUlUVi8WCzWbjpz2NFPa/FjQ9oT7OvHFrNJHB3vb7Hr4iJjIyksjIyKMPyAshTpkU5MQJKSwsPOKLesvvhYWFR31cYmKiffad6Hg/Zxby4CebqW200c25ntdM3zNYG0BOTAzJh416CSHEqZLs73xW77Bw/0cbqaizom+q5WL3XIJ6O5NaEnjs7FcUGPsw1Bb/WYSTmdBCiDZI9ndOVquVxx9/nNQtGdiibqIw6AIAeutL+fof1+Pl2nql09FWxMiAvBBnnk7TNK2jD0KcHY899hjPPvvsMe+zbds2wsLC7L+/++67zJ49m/Ly8lb3mzlzJvv37+fnn3+2/622thZ3d3d+/PFHLrvssjafv62RstDQUCoqKvDy8jqFdyVOhaZpvLZiFy/8sgOAEKWMR4vn0sOpCmf/UPrM/hFLnQ7AvnuSEEKcKsn+zkPTNJas3cvCH7ehatBUuJPS754j1ODBihUrWl1oSfYLIU6HZH/no6oqjz36CJ9++yPWCXNw8AnCUdEx+8IQ/jrIn8DAQMl+ITqQzJA7hz300EPccccdx7xP7969T+i5AgMDSUlJafU3s9lsv+1onJ2dcXZ2PqHXEGdHXaONR774g++2HADg2iFGkt94ljR9EUo3HdtzzVxfbePtd961T00/Vh85IYQ4Hsn+zqG+yUb8Vxl8sTEPADfzFrYvfRq1qZFizRdVVXn77bcl+4UQZ4Rkf+dTWHCAmopCHKYmgM4JtcrCa3eOIvmnT5n5f5L9QnQ0Kcidw4xG4xlbfjhq1CgSEhIoKioiIKB5qcqvv/6Kl5cX4eHhZ+Q1xKlp6QnRVk+Hwop6Zryfxtb8ChwUHU9dGc7uX94jLzeXhJwGjO46mhwbmFhcQnJy8gn3kRNCCNGxjpX9AEWV9cz8II3NuRXoFR0j9PtJXrkIzdqETtc8I7qkRLJfCCG6kuNl/6H3cffyYdrry9jmdyMAEXXp7PzxLQJmfC/ZL0QnIQU5AUBOTg6lpaXk5ORgs9nYvHkzAH379sXDw4NLLrmE8PBwbr31Vp577jkKCwuZO3cu9957r4yEdSBVVUlISGhzdsOm/aVMfy+NktomfN0ceeOWKHq5W/k4NRUPDw+cnJ2p1vQEGfyPaN4qfeSEEKLzOlr2t1yEHWhwZNb/NmKubMBb38DzA/fwfx+vwNPDAxcXF/R6Pf7+kv1CCNGVHC/7WzI8ISGBNRszsfSfSpkuCJ2mcmXlJ/jv/JZdjibJfiE6ESnICQCeeOIJ3nvvPfvvLbumrlixgvHjx6PX6/n++++55557GDVqFO7u7tx+++0888wzHXXIArBYLPYRrqSkJLKysggPD+enjEIeWJqODQVfXR1f//1Cevh7oKoqsbGxaJqG0WhEr+iYPCaKoEBTm81bhRBCdD5tZX9YWBiJiYn8nF1CQegkbCj0dS5nsfFTeuBERswglmvNs+d1Oh3Dhw/HZJLsF0KIruJY2d9SXJs+fTrLM/LY3+tqNJ07TloT3fb+SH7FfrK0EVw1JUqyX4hORDZ1EO2qsrISb29vae56hrSMlCUlJVFfX4+ziwvuw68itSkEAMfiHfQtWs27i960T0VXbVZKcrbjG9yHul8X4lG2DV1odPMuenJCFkKcBZL9Z9bh2e/i4kJEZCQrilywmGIAGNPLizf6JONpToGQEVgvmE329h307duXJ598koyMDEaOHCm9g4QQZ41k/5nVVvZHRkaSkZGB2WzGFBjI+Lvn8/q6fDR0+Cs1fDZ7MjVFuZL9QnRSMkNOiC6sZVvyrKwsHnk0jt2+I2g4WIzrq+XjVLCcUSObp6KrqoqlyIwx+32M+ekQEIZn2TaoKYK8NKgtBo+ADn5HQgghjufQ7H/00UcptJSQVx5Ihak/AJEOhbwz7VIcldGo1UWYq20sSvwXKSkpRERE2C/epHeQEEJ0HYdnf8sGexEREdRbNWqG3MBr6w4AOq4IN/DQhYP54M1XJfuF6MSkICdEF6coCsE9+1ASeT0NOl9AI9Yxl+qN3xMZGUlcXBzQ3E9ie/oanhhqoV+QFzpNA1M4FOkgZAS4+XfsGxFCCHHCFEUhLCyMvpHD2Fvbk1r3IHSoGPf/TnSYD3pFhwokvLqI1atXk5OTg6enJ5qmERkZiU6nk95BQgjRxbRkf2RkJAAxMTFU2JzIDbueRpsvjnodT/wlnL2/fsDdH0j2C9HZSUFOiC4ut6SGK1/4iXKdLw6ajYQr+/LBv97EbDaj0+koKSkBIDk5GXNhCclGKz26++AcGg1j5kBdaXMxTqatCyFEl6GqKo8mvMSPjeE0uXvj4aTgv/1bqnenk1oViMViAZqzv7S0FABfX19GjhxJXFwcJSUl0jtICCG6GFVVSUxMJCMjg8jISIZOvp45n2dic3XBoamGN66PYlA3V6alSPYL0RVIQU6ILiwzv5xbFydRrrmi1FfSI+9nxvVJZMchOycZDAYsFgsxMTGkpKSwLzQGx2tnNi9PVRRZpiqEEF2Mqqp89Hs6X1X3RXV2xrGxgkW3juS3L0NIrslvM/ujo6OZOXMmJpMJRVFkqZIQQnQxqqqSlZVFUlIShWYzpYZBfP7NbmwOLrjWmpliKGL8oKsl+4XoQqQgJ0QXpKoq36fu5KGvttOEHsdaC732/8iYqObp6y0jYAaDgYSEBNauXcsFF1zAokWL7Cdis+ysJIQQXYqqqhQUFDDn1Y9IoT+a3hm3mgKm+BfR029C6+xfsICMlJVERI9rlf2yq54QQnQtLdn/6quvkpmZSV1DE7bh11PgFw4a/HVYNx4cM5xuJiPz589nxYoVjB8/nkWLFmE0Gu2rZYQQnY98GxOii1FVlbuefp0HvmguxjXlZcLyl3j0gbux2WzMmDGDxMREjEYjFouFpUuXkpKSwscff2x/joSEBKZNm0ZCQgKqqnbguxFCCHEiVFVl/vwFjJnxDMnKQDRFj1f5Tl6Z0hsntaF19heZ8f5jEdP8N+GzdQlozTkv2S+EEF2LqqosWLCAcePG8dprr7ExaxcFA/9GuV84aCoxTnm8cO1gugcHYTabee2119iwYQOvv/46VquVxMREyX0hOjGZISdEF6JpGi//tJWVDb1Agbrtayn58WWc9ApPPvkkFosFDw8P++5JqqpitVpbPYfFYiE5OZnCwkLZZUkIIbqIQnMRX+7Xow2+CoDajd8SXJvJc7u+Jzc3t1X2U1PMYL8G/J3A2bkRpa4Ui8VBsl8IIboYi8XC6tWryc/PB+9uOFwWR527Ea2hFtuat6gxOVFcPBWTyYTFYqG2thZVVamrq2PXrl2S+0J0cjJDToguQlU1nvk+i/9bkweAd2E61tWLcHbQo9PpqKysBMDPz8/eP2jx4sXo9Xr8/f256aabMJlMGI1GYmNjCQwMlF2WhBCiC6hrtPHkL7lUBAxF01QqVi7BJfsnXJydKS8vB1pn/1sffomzHrp56ugebMLYY4BkvxBCdEFGo5Hhw4fj2mcEATc/h97LSKBq5qZ9T2HN3UJkZCRGoxFVVfnyyy/tjzOZTIwaNUpyX4hOTmbICdEFNDZaeejjVL7Lat4t6bHJ/bnAEMoXPWysW7cOVVVxdXUlNjaWGTNm2EfJUlNT8fDwwMPDg+nTp9t7BsXHx0sfISGE6ORUVWVnzgEe/WEfm3MrcNIrRFZvpMK9gjF33oleryclJYWrrrqqVfbv3LyBCYEOlFn1hIT0QqkvB48AyX4hhOgCVFXFYrFgMBgoLi6m7+Uz8NaNA52OIbrdPOv6NpXda3Drfz1xCQkoioLZbGbDhg04ODig0+no1asXFRUVkvtCdHJSkBOik6urb+Ke175gpcUTPTaMe5bx6fwX+c7VlZiYGD744AN7w9ZDT7ZGo5Ho6GiWLl1KTU0NS5YsYe7cuSiKIrssCSFEJ6eqKnHzn+OrshAaXXxRrPX4Z31NvbWEESNGMG/ePBRFOeJCy2g00m/oBWz8I5MhhkZy86yMd/VDAcl+8f/t3Xd4FOX6xvF7d9M7JJsCBEgQ6b0EUECOHEDRn12OooKiCHbBAoJIi2CnqNgpir0fy1FEqUJoAobeQiCkLIF00nbm9weHPUQ6wm4Svp/r2guymew+O5nckzz7zvsCqOQMw1BiYqKWL1+uouISZdfrobzI1pLFongzXR//85D80huqoEYTte8zRlbb4T/n7Xa7unTpoj/++EPFxcUyTVPh4eHkPlDJ0ZADKrHcQ2Ua9O7vWuUIlp/KdF/eNE1dtEqZBYbi4+NlsVg0ZMgQeXl5HXOytVqtGjx4sJYsWaKDBw9qxYoVzB0BAFXEis2p+iI3TuV+QXLm71fOt89KJWkqjI6T1WpVdna2oqKijp/9996rAXcs0Q8Z++WbblWz/dlkPwBUAQ6HQ8uXL9euvRnKaXaDfCJbyTQN+W36Uf5GqvIefVv+CXcqOCBCOmrEm9Vq1ZAhQ7R06VI5HA75+/u7zhMAKi8ackAllZVfrAHvrdSm9AIFqFhPHpqutJ3rlH3IIj8/P0VGRp5yPoioqCh169ZNSUlJzB0BAFXE2j05Gvr5VpX7BMk4mKacryboiVa56ljLS/us5dob1/GU2d+1W3clJSWpI9kPAFVGeHi4CgwvHeo8WD5hdWSUHtLBH15RZFmGOt5xh+yRURUacUeLiopS9+7d+b0fqEIspmmani4CF468vDyFhoYqNzdXISEhni6n0tpzoEi3vZuk3dlFqhngpZrr5sqyb51Ss4sUExOjq3p0Uv/BDysqOuaU80EcmYeCuSMAeArZf/oWb3Po3vdXq6jUKf+iTNmWvqWgUode7l6i2Bq+iqjfTL43vSVrSPRJH4fsB+BpZP+ZW7R+h+5/f4XybSEKLDuozG9ekE+RQ02bNtX777+vmJiYk3492Q9ULfyUApXMtsx83fjG79qdXaTYmv76YmgXdW/dUL7hsbr11v769vHuGn7RLsVsm3taP8BH5o7gpAwAldt36/fprlkrVVTq1KUXheumiHTVj4nQFdffquKQeKXnObV8b7kUGHHKxyL7AaBqWbAlS0M/36p8W4jqm2l6rvR51bMdUFBQkLp163Zal5+S/UDVwiWrQCWycV+ebns3SQcKS3VxVJBm39lB1pJ8jRw58vCiDf6mrP9+SCrMkvaukor2S0GRni4bAPA3fZiUqlFf/ynTlPq2iNaIy2opJupJZe93yH/V69r8y25t2C99tUNqypxwAFCtfLwiVaO+TpbTMNWlZoFeCPpOn87br+3pBYqw+2jQoEE02YBqiJ9qoJJYtydHt7y9XAcKS9Widqg+uidB70x/SYMGDdKkSZMODz0PipRRu51KvMNk1G4nBZx6lAQAoHJ7Z/FOPfXV4WZc/4S6itzxg4bee8/h7A+wKDhns+qE+apJuKnuHVowLxAAVBOmaerFn7ZoxJd/ymmYCju4RRcf2irrPyfozY1BksXi6RIBnEc05IBKYFXKAfV/J0m5h8rUtm6YPrg7QeUFB7Vl9WJlZqQrKSlJDodDhqTERSUa9O0hJS4qkeHpwgEAZ800TU2bv00Tv98kSRrSvYHuTwjXksWLlJ7+3+wvMmXWaa8CBWhTfpAKTH8PVw0AOBfKnIYe/3y9Xv1tuySp5r7lsq6aq1Urk6SgSN1ya39FRETIZrPpnXfekWHwmz9Q3XDJKuBhv+/Yr7tnr1JRqVMJcTU16cp6CvQyZVn1usa0zlKS3amU2MMr6jkcDiWtWKGMjAPKKV8hh8PBZUsAUAWZpqnJ/9msNxfulCTd26WWHv1HnJ5++mnt3r1bFotFHTp0kD0ySg7dofFT5mvL3mxFOVaR/QBQxR0qdeq+uav12xaHbBapk1eKViV9Kknq0KGDoqKiNHjwYC1ZskQHDhzQypUryX6gGqIhB3jQgi1Zuvf91SopN9S1YYTi0+bpwSHL5Feep8cv3q264b66qXMT+dw4WFarVXa7XQkJCSxnDgBVmGGYGvvvDZqzbLckKcFnr5a8+bq+fz5Xmzdvlo+Pj5o2barBg/+b/ZFRatSuq3LKyX4AqOoOFpZq0OyVWpOaI5WXqnzpO1qZvU3BwcGqWbOmK/ujoqLUrVs3fu8HqjEacoCHzN+UqaEfrFap09TljSM19p91NPTe5dq7d6927tih1oZVl9b3Vbv2reT334UbrFarRo0axXLmAFBFOQ1TT3y+Tl+sSZPFIj35j3r6buoM7d27V9u3b1d5ebm8vb3Vtm1b10gIsh8Aqj7DMJS8M03Dvtmh7Y5CWcuL5fhivIr3bFB8VLBq1o2tsJoq2Q9UfzTkAA/4dfP/mnEhuTsUm/qHYqJGKCEhQcXFxdq7d69eTCrTD5kh+nLcEIUcdQI+8o4ZAKBqKXcaGvbpWn27Ll0yDXXzTdXdPXrLsfx/2V9aWiq73a6HH364wh9fZD8AVF2GYeixCS/p27y6KvcOUlSIr1rnrNTcrO16qquPujfwUpOeLRV1xaAKk7yT/UD1RpsdcCfD0G9/bNGQ9//XjPNe9YGWLl6ozMxM3X333Zo5c6ZatmwpH19f+UfUkz2SkzAAVGWGYWhP2j4Nnb1c365Ll8V0KuTPT7Xv96+PyX4/Pz/Vr1+fP8AAoIozDEPp6elKS0vTFwtW65v8eJV7B8n70AG9fn0DjX5wkC7r2Fxd6vqoVqhNUVkLZf1mqLT4RYkFHIALAiPkgPPIMIz/DTOX9NsXM3Tv6joqlZd6R+bIlr9F83IOKj83R3fcfpuig70U27iNAgICVLt2bfn7+ys7O5s/zACgCjk6+yVp3PgJen+7TUadNrLJqSctc1To87ve2B6o2267TTabTW3btiX7AaAK+2v2T5gwQXPnzlWOb5T8ez0ii7efLAdSpN/f1mPr31N5ebkyM7K1zR4qu9OU0+mU9VCOtHeVVLRf+u+UNQCqLxpywDl25GQcHh6uSZMmuSZi7dL3Jg1dc7gZ18drte7c/Y4Gfluo7EJTdWrX0j/91qlztLd2Zu2V2ewqWSwWJnAFgCriRNl/x4A79dneIBl1GkvOcg3OnaoOttXKCpWig0O1cuVKWa1W7dq1S9dffz3ZDwBVyImy/6677tL8+fO136+Wgns9IouXt8r2/Kn6e39WvtXQypUrZbFY5O3tra+zW6u0WQe1blNDSlsj1WkvBUR4+qUBcAMacsA5ZBiGEhMTlZSUpGbNmik5OVmZmZn6JTlNMwu2ybB4qYd1rV4I/VyvrSnQngMlksWi+pFB6t4gUEEqkmHsV6pZpDfffFMxMTFM4AoAldyJsn/Z8hX6qSBWRRGNZTrLZFn6jkr8V+hAHYtWpEklXsHy9fVVYWGhMjIyVFhYSPYDQBVxouxfvny58vPzleZdS8F9bpXFalPRlt9V8Mt0XXP7bdq6davS0tJUWFgowzAUW7eeHhg5QVYvr8Mj4wIiJM4BwAWBn3RIklJSUjRo0CDFxcXJ399fDRo00DPPPKPS0tIK261fv15du3aVn5+fYmNj9fzzz3uo4srJ4XAoKSlJGRkZSk5OVtOmTeVbt6X21O8rw2KVT9ZGlW5cpIJrZmtecSv5BwSoY8eOmjH7MzXrNUCFCtSKfaZmzPlM06ZN8/TLAQCchuNlf1iNcOU2v0F7LXbJKFetnd/ry+ljVbtObdlsVtWuXVufffaZ7rrrLgUFBclqterzzz8n+wGgijhe9teoUUPNmjXT4nTJ2b6/LFabfPatVf5PU+Tn7aXIyEjNnj27QvZ///33evrpp2VIhy9TpRkHXDD4aYckafPmzTIMQ2+++aY2bNigV155RW+88Yaeeuop1zZ5eXnq1auX6tWrp9WrV+uFF17Q2LFj9dZbb3mw8srFbrcrISFB0dHRSkhIUIF/lPY1+D8ZFqtirQd1kWOxGre7VPb4FurarbuaNGmibt26KaZWbQVdOVbzAq7RK6ussnl5Kzk5WQ6Hw9MvCQBwCn/Nfv+AQGXE9VGaxS6bDNVL/UlXtq6rlg1q6dI4f0WH+euSOD/VDvPVpEmT9K9//Uv+/v7y9ib7AaCq+Gv2BwYGSpJ2+DRQeu3uksWqxrYsXWU/IH8/X/n5+WnlypXy8vIi+wFI4pJV/FefPn3Up08f18fx8fHasmWLZsyYoRdffFGSNHfuXJWWluq9996Tj4+PmjVrprVr1+rll1/W4MGDPVV6pWK1WjVq1ChlZmbq981pmvVDqkybt4LyU/XBk1cpwNlG4XUbybE/W6tWrVJRUZFWrVolh8OhqKgojUx8RQUKUHJysjp16sQcQgBQBRyd/fvSMzRgxnwVhF8si+HU5GsaqknofWrcuLGy9zu0Is2p+l4WpeQ7FVZkKirES1OmTFFgYCDZDwBViCv7M9KVnbpFj4xOVFrNdjpUXkeS1K95iB68rJXuvfdz+fv7q7y8XM2bNz+82JvVSvYDoCGHE8vNzVXNmjVdHy9btkzdunWTj4+P677evXvrueee08GDB1WjRo1jHqOkpEQlJSWuj/Py8s5v0ZXE8299oG/z42V4+cmZvlmR+35SnR25su1bI6W2l/3SYUpISHBN/HrkBHzkHTPXyqwMWQdQBV2o2f/WW29r9qYyGfU7SYZTPXx3atP8tZq9YoUSEhI0cuRIpcTepJ/WLFGjtpfKHnl4FVWyH0B1cEFmv2lo01t3S2mrFBh7gw5FdZcktffeqw0f/1vv7eyojh07SpKaN2+uxMREV8aT/QBoyOG4tm/frunTp7tGx0lSRkaG4uLiKmwXFRXl+tzxGnKTJk3SuHHjzm+xlczqrXv077z6cnr7ycjaoaA1HygmPkLlu5bJWpaj0h1L5d3mDo0aNeq4J2Cr1erarwBQFV2I2Z+VlaUvd9tk1G8n0zAUse07PTLuAT311FPKyMjQokWLdPfdd2vU6NFkP4Bq6ULM/uzULfLP3qC5gTdrnd+VkqS724Zp+ZwZysjI0OLFizVr1iwNGTLkuE03sh+4sNGGr+ZGjBghi8Vy0tvmzZsrfE1aWpr69Omjm266Sffcc8/fev6RI0cqNzfXdduzZ8/ferzKbs+BIj301XaVeweonrFXT5qz1KBujBq36yqvuM7alp6nT5ftVOKUw/PuRUVF8W4YgGrnQst+0zT15gqHciNbyzQNlSx6W1e1jFHTpk3VsWNH5efnKzU11TXnKtkPoDq60LJfkoKj4/Wieau++28zrpPXLo24PqFC9r/zzjuMgANwXIyQq+aGDx+ugQMHnnSb+Ph41//37dunHj16qEuXLscs1hAdHa3MzMwK9x35ODo6+riP7evrK19f37OovOrJyitW/3eSlJ5brAa+Ofog/HNFtYzXzZeMU3i9JnJkZWr81F+1ZW+2otJXuOaNA4Dq5kLKfkl68actmvl7qiSpz/4PtTOoUEOGDJGXl5fuueceLV68WAcOHNDKlSvJfgDV1oWW/eXlTl05dq52BnWVTEORKfP0ypSRZD+A00ZDrpqz2+2nPUFoWlqaevTooXbt2mnmzJnHvIvTuXNnjRo1SmVlZfL29pYkzZs3T40aNTru5arVjWEYJ5zjIbeoTLe/t0KpB4pUt6a/5rbaouj9NaQ67WWv10SyWmWPjFKjdl2VU15x3jgAQOV1suyXpNd+26bXFuyQJA33+lwJwcu0pNu/XH94RUVFqVu3bsfMGQoAqLyOm/2GIRXtlwIiVGaYGvLeYu20xMg0DJUteVc9ujYi+wGcEYtpmqani4DnpaWl6bLLLlO9evU0e/Zs2Ww21+eOjH7Lzc1Vo0aN1KtXLz355JNKTk7WXXfdpVdeeeW0V1nNy8tTaGiocnNzFRIScl5ey/lgGIYSExNdJ9VRo0a5Ts6HSp267d0krd59UF5lhbouZJeeGz1c1kMHpIAI6ag/4E71hx0AVEfVMfsl6YNlKRr9zQZJ0s1eSzW58VYV1miqwD5jZLV5VXgcsh/AhaZaZb8kLX5R2rtKZbXa6cpforXNGSGZhurs+UWXxPopMTFRXl5kP4DTxwg5SDo80m379u3avn276tSpU+FzR3q2oaGh+vnnn3X//ferXbt2ioiI0JgxY067GVeVORwOJSUlKSMjQ0lJSa5h52VOQ/d/uEardx+U1VmioNWztSnIIsf+gccdls7ErQBQdZwo+yXp23X79PR/m3H+uxZpU2Gysgc97xoVfTSyHwCqjuNmf6BF2rtKRn6mnlzmfbgZZzhVZ88vemPUYDVt2pQFGwCcMRpykCQNHDjwlHPNSVLLli21ePHi819QJWO325WQkFBh2LlhmHry8/X6dXOWfGwWXe6zS3uCLAxLB4Bq4njZL0m/bc7SsE/WypTU2JYlW+EGdUzopPDjNOMAAFXLibLfqN1eI5O89WXexbLIVJ2989Wrqf24zTgAOB1csgq3qqpD16WKw84tFosSv9+kd5bskkWmLtr1pS5tEqvB9w5h9TwA+Ivqkv1Wq1Urdh3Q7e8mqaTcUIBjg26sXaihQ8l+APir6pT9hmFq1Ffr9dHKvZJpqKv3Tj1//81kP4C/hfQATtORYedWq1UzFu7QO0t2SZL+uW+mhvl8ppC1b0umwUkZAKqRo7M/OS1Xg2atVEm5obLdf2jr+0/rtddelWGQ/QBQnRyd/aZpasy3yfpo5V6ZpqEDP0zRDzPGk/0A/jYSBDhDX6zeq+f/s0WSdH+HYF1r/KQIf0ONgvJlFGR5uDoAwPmQsr9QA95bofySctnLHcr4fIKcZaXKz8+Xw+HwdHkAgPPANE2N+/dGfbA8VTJNZX8/RfnJv5L9AM4JGnLAcRiGoczMTBmGUeH+xdscevKL9ZKkuy+tr5T5H2nZnnJlFphamW4q+5DFE+UCAM6BE2W/I79Ed7yXpOzCUjUOLNAzOaOV2N0iq6SgoCDmDQWAKuxE2W+apib9uEmzfk+RTFO5v7yuwg2/SiL7AZwbLOoA/IXhLNeUxNH6bcWf6pjQ6fBS51arNu7L05APVqvcMBWSs015ixdp564Uvb/GWyHrSxTXrINGNWvu6fIBAGehvLxco0aNUnJysjp1+l/2F5SU686ZK5R64JB8S3P1tG26GtQoVIcwb3l5eSmz+Z2KiYnxdPkAgLNwouyXpGm/bNVbiw5PUWNZ/Yny1/0sSbLZbLrzTrIfwN9HQw44mmGo8D/jdemBj+UXZNGPSYeXPnf6hujOWStUWOKUM32z9s+fqtWNGqpdu3ayWCyKj4/Xyy+/LC8vfqQAoKoxDEOjRo3SrFmzXDnucDhUI9yuoR+sVvK+PJnF+Sr48TmlXlqslrV9VFxm1ZXtY3TxY8OZQwgAqqAj2T971kxFBdu0Qoayd2+SvV4Tvb1kl16Zv12SVL7iY3ntWKjYGr5KzytXrdq1NWzYMLIfwN9G9wA4WtF+BR3cpDphPpJZqux68fIOCNHt76xQZl6JfIsPKH/B68o9mK0dO6zq2rWr3n33XVZYAoAqzOFwKDk5WV5eXiorK1NcXJxq1KipJ79Yr8Xb9stilKls/jTl7N2uUfPDVWdgM3W4KFDhDS6VNSTa0+UDAM6Cw+HQhuQ/9Wh7Q23sJapfJ0URS5/Rh0t6K3FDLUlS+R9fKSfpS427PFidYmtoS2Gw9sb9i9FxAM4JOgjAUQz/miqo0URRDVrqYFADLduwS30nfaOtmQWKDPbVP323qclF9eXr66uDBw/qo48+ci2L/td5JwAAVUN4eLiaN2+uVq1aqVGjRtq5c6dumDBHX/2RJpvVoq6WzWoc6S8/Xx9ZS3J1z4ep2tliuNR1uMSbMQBQJYWHh6tjs3h1rGVRnWCbankd1NfpNTVqw+FmW2MzVV5b5yvC31SLmiWy+xv6v7a19NTD9/BGPIBzghFygA4PWU9PT9fUqVO1cUOyEpo30PLkIu2I6KISI1gBPlZ1KVur7cmr1KFJPe1NTZGzYL+c5WWaMmWKNm3apISEhArzTgAAKrejsz85OVnx8fHauXOndvvGqbDs8Mi3Ll67tH/tItWrG6u+QRvVJKRQazIdemjkeHW/rAe5DwBVzNHZv2b1RgUFeal9LZsW5nfQi8VXy5RFTbyyVLLscznLy3XwkEVLU0pktVq07GCmUqe9o1GjR5P9AP42GnK44JWXl+vJJ5/UZ599puzsbIWGhso0Tfm06K0SS0NZZOrJS8L12bRfdWXwJrW3bdBd/QK0N8NbfziK9Pa33ygoOERJSUlyOByKiory9EsCAJzCibI/8OLOKvRrK0m6rVWo1rz/vdatW6cUW4lu7Wmqhrep1nanPl62Ucv9/Ml9AKhC/pr9ISEhSg0KVB1LB6U0vlWGrOoZH6C0rz/T5k2bXFfBTP7dpnfXFcjp61DbdvzOD+DcoCGHC5phGHrqqac0Y8YMHTp06PCdpqlOreL0rtlQktTFK0WfTpshf2eB2keZqhNiVVRgsWxhXvLytuiLFEOBNWooISGB5c8BoAo4XvYbhqFsM0ibfVtKFosutmZqzQevKz8/X2VlZdpfKq3YZ6iN3aKV6VJmfrmubN6c3AeAKsIwDI16aqS+mD1De7MPyfzvfXVadtGuhjfLlFX1rAe075sZKsjPV2lpqSwWi2w2m0xJOWU+CvA21ZzsB3CO0JDDBc3hcGjNmjVyOp2u+yLqNdQcs5ck6a4a67R12QJlZGSrRlioMr3rSnm7dcgWLGdQqHbnOtX7uhs0+N57WdgBAKqI42W/JShCWY2vl6zeCshNkXPb18p0ZCkmJkZxcXHauXOn3t0aJnuaVQdLrBp453VKTEwk9wGginBkZaqx4zu93tuq3/f46NnFpbKGxcjR9GbJ5iP/vFR5bftaaVkZiomJUXx8vDZs2CBfX181adJEISEhatmyJdkP4JyhIYcLlmEYKi8vl2EY8vLykmma8g6Llno9qTJ56/LAXRrZ0aZnD3XRyk0fKScnR4/vtalueA351aylt6c+p16BEbJH0ogDgKrieNnv5R+siOuflvxC5FPk0HVRB7Rsi1MZGRkKCQlReHi4iouLVbt2bU2ePFl2u503YQCgCjEMQ0ZehloE58lSalHnWG/FxkZI/zdW8g2Sb2GGbojcr983l7myPyIiQg0aNFBkZKRmz54tLy8v2e12sh/AOUNDDhckwzCUmJioRYsWac+ePQoMDFS5xUs1bhorp3+oLDl7dZFfmmzdJmhwY4eWLF2qAwcOqKCgQGagXR0SOsse14wTMgBUIcfNfqep8OufVlmN2tKhHPXy26777hmqtSuXKyYmRsHBwWrRooWsVqsSEhLUvHlzsh8AqhDDMJQ4caJid32kbmGH5PS16uvUIHn930Q5g8Kl/Ez1Dtypoffcpz9OkP0xMTFkP4BzjoYcLkgOh0NJSUk6cOCAysrKVO40FHTlQ3IGRclWmq+QPz/R0r0BcuzPVlRUlLp166akpCR16NBBgwcPZmQEAFRBx2R/ebmCegxWWXgDWZylCl3/sVICTVmtVnXq1ElJSUlKSEjQyJEjlZ2dzcgIAKiCHA6HtqxZou4xOSook/YV+urD2k/KGRQpW0m+QtbO1c4a/mQ/ALejIYcLkt1uV8eOHfXBBx8oNzdXfl1uk7V2C9nkVN+QvdpZI8C1SIPVatWoUaPkcDg4IQNAFfbX7PdpdZWsDbvKIlOXB6QqI9BUQkKCoqKijsl9VtMDgKrJbrfr4jaXaPXaZF0cIk0KeFjO0AbyVbmuDE3Vthr+ZD8Aj7CYpml6ughcOPLy8hQaGqrc3FyFhIS4/fkNw3CdZNPT09WlSxcdrNFENfs8KEma1DdO/S5pTPMNAM6hypj92f6xirh2pCRp2GV19ECvFmQ/AJxDlS37L+nSWc7WN8jWpKcszlK9dUsLXd46nuwH4DGMkMMF48jcQUeGod91113yjrlYNboOkSSF7F6kmzr35t0wAKhGjpv99vqq2e3wGzGB+1brvp5kPwBUJ8fLfmvra6QmPWUaToVv/lo9Wl5N9gPwKN4GwAXjyNxB6enpWrRokRwFpfLqPlQWm7ecKatUO/dPZWdne7pMAMA59NfsP1hUJp/LH5LVx1/OfRtUd38S2Q8A1cxfs//fG7JlNOkjSSpf/oGinA6yH4DH0ZDDBcNut6tDhw4qKCjQ7r37dPfslSq2+CrULFCzwjXq0rmz7Ha7p8sEAJxDFbM/TYNmLleRxU9BZpGaHVyuLp07kf0AUM0cnf27SgL13K+pkqSm5m61Di5UZ37vB1AJMIcc3MpTc0kcmUOivLxcAwYO1J5al6kkprVC/Gz69wOXys9ZyNwRAHCeVJrsj+mmklptFeRr01dDuyjEcojsB4DzxKPZn5UpIz9L/R57XqkX3yjZfHRlk3BNv62D9u/fT/YDqBSYQw7V3tFzSHTs2FE1O92g7WWxssjUa7e2Vb2IIElBni4TAHAOnSz7p9/SRg2jQyS5f5JxAMD5YxiGEidOVP09n6luTIRymtwnyUe1rHl6+ZbestlszBkHoNLgbQFUe5mZmVq0aJHS09P1nz9StKo8VpL09FVN1fXiSA9XBwA4H47O/h/X7nZl/6i+TdSjMX+MAUB1lJmZqfXLf1WEV5FGlfRXngLUsKa3fhx9vfx8GIsCoHKhIYdqzTAMvfXWW9q9e7d2789XWr3eMkypoW2/BnSu5+nyAADnQYXsP3BI+/6b/Rfb9uvOLvU9XR4A4Dw4kv3rdmRogvVe7bXEKKjsgNoVrVKwn7enywOAY9CQQ7XmcDi0cuVK+QYEyb/ng7L4Bak8a4eMlR9p//79ni4PAHAeuLI/MET+/3xYFt9AlWdslbHyQ7IfAKoph8OhFStXymz/L+0LbiaVHVL6189r9dLf5HA4PF0eAByDhhxc/u///k9169aVn5+fYmJidPvtt2vfvn0Vtlm/fr26du0qPz8/xcbG6vnnn/dQtafHbrcrISFBXh3/JZs9XiopVMCaD9X90i6srAQA1ZTdblfHjgmydLpdtpp1pEO5ClgzV90uvYTsB4Bqym63K6DN1SqL7SCZhrxWfqAIr1J17dqV7AdQKXEhPVx69Oihp556SjExMUpLS9Njjz2mG2+8Ub///rukwysl9erVSz179tQbb7yhP//8U3fddZfCwsI0ePBgD1d/fFarVRf3GaCDX/wpi0V6pV8rJTzxlaKiolhZCQCqKavVKnu3W5T3ny3ytln06h0d1HLEv8l+AKjGft6YqVXldSQdniv6ykdmSBLZD6DSoiEHl0cffdT1/3r16mnEiBG69tprVVZWJm9vb82dO1elpaV677335OPjo2bNmmnt2rV6+eWXK21DLjktV09/s0GSNLhzLf1fx4ackAGgmlu01aEXftoiSRrWPVb/bNOA7AeAamz93hw98slamaZ0e6e66tswUJGRkWQ/gEqNhMJxHThwQHPnzlWXLl3k7X14EtRly5apW7du8vHxcW3Xu3dvbdmyRQcPHjzu45SUlCgvL6/CzR0Mw9DW3Wka8sFqlZYbirXlaslbTysxMVGGYbilBgC4UHky+//YmqoHP/rj8CIOXvv13bSRZD8AuIGnsn/vgULdNXOFissMdY8Pkde6r3T33XeT/QAqPRpyqODJJ59UYGCgwsPDlZqaqm+++cb1uYyMDEVFRVXY/sjHGRkZx328SZMmKTQ01HWLjY09f8X/l2EYmjgxUdc//432Hjyk2qE+Cvrzc2VmZCgpKYlJXQHgPPNU9o+b+Kxuee035R4qU5OoAHmt+5LsBwA38UT2FxSX6v9e/EH7C8tU25KtlyxTFL/3M2VmpJP9ACo9GnLV3IgRI2SxWE5627x5s2v7xx9/XH/88Yd+/vln2Ww23XHHHTJN86yff+TIkcrNzXXd9uzZcy5e1kk5HA59t6tcBcH1ZDHK9WzfeHXp0EbR0dFKSEhgUlcAOM88kf1ZWVn6el+Aiv0jZCsv0qS+8ercsT3ZDwBu4u7sN01TD89dpQNGgGylBXrq0BSFlKQrobaXGtUJJ/sBVHrMIVfNDR8+XAMHDjzpNvHx8a7/R0REKCIiQhdffLGaNGmi2NhYLV++XJ07d1Z0dLQyMzMrfO2Rj6Ojo4/72L6+vvL19f17L+IEDMOQw+GQ3W6vMD/E9jyrHFEdJEkdLDt0SdO+6tp81HG3BQCce57I/l92FSs3rJFkGupm26bm8dep5SiyHwDcxd3Z/+qv2zV/20FZZajunp/ldXENeYXV0EXNO+ilIXfIHsliDgAqNxKqmrPb7WrcuPFJb0fPCXe0I3MulJSUSJI6d+6sRYsWqayszLXNvHnz1KhRI9WoUeP8v5i/1JaYmKhBgwZVmB/CkV+iRz5dJ1MWxZkZKkyer0mTJklihSUAqOpOlP1/7s3V+O82SZJaKUVZyUvJfgCoJo6X/T9tyNBL87ZKkiZc20Id4yM0fa2vpuy8SOo6XFHRMWQ/gEqPlIIkKSkpSa+++qrWrl2r3bt369dff9Utt9yiBg0aqHPnzpKkW2+9VT4+Pho0aJA2bNigTz75RFOnTtWwYcPcXq/D4dCKpOUqPbBXK5KWy+FwqLzcqfvfXyFHfoniw/3kv/HfyszMZP4IAKgmHA6Hli9frj179ihp+TJl796kgwWHdO+cFSp1GurWIEzlG34i+wGgGjk6+5ctW6Yflq7VsE/WSpIGdK6nnnH+2rBhgzIys/TrimQ59md7tmAAOE1csgpJUkBAgL788ks988wzKiwsVExMjPr06aPRo0e7hp6Hhobq559/1v3336927dopIiJCY8aM0eDBg91erz0iXMM6mAo8mKPCGrVUIyxU142aoT8tcfKSU6/1b6fPi9spKamc+SMAoJoIDw9XcXGxMjPS9XDrUgXOH6Fbd/bSPiNewZYSTflXW72WkaCkpCSyHwCqiSPZn56errwSQ498sUnlfmEKLNgr67o1Cu87UgkJZD+AqoeGHCRJLVq00K+//nrK7Vq2bKnFixe7oaLjc80f4W/qsgaBKsutLa/QAD0w5lmtNzvIYpFq7vpFYZYOGsXcQQBQLRzJfsMw5Ofnpyb1IhXnk6mXNnfUWq94WYwyhW3+XCUFncl+AKgm/pr94fZI5ba+TT5+YXLmZsiS9J6WhIfI4bib7AdQJZFWqDIMw9DEiRN12223aeIrb8qs014+YbW1J7Clfi5vJovVquLNC5W96nu9/fbbkpg7CACquqOz/80331RCQoK8Q6P1fVEzzbTdIEmy/PGFsrasJvsBoJo4Xvb7dPyXfGKbyyw9pOJ5U1WU49Ce1N368K0pkmmQ/QCqHEbIocrIzMzU3LlzlZGRoZ07d2rQoAWKaTdQYz5NUbn3fnkfypaSv1FoaKhWrFghh8OhqKgoT5cNAPgb/pr9CxYs0A23DtSN76yWIZvqGRkySnarKCiI7AeAauKv2T/iza+UW7RHklQrdZ4uubaXVq5IUr9ae9X+4Ccq/I+vgq8YK9GQA1CFkFioUkzTPDx/UGampk6brjdX52vhtv3y87aqh89O+VhNFRYWqmPHjswfAQDVxNHZP236dD27YJ8OyUfx4X66xG+vsjIzVVBQQPYDQDVyJPv3O/01eV6KJOnBf1ykL6ePVWBgoMpy09UkuEB1wnwUdHCTVLTfswUDwBmiIYcqIzw8XF26dFFQUJBCQkK0ameWXvz58HLnw7rHat+mVQoODlbdunV1zz33MGQdAKo4wzBkGIYuv/xyBQcHKyQkRAuzfLV0e7b8vW16tm8DrV+zUkFBQWQ/AFQTFbI/IlphfR+T02JT5/oherTnxbJarVq9erVKvUKUUm5XzbqNZYntIAVEeLp0ADgjXLKKKqG8vFxXXHGF/vzzTwUFBalx81ZKb3i1nIapK1tEa1CPJspc9r/VlbhcCQCqNsMwNGHCBH344YcyTVONGzeWV3RD7Y5OkCSNu6aZOjauXWFlPbIfAKq2o7PfMKXwqx5TSbBdwZYSvXZbB1mtFtntdlf2743rKJ8bB0tBkVyuCqDKoSGHKmHz5s1KTk5WYWGhJCmyz/3aklaumFA/TbqupWw2G6srAUA14nA4tGTJEmVkZMhisah2XEMVtuons9Cpa1rX0k3t6shisZD9AFCNHJ39/h1vkl+NePnaLPr4vn+oZpCfJMlqtZL9AKoFGnKoEho3bqzmzZsrOTlZ9btep8Vp5bJYpFf6tVZogLekwydnRkcAQPVgt9t16aWXKjU1VaYks/0tyip0ql54gCZe21wWi0US2Q8A1cmR7N9VGqzydtdJkiZd30LNaodV2I7sB1AdWEzTND1dBC4ceXl5Cg0NVW5urkJCQs7oa8vLy7VodbIe+TFTecXlur9HAz3eu/F5qhQAcK6cbfYbhqHMzEx99adDz/+6R942i74Y2kUt64Sdv2IBAOfE2Wb/9qx8XfPqEhWWGhrQuZ7GXdP8PFYJAJ7D+F5UGRarTW+sPaS84nK1ig3TIz0v9nRJAIDzyGq1KtcSqKmL0iRJT/RuTDMOAKoxwzD10EdrVVhqqEP9GhrVt6mnSwKA84aGHKqMNxbu0IpdBxToY9PUfq3lbePwBYDqrKi0XA98+IdKyg1d1siuQZfGebokAMB5ZLVaNO6aZmpWK0Sv3dpWPl78vg+g+mIOOVQJf6Qe1MvztkqSxl3TXPUjAj1cEQDgfBv/743anlWgyGBfvXhTK1mtFk+XBAA4zzrUr6nvHrzUNVcoAFRXvOWAKmH6r9vlNExd1TJGN7St7elyAADnmWmaahwdLF8vq6b0a62IIF9PlwQAcBOacQAuBIyQQ5Xw6q1tNG3+dg29rAEnaAC4AFgsFg28JE59W9aSPZhmHAAAAKoXGnKoEgJ8vDTiClZUBYALDc04AAAAVEdcsgoAAAAAAAC4EQ05AAAAAAAAwI1oyAEAAAAAAABuREMOAAAAAAAAcCMacgAAAAAAAIAb0ZADAAAAAAAA3MjL0wXgwmKapiQpLy/Pw5UAgPsFBwfLYrF4ugy3I/sBXMjIfrIfwIXndLKfhhzcKj8/X5IUGxvr4UoAwP1yc3MVEhLi6TLcjuwHcCEj+8l+ABee08l+i3nkrQvADQzD0L59+87oncK8vDzFxsZqz549F+QvM6eDfXRq7KNTYx+d2t/dRxfqKAmy//xgH50a++jU2EenRvafHbL//GAfnRr76NTYRyd3LvYPI+RQ6VitVtWpU+esvjYkJISwOAX20amxj06NfXRq7KMzQ/afX+yjU2MfnRr76NTYR2eG7D+/2Eenxj46NfbRyZ3v/cOiDgAAAAAAAIAb0ZADAAAAAAAA3IiGHCo9X19fPfPMM/L19fV0KZUW++jU2Eenxj46NfaR+7CvT419dGrso1NjH50a+8h92Nenxj46NfbRqbGPTs5d+4dFHQAAAAAAAAA3YoQcAAAAAAAA4EY05AAAAAAAAAA3oiEHAAAAAAAAuBENOQAAAAAAAMCNaMihUktMTFSXLl0UEBCgsLCw426Tmpqqvn37KiAgQJGRkXr88cdVXl7u3kIrkfr168tisVS4TZ482dNledRrr72m+vXry8/PTwkJCVqxYoWnS6o0xo4de8zx0rhxY0+X5VGLFi3S1VdfrVq1aslisejrr7+u8HnTNDVmzBjFxMTI399fPXv21LZt2zxTbDVF9p85sv9YZP+Jkf3HIvs9i9w/O2T/scj+EyP7j+Xp7Kchh0qttLRUN910k4YOHXrczzudTvXt21elpaX6/fffNXv2bM2aNUtjxoxxc6WVy/jx45Wenu66Pfjgg54uyWM++eQTDRs2TM8884zWrFmjVq1aqXfv3srKyvJ0aZVGs2bNKhwvS5Ys8XRJHlVYWKhWrVrptddeO+7nn3/+eU2bNk1vvPGGkpKSFBgYqN69e6u4uNjNlVZfZP/ZIfv/h+w/NbK/IrLfs8j9s0f2/w/Zf2pkf0Uez34TqAJmzpxphoaGHnP/Dz/8YFqtVjMjI8N134wZM8yQkBCzpKTEjRVWHvXq1TNfeeUVT5dRaXTs2NG8//77XR87nU6zVq1a5qRJkzxYVeXxzDPPmK1atfJ0GZWWJPOrr75yfWwYhhkdHW2+8MILrvtycnJMX19f86OPPvJAhdUb2X/6yP6KyP6TI/tPjuz3HHL/zJD9FZH9J0f2n5wnsp8RcqjSli1bphYtWigqKsp1X+/evZWXl6cNGzZ4sDLPmjx5ssLDw9WmTRu98MILF+xw/tLSUq1evVo9e/Z03We1WtWzZ08tW7bMg5VVLtu2bVOtWrUUHx+v/v37KzU11dMlVVq7du1SRkZGhWMqNDRUCQkJHFNuRPYfH9l/GNl/esj+00f2ex65f2Jk/2Fk/+kh+0+fO7Lf65w8CuAhGRkZFU7MklwfZ2RkeKIkj3vooYfUtm1b1axZU7///rtGjhyp9PR0vfzyy54uze32798vp9N53GNk8+bNHqqqcklISNCsWbPUqFEjpaena9y4ceratauSk5MVHBzs6fIqnSO5crxj6kLNHE8g+49F9v8P2X9qZP+ZIfs9j9w/PrL/f8j+UyP7z4w7sp8RcnC7ESNGHDOZ5F9vhGZFZ7LPhg0bpssuu0wtW7bUkCFD9NJLL2n69OkqKSnx8KtAZXTFFVfopptuUsuWLdW7d2/98MMPysnJ0aeffurp0lDNkP1njuzH+UL2wx3I/bND9uN8IfsrH0bIwe2GDx+ugQMHnnSb+Pj403qs6OjoY1bOyczMdH2uuvg7+ywhIUHl5eVKSUlRo0aNzkN1lVdERIRsNpvrmDgiMzOzWh0f51JYWJguvvhibd++3dOlVEpHjpvMzEzFxMS47s/MzFTr1q09VFXVQPafObL/7JD9Z47sPzmy/+yQ+2eH7D87ZP+ZI/tPzh3ZT0MObme322W328/JY3Xu3FmJiYnKyspSZGSkJGnevHkKCQlR06ZNz8lzVAZ/Z5+tXbtWVqvVtX8uJD4+PmrXrp3mz5+va6+9VpJkGIbmz5+vBx54wLPFVVIFBQXasWOHbr/9dk+XUinFxcUpOjpa8+fPd52I8/LylJSUdMKV4XAY2X/myP6zQ/afObL/5Mj+s0Punx2y/+yQ/WeO7D85d2Q/DTlUaqmpqTpw4IBSU1PldDq1du1aSdJFF12koKAg9erVS02bNtXtt9+u559/XhkZGRo9erTuv/9++fr6erZ4D1i2bJmSkpLUo0cPBQcHa9myZXr00Ud12223qUaNGp4uzyOGDRumAQMGqH379urYsaOmTJmiwsJC3XnnnZ4urVJ47LHHdPXVV6tevXrat2+fnnnmGdlsNt1yyy2eLs1jCgoKKrxTuGvXLq1du1Y1a9ZU3bp19cgjj2jixIlq2LCh4uLi9PTTT6tWrVquX/7w95H9Z4bsPxbZf3Jk/7HIfs8i988c2X8ssv/kyP5jeTz7z8larcB5MmDAAFPSMbfffvvNtU1KSop5xRVXmP7+/mZERIQ5fPhws6yszHNFe9Dq1avNhIQEMzQ01PTz8zObNGliPvvss2ZxcbGnS/Oo6dOnm3Xr1jV9fHzMjh07msuXL/d0SZVGv379zJiYGNPHx8esXbu22a9fP3P79u2eLsujfvvtt+PmzoABA0zTPLwE+tNPP21GRUWZvr6+5uWXX25u2bLFs0VXM2T/mSH7j4/sPzGy/1hkv2eR+2eO7D8+sv/EyP5jeTr7LaZpmuemtQcAAAAAAADgVFhlFQAAAAAAAHAjGnIAAAAAAACAG9GQAwAAAAAAANyIhhwAAAAAAADgRjTkAAAAAAAAADeiIQcAAAAAAAC4EQ05AAAAAAAAwI1oyAEAAAAAAABuREMOAAAAAAAAcCMacgAAAAAAAIAb0ZADAAAAAAAA3IiGHAAAAAAAAOBGNOQAAAAAAAAAN6IhBwAAAAAAALgRDTkAAAAAAADAjWjIAQAAAAAAAG5EQw4AAAAAAABwIxpyAAAAAAAAgBvRkAMAAAAAAADciIYcAAAAAAAA4EY05AAAAAAAAAA3oiEHAAAAAAAAuBENOQAAAAAAAMCNaMgBAAAAAAAAbkRDDgAAAAAAAHAjGnIAAAAAAACAG9GQAwAAAAAAANyIhhwAAAAAAADgRjTkAAAAAAAAADeiIQcAAAAAAAC4EQ05AAAAAAAAwI1oyAEAAAAAAABuREMOAAAAAAAAcCMacgAAAAAAAIAb0ZADAAAAAAAA3IiGHAAAAAAAAOBGNOQAAAAAAAAAN6IhBwAAAAAAALgRDTkAAAAAAADAjWjIAQAAAAAAAG5EQw4AAAAAAABwIxpyAAAAAAAAgBvRkAMAAAAAAADciIYcAAAAAAAA4EY05AAAAAAAAAA3oiEHAAAAAAAAuBENOQAAAAAAAMCNaMgBAAAAAAAAbkRDDgAAAAAAAHAjGnIAAAAAAACAG9GQAwAAAAAAANyIhhwAAAAAAADgRjTkAAAAUKmkp6drxIgR6tGjh4KDg2WxWLRgwQJPlwUAAHDO0JADAABApbJlyxY999xzSktLU4sWLTxdDgAAwDlHQw4AAACVSrt27ZSdna2tW7dq2LBhni4HAADgnKMhBwAAgPPu0KFDaty4sRo3bqxDhw657j9w4IBiYmLUpUsXOZ1OSVJwcLBq1qzpqVIBAADOOxpyAAAAOO/8/f01e/Zsbd++XaNGjXLdf//99ys3N1ezZs2SzWbzYIUAAADu4+XpAgAAAHBhSEhI0BNPPKHnnntO1113nTIzM/Xxxx9rypQpuvjiiz1dHgAAgNvQkAMAAIDbjB07Vt99950GDBiggoICde/eXQ899JCnywIAAHArLlkFAACA2/j4+Oi9997Trl27lJ+fr5kzZ8pisXi6LAAAALeiIQcAAAC3+umnnyRJxcXF2rZtm4erAQAAcD8acgAAAHCb9evXa/z48brzzjvVpk0b3X333crNzfV0WQAAAG5FQw4AAABuUVZWpoEDB6pWrVqaOnWqZs2apczMTD366KOeLg0AAMCtWNQBAAAAbjFx4kStXbtW8+fPV3BwsFq2bKkxY8Zo9OjRuvHGG3XllVdW2FaSNmzYIEl6//33tWTJEknS6NGj3V88AADAOWQxTdP0dBEAAACo3tasWaOEhAQNHTpU06ZNc93vdDrVuXNnpaWlacOGDQoLC5Okky70wK+vAACgqqMhBwAAAAAAALgRc8gBAAAAAAAAbkRDDgAAAAAAAHAjGnIAAAAAAACAG9GQAwAAAAAAANyIhhwAAAAAAADgRjTkAAAAAAAAADeiIQcAAAAAAAC4EQ05AAAAAAAAwI1oyAEAAAAAAABuREMOAAAAAAAAcCMacgAAAAAAAIAb0ZADAAAAAAAA3IiGHAAAAAAAAOBGNOQAAAAAAAAAN6IhBwAAAAAAALgRDTkAAAAAAADAjWjIAQAAAAAAAG5EQw4AAAAAAABwIxpyAAAAAAAAgBvRkAMAAAAAAADciIYcAAAAAAAA4EY05AAAAAAAAAA3oiEHAAAAAAAAuBENOQAAAAAAAMCNaMgBAAAAAAAAbkRDDgAAAAAAAHAjGnIAAAAAAACAG9GQAwAAAAAAANyIhhwAAAAAAADgRjTkAAAAAAAAADeiIQcAAAAAAAC4EQ05AAAAAAAAwI1oyAEAAAAAAABuREMOAAAAAAAAcCMacgAAAAAAAIAb0ZADAAAAAAAA3IiGHAAAAAAAAOBGNOQAAAAAAAAAN6IhBwAAAAAAALiRl6cLAAAA/+N0OlVWVubpMgAAlYy3t7dsNpunywAAnCM05AAAqARM01RGRoZycnI8XQoAoJIKCwtTdHS0LBaLp0sBAPxNNOQAAKgEjjTjIiMjFRAQwB9bAAAX0zRVVFSkrKwsSVJMTIyHKwIA/F005AAA8DCn0+lqxoWHh3u6HABAJeTv7y9JysrKUmRkJJevAkAVx6IOAAB42JE54wICAjxcCQCgMjtynmCuUQCo+mjIAQBQSXCZKgDgZDhPAED1QUMOAAAAAAAAcCMacgAAoEqZNWuWwsLCPF0GgGpgwYIFslgsrHANAHA7GnIAAOCsDBw4UBaLRRaLRT4+Prrooos0fvx4lZeXn9fn7devn7Zu3Xpen+NUjn7t3t7eioqK0j//+U+99957MgzjjB6LBuO5ceR7Mnny5Ar3f/31126/zO/IsWGxWBQYGKiGDRtq4MCBWr169Rk/1mWXXaZHHnnk3Bd5ATj6+3C829ixYz1dIgDgAkZDDgAAnLU+ffooPT1d27Zt0/DhwzV27Fi98MILx922tLT0nDynv7+/IiMjz8lj/R1HXntKSop+/PFH9ejRQw8//LCuuuqq896UxPH5+fnpueee08GDBz1dimbOnKn09HRt2LBBr732mgoKCpSQkKA5c+Z4urQLRnp6uus2ZcoUhYSEVLjvscce81ht5yoPAQBVFw05AABw1nx9fRUdHa169epp6NCh6tmzp7799ltJh0csXXvttUpMTFStWrXUqFEjSdKePXt08803KywsTDVr1tQ111yjlJQUSdLPP/8sPz+/Yy4fe/jhh/WPf/xD0vFHlM2YMUMNGjSQj4+PGjVqpPfff9/1uZSUFFksFq1du9Z1X05OjiwWixYsWCBJOnjwoPr37y+73S5/f381bNhQM2fOPK3XXrt2bbVt21ZPPfWUvvnmG/3444+aNWuWa7uXX35ZLVq0UGBgoGJjY3XfffepoKBA0uHL5e68807l5uYeM2rn/fffV/v27RUcHKzo6GjdeuutysrKOtW35ILWs2dPRUdHa9KkSSfdbsmSJeratav8/f0VGxurhx56SIWFhZKkV199Vc2bN3dte2SE3RtvvFHheUaPHn3S5wgLC1N0dLTq16+vXr166fPPP1f//v31wAMPuBqG2dnZuuWWW1S7dm0FBASoRYsW+uijj1yPMXDgQC1cuFBTp051HR8pKSlyOp0aNGiQ4uLi5O/vr0aNGmnq1KlnvL+qu+joaNctNDRUFoulwn1BQUGubVevXq327dsrICBAXbp00ZYtWyo81jfffKO2bdvKz89P8fHxGjduXIXGe2pqqq655hoFBQUpJCREN998szIzM12fHzt2rFq3bq133nlHcXFx8vPz05w5cxQeHq6SkpIKz3Xttdfq9ttvP097BQBQWdCQAwAA54y/v3+FkR/z58/Xli1bNG/ePH333XcqKytT7969FRwcrMWLF2vp0qUKCgpSnz59VFpaqssvv1xhYWH64osvXI/hdDr1ySefqH///sd9zq+++koPP/ywhg8fruTkZN17772688479dtvv5123U8//bQ2btyoH3/8UZs2bdKMGTMUERFxxq//H//4h1q1aqUvv/zSdZ/VatW0adO0YcMGzZ49W7/++queeOIJSVKXLl2OGblzZNROWVmZJkyYoHXr1unrr79WSkqKBg4ceMY1XUhsNpueffZZTZ8+XXv37j3uNjt27FCfPn10ww03aP369frkk0+0ZMkSPfDAA5Kk7t27a+PGjXI4HJKkhQsXKiIiwtW8LSsr07Jly3TZZZedcX2PPvqo8vPzNW/ePElScXGx2rVrp++//17JyckaPHiwbr/9dq1YsUKSNHXqVHXu3Fn33HOP6/iIjY2VYRiqU6eOPvvsM23cuFFjxozRU089pU8//fSMazpbpmmqqLTcIzfTNM/56xk1apReeuklrVq1Sl5eXrrrrrtcn1u8eLHuuOMOPfzww9q4caPefPNNzZo1S4mJiZIkwzB0zTXX6MCBA1q4cKHmzZunnTt3ql+/fhWeY/v27friiy/05Zdfau3atbrpppvkdDpdb2JIUlZWlr7//vsKzw8AqJ68PF0AAAA4dwzDkMPhkN1ul9XqvvfdTNPU/Pnz9dNPP+nBBx903R8YGKh33nlHPj4+kqQPPvhAhmHonXfecc3rNXPmTIWFhWnBggXq1auX/vWvf+nDDz/UoEGDJB1u6uXk5OiGG2447nO/+OKLGjhwoO677z5J0rBhw7R8+XK9+OKL6tGjx2nVn5qaqjZt2qh9+/aSpPr165/VfpCkxo0ba/369a6Pj57/q379+po4caKGDBmi119/XT4+PhVG7hzt6D/I4+PjNW3aNHXo0EEFBQUVRvZUaoYhFe2XAiIkNx2P1113nVq3bq1nnnlG77777jGfnzRpkvr37+/6vjRs2FDTpk1T9+7dNWPGDDVv3lw1a9bUwoULdeONN2rBggUaPny4awTaihUrVFZWpi5dupxxbY0bN5Yk14jQ2rVrV7hs8sEHH9RPP/2kTz/9VB07dlRoaKh8fHwUEBBQ4fiw2WwaN26c6+O4uDgtW7ZMn376qW6++eYzrutsHCpzqumYn9zyXH+1cXxvBfic2z9jEhMT1b17d0nSiBEj1LdvXxUXF8vPz0/jxo3TiBEjNGDAAEmHfx4nTJigJ554Qs8884zmz5+vP//8U7t27VJsbKwkac6cOWrWrJlWrlypDh06SDp8meqcOXNkt9tdz3vrrbdq5syZuummmyQdzsi6deueVcMXAFC1MEIOAIBqwjAMJSYmatCgQUpMTDzjxQXOxnfffaegoCD5+fnpiiuuUL9+/SpMlN6iRQtXM06S1q1bp+3btys4OFhBQUEKCgpSzZo1VVxcrB07dkiS+vfvrwULFmjfvn2SpLlz56pv374nXPhg06ZNuuSSSyrcd8kll2jTpk2n/TqGDh2qjz/+WK1bt9YTTzyh33///bS/9q9M06ywiMAvv/yiyy+/XLVr11ZwcLBuv/12ZWdnq6io6KSPs3r1al199dWqW7eugoODXc2C1NTUs67NrQxDWvyi9M0Dh/91w/F4xHPPPafZs2cf9xhYt26dZs2a5Tr+goKC1Lt3bxmGoV27dslisahbt25asGCBcnJytHHjRt13330qKSnR5s2btXDhQnXo0EEBAQFnXNeRkV1Hjg+n06kJEyaoRYsWqlmzpoKCgvTTTz+d1vf4tddeU7t27WS32xUUFKS33nqr6hwblVDLli1d/4+JiZEk1yXi69at0/jx4yscM0dGLRYVFWnTpk2KjY11NeMkqWnTpgoLC6twDNarV69CM06S7rnnHv38889KS0uTdPiS/CMLlAAAqjdGyAEAUE04HA4lJSUpIyNDSUlJcjgcioqKOq/P2aNHD82YMUM+Pj6qVauWvLwq/moRGBhY4eOCggK1a9dOc+fOPeaxjvyh2qFDBzVo0EAff/yxhg4dqq+++qrCnGxn6shIwaMvcysrK6uwzRVXXKHdu3frhx9+0Lx583T55Zfr/vvv14svvnjGz7dp0ybFxcVJOjwS6qqrrtLQoUOVmJiomjVrasmSJRo0aJBKS0tP2NQpLCxU79691bt3b82dO1d2u12pqanq3bt31ZkMvmi/tHeVVJB5+N+i/VKQexbj6Natm3r37q2RI0cec5lvQUGB7r33Xj300EPHfF3dunUlHV7Z9K233tLixYvVpk0bhYSEuJp0CxcudDVHz9SR5syR4+OFF17Q1KlTNWXKFNc8g4888sgpv8cff/yxHnvsMb300kvq3LmzgoOD9cILLygpKems6job/t42bRzf223P99fnPte8vb1d/z/SDDvypkZBQYHGjRun66+//piv8/PzO+3n+GseSlKbNm3UqlUrzZkzR7169dKGDRv0/fffn2n5AIAqiIYcAADVhN1uV0JCgpKSkpSQkHDMSIzzITAwUBdddNFpb9+2bVt98sknioyMVEhIyAm369+/v+bOnas6derIarWqb9++J9y2SZMmWrp0qetyMklaunSpmjZtKul/jb709HS1adNGkios8HCE3W7XgAEDNGDAAHXt2lWPP/74GTfkfv31V/3555969NFHJR0e5WYYhl566SVXY/Cv83z5+PjI6XRWuG/z5s3Kzs7W5MmTXaNuVq1adUa1eFxAhFSn/eFmXJ32hz92o8mTJ6t169auxUSOaNu2rTZu3HjS47Z79+565JFH9Nlnn7kuHbzsssv0yy+/aOnSpRo+fPhZ1XRkvsCePXtKOnycXnPNNbrtttskHW4Abd261XXsSsc/PpYuXaouXbq4LtOW5Bph6i4Wi+WcXzZaWbVt21Zbtmw54THTpEkT7dmzR3v27HH9vG7cuFE5OTkVvpcncvfdd2vKlClKS0tTz549K4y0AwBUXxfGWRQAgAuA1WrVqFGjPDKH3Onq37+/XnjhBV1zzTUaP3686tSpo927d+vLL7/UE088oTp16ri2Gzt2rBITE3XjjTfK19f3hI/5+OOP6+abb1abNm3Us2dP/fvf/9aXX36pX375RdLhhSY6deqkyZMnKy4uTllZWceskDlmzBi1a9dOzZo1U0lJib777js1adLkpK+lpKREGRkZcjqdyszM1H/+8x9NmjRJV111le644w5J0kUXXaSysjJNnz5dV199tZYuXVphtU7p8LxyBQUFmj9/vlq1aqWAgADVrVtXPj4+mj59uoYMGaLk5GRNmDDhjPe3R1mtUtfH3D6H3BEtWrRQ//79NW3atAr3P/nkk+rUqZMeeOAB3X333QoMDNTGjRs1b948vfrqq5IOX75Yo0YNffjhh/ruu+8kHW7IPfbYY7JYLMdcIn08OTk5ysjIUElJibZu3ao333xTX3/9tebMmeO6/Lphw4b6/PPP9fvvv6tGjRp6+eWXlZmZWaGJU79+fSUlJSklJcV1iXfDhg01Z84c/fTTT4qLi9P777+vlStXukbe4dwaM2aMrrrqKtWtW1c33nijrFar1q1bp+TkZE2cOFE9e/Z0HW9TpkxReXm57rvvPnXv3t01L+XJ3HrrrXrsscf09ttva86cOW54RQCAyqDy/aYOAADOmtVqVVRUVKVsxklSQECAFi1apLp16+r6669XkyZNNGjQIBUXF1cYMXfRRRepY8eOWr9+/QlXVz3i2muv1dSpU/Xiiy+qWbNmevPNNzVz5swKk6K/9957Ki8vV7t27fTII49o4sSJFR7Dx8dHI0eOVMuWLdWtWzfZbDZ9/PHHJ33e//znP4qJiVH9+vXVp08f/fbbb5o2bZq++eYb2WyHL6lr1aqVXn75ZT333HNq3ry55s6dq0mTJlV4nC5dumjIkCHq16+f7Ha7nn/+edntds2aNUufffaZmjZtqsmTJ5/V5bMeZ7UevkzVQ8fj+PHjj5lLsWXLllq4cKG2bt2qrl27qk2bNhozZoxq1arl2sZisahr166yWCy69NJLXV8XEhKi9u3bH/fSw7+68847FRMTo8aNG2vo0KEKCgrSihUrdOutt7q2GT16tNq2bavevXvrsssuU3R0tK699toKj/PYY4/JZrOpadOmrkuX7733Xl1//fXq16+fEhISlJ2dXWG0HM6t3r1767vvvtPPP/+sDh06qFOnTnrllVdUr149SYePl2+++UY1atRQt27d1LNnT8XHx+uTTz45rccPDQ3VDTfcoKCgoGO+/wCA6stino91wwEAwGkrLi7Wrl27FBcXd0bzEQEAqofLL79czZo1O2ZE519xvgCA6oNLVgEAAADAAw4ePKgFCxZowYIFev311z1dDgDAjWjIAQAAAIAHtGnTRgcPHtRzzz13zAIkAIDqjYYcAAAAAHhASkqKp0sAAHhI5ZzxGQAAAAAAAKimaMgBAFBJsM4SAOBkOE8AQPVBQw4AAA/z9vaWJBUVFXm4EgBAZXbkPHHkvAEAqLqYQw4AAA+z2WwKCwtTVlaWJCkgIEAWi8XDVQEAKgvTNFVUVKSsrCyFhYXJZrN5uiQAwN9kMRn3DACAx5mmqYyMDOXk5Hi6FABAJRUWFqbo6GjetAGAaoCGHAAAlYjT6VRZWZmnywAAVDLe3t6MjAOAaoSGHAAAAAAAAOBGLOoAAAAAAAAAuBENOQAAAAAAAMCNaMgBAAAAAAAAbkRDDgAAAAAAAHAjGnIAAAAAAACAG9GQAwAAAAAAANyIhhwAAAAAAADgRv8P19XrJGJ1s/wAAAAASUVORK5CYII=\n" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Visualize the data collected and theory determined during each cycle\n", - "plot_results_panel_2d(random_experimentalist_cycle,\n", - " wrap=3,\n", - " subplot_kw=dict(figsize=(14,10))\n", - " );\n" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": 12, - "outputs": [ - { - "data": { - "text/plain": "
", - "image/png": "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\n" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Visualize final cycle\n", - "plot_results_panel_2d(random_experimentalist_cycle,\n", - " query=[-1],\n", - " subplot_kw=dict(figsize=(8,5))\n", - " );\n" - ], - "metadata": { - "collapsed": false - } - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 2 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython2", - "version": "2.7.6" - } - }, - "nbformat": 4, - "nbformat_minor": 0 -} diff --git a/docs/cycle/simple_cycle_bms_darts.ipynb b/docs/cycle/simple_cycle_bms_darts.ipynb deleted file mode 100644 index be862996f..000000000 --- a/docs/cycle/simple_cycle_bms_darts.ipynb +++ /dev/null @@ -1,396 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "source": [ - "# Simple Cycle Examples with BMS and DARTS\n", - "The aim of this example notebook is to use the AutoRA `Cycle` to recover a simple ground truth theory from some noisy data using BSM and DARTS, as a proof of concept.\n", - "It uses a trivial experimentalist which resamples the same x-values each cycle." - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": [ - "# Uncomment the following line when running on Google Colab\n", - "# !pip install autora" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": [ - "from autora.variable import VariableCollection, Variable\n", - "from autora.cycle import Cycle, plot_results_panel_2d\n", - "from itertools import repeat, chain" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": [ - "def ground_truth(xs):\n", - " return (xs ** 2.) + xs + 1." - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "markdown", - "source": [ - "The space of allowed x values is the integers between 0 and 10 inclusive, and we record the allowed output values as well." - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": [ - "study_metadata = VariableCollection(\n", - " independent_variables=[Variable(name=\"x1\", allowed_values=range(11))],\n", - " dependent_variables=[Variable(name=\"y\", value_range=(-20, 20))],\n", - " )" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "markdown", - "source": [ - "The experimentalist is used to propose experiments.\n", - "Since the space of values is so restricted, we can just sample them all each time." - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": [ - "from autora.experimentalist.pipeline import make_pipeline\n", - "example_experimentalist = make_pipeline(\n", - " [list(chain.from_iterable((repeat(study_metadata.independent_variables[0].allowed_values, 10))))])" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "markdown", - "source": [ - "When we run a synthetic experiment, we get a reproducible noisy result:" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": [ - "import numpy as np\n", - "\n", - "def get_example_synthetic_experiment_runner():\n", - " rng = np.random.default_rng(seed=180)\n", - " def runner(xs):\n", - " return ground_truth(xs) + rng.normal(0, 1.0, xs.shape)\n", - " return runner\n", - "\n", - "example_synthetic_experiment_runner = get_example_synthetic_experiment_runner()\n", - "x = np.array([1.])\n", - "example_synthetic_experiment_runner(x)" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "markdown", - "source": [ - "## Bayesian Machine Scientist" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": [ - "from autora.skl.bms import BMSRegressor\n", - "bms_theorist = BMSRegressor(epochs=100)" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "markdown", - "source": [ - "We initialize the Cycle with the metadata describing the domain of the theory,\n", - "the theorist, experimentalist and experiment runner,\n", - "as well as a monitor which will let us know which cycle we're currently on." - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": [ - "cycle = Cycle(\n", - " metadata=study_metadata,\n", - " theorist=bms_theorist,\n", - " experimentalist=example_experimentalist,\n", - " experiment_runner=example_synthetic_experiment_runner\n", - ")" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "markdown", - "source": [ - "We can run the cycle by calling the run method:" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": [ - "cycle.run(num_cycles=3)" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "markdown", - "source": [ - "We can now interrogate the results. The first set of conditions which went into the\n", - "experiment runner were:" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "markdown", - "source": [ - "The observations include the conditions and the results:" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": [ - "cycle.data.observations[0]" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "markdown", - "source": [ - "The best fit theory after the first cycle is:" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": [ - "len(cycle.data.observations)" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": [ - "str(cycle.data.theories[0].model_), cycle.data.theories[0].model_.fit_par[str(cycle.data.theories[0].model_)]" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": [ - "str(cycle.data.theories[-1].model_), cycle.data.theories[-1].model_.fit_par[str(cycle.data.theories[-1].model_)]" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": [ - "# Plot all cycle results\n", - "plot_results_panel_2d(cycle, subplot_kw=dict(figsize=(12,4)))" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "markdown", - "source": [ - "## DARTS\n" - ], - "metadata": { - "collapsed": false - }, - "execution_count": 217 - }, - { - "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": [ - "from autora.skl.darts import DARTSRegressor\n", - "darts_theorist = DARTSRegressor(max_epochs=100)" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": [ - "darts_cycle = Cycle(\n", - " metadata=study_metadata,\n", - " theorist=darts_theorist,\n", - " experimentalist=example_experimentalist,\n", - " experiment_runner=example_synthetic_experiment_runner\n", - ")" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": [ - "darts_cycle.run(3)" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": [ - "darts_cycle.data.theories[-2].visualize_model()\n" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": [ - "darts_cycle.data.theories[-2].model_repr()\n" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": [ - "# Rerun 3 more times\n", - "darts_cycle.run(3)" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": [ - "# Plot the all cycle results\n", - "plot_results_panel_2d(darts_cycle, wrap=3)\n" - ], - "metadata": { - "collapsed": false - } - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 2 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython2", - "version": "2.7.6" - } - }, - "nbformat": 4, - "nbformat_minor": 0 -} diff --git a/docs/cycle/simple_cycle_bms_model_poppernet.ipynb b/docs/cycle/simple_cycle_bms_model_poppernet.ipynb deleted file mode 100644 index 1bda9fd20..000000000 --- a/docs/cycle/simple_cycle_bms_model_poppernet.ipynb +++ /dev/null @@ -1,622 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "outputs": [], - "source": [ - "# Uncomment the following line when running on Google Colab\n", - "# !pip install autora" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "import matplotlib.pyplot as plt\n", - "import numpy as np\n", - "\n", - "from autora.cycle import Cycle\n", - "from autora.experimentalist.pipeline import Pipeline\n", - "from autora.experimentalist.pooler import grid_pool, poppernet_pool\n", - "from autora.experimentalist.sampler import nearest_values_sampler\n", - "from autora.skl.bms import BMSRegressor\n", - "from autora.variable import Variable, VariableCollection" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "outputs": [], - "source": [ - "# meta parameters\n", - "ground_truth_resolution = 1000\n", - "samples_per_cycle = 7\n", - "value_range = (-1, 5)\n", - "allowed_values = np.linspace(value_range[0], value_range[1], ground_truth_resolution)" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": 4, - "outputs": [], - "source": [ - "# define ground truth\n", - "def ground_truth(xs):\n", - " # return (xs ** 2.) + xs + 1.\n", - " y = xs * 1.0\n", - " y[xs < 0] = 0\n", - " return y" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": 5, - "outputs": [], - "source": [ - "# define variables\n", - "study_metadata = VariableCollection(\n", - " independent_variables=[\n", - " Variable(name=\"x1\", allowed_values=allowed_values, value_range=value_range)\n", - " ],\n", - " dependent_variables=[Variable(name=\"y\", value_range=(-20, 20))],\n", - ")" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": 6, - "outputs": [], - "source": [ - "# define experiment platform\n", - "def get_synthetic_experiment_runner():\n", - " rng = np.random.default_rng(seed=180)\n", - "\n", - " def runner(xs):\n", - " return ground_truth(xs) + rng.normal(0, 0.5, xs.shape)\n", - "\n", - " return runner\n", - "\n", - "synthetic_experiment_runner = get_synthetic_experiment_runner()" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": 7, - "outputs": [], - "source": [ - "# Initialize the experimentalist\n", - "random_experimentalist = Pipeline(\n", - " [\n", - " (\"grid_pool\", grid_pool), # type: ignore\n", - " (\"nearest_values_sampler\", nearest_values_sampler), # type: ignore\n", - " ],\n", - " {\n", - " \"grid_pool\": {\"ivs\": study_metadata.independent_variables},\n", - " \"nearest_values_sampler\": {\n", - " \"allowed_values\": np.linspace(\n", - " value_range[0], value_range[1], samples_per_cycle\n", - " ),\n", - " \"n\": samples_per_cycle,\n", - " },\n", - " },\n", - ")" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": 8, - "outputs": [], - "source": [ - "# define theorist\n", - "bms_theorist = BMSRegressor(epochs=100)" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": 9, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:autora.skl.bms:BMS fitting started\n", - " 0%| | 0/100 [00:00:2: RuntimeWarning: invalid value encountered in power\n", - " return X0**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return _a0_/X0\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return _a0_/X0\n", - " 3%|▎ | 3/100 [00:00<00:03, 24.45it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", - " return sig(_a0_/X0)\n", - "/Users/jholla10/Library/Caches/pypoetry/virtualenvs/autora-17yK3Jyq-py3.8/lib/python3.8/site-packages/scipy/optimize/_minpack_py.py:906: OptimizeWarning: Covariance of the parameters could not be estimated\n", - " warnings.warn('Covariance of the parameters could not be estimated',\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return sig(_a0_/X0)\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return sig(_a0_/X0)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(X0)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(X0)\n", - " 6%|▌ | 6/100 [00:00<00:04, 19.35it/s]:2: RuntimeWarning: divide by zero encountered in log\n", - " return log(X0)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(X0)\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(X0)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(X0)\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(X0)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(X0)\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return _a0_/X0\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return _a0_/X0\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return -log(X0)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return -log(X0)\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return -log(X0)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return -log(X0)\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return -log(X0)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return -log(X0)\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return -_a0_*log(X0)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return -_a0_*log(X0)\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return -_a0_*log(X0)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return -_a0_*log(X0)\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return -_a0_*log(X0)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return -_a0_*log(X0)\n", - " 10%|█ | 10/100 [00:00<00:03, 24.48it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", - " return _a0_/X0\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return _a0_/X0\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return _a0_/X0\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return _a0_/X0\n", - " 13%|█▎ | 13/100 [00:00<00:03, 25.56it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(X0)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(X0)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(X0)\n", - " 17%|█▋ | 17/100 [00:00<00:02, 28.60it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(X0)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(X0)\n", - " 25%|██▌ | 25/100 [00:00<00:02, 29.38it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(X0)\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return abs(relu(_a0_/X0))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return abs(relu(_a0_/X0))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return abs(relu(_a0_/X0))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(X0)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(X0)\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(X0)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(X0)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(X0)\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(X0)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(X0)\n", - " 29%|██▉ | 29/100 [00:01<00:02, 30.25it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return abs(X0**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(sqrt(X0))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(sqrt(X0))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(X0)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(X0)\n", - " 33%|███▎ | 33/100 [00:01<00:02, 31.17it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(X0)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(X0)\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return _a0_/X0\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return _a0_/X0\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(X0**_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return sig(sig(_a0_/X0)**2)\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return sig(sig(_a0_/X0)**2)\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return sig(sig(_a0_/X0)**2)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(X0)\n", - " 37%|███▋ | 37/100 [00:01<00:01, 32.09it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", - " return _a0_/X0\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return _a0_/X0\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return _a0_/X0\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return _a0_/X0\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(sqrt(X0))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(sqrt(X0))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return _a0_/X0\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return _a0_/X0\n", - " 41%|████ | 41/100 [00:01<00:01, 32.14it/s]:2: RuntimeWarning: divide by zero encountered in power\n", - " return sig(sig(sig(X0**_a0_)))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sig(sig(sig(X0**_a0_)))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return sig(sig(sig(X0**_a0_)))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sig(sig(sig(X0**_a0_)))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return sig(sig(sig(X0**_a0_)))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sig(sig(sig(X0**_a0_)))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return _a0_/X0\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return _a0_/X0\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return _a0_/X0\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return _a0_/X0\n", - " 45%|████▌ | 45/100 [00:01<00:01, 32.18it/s]:2: RuntimeWarning: divide by zero encountered in log\n", - " return log(relu(X0))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(relu(X0))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(X0)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(X0)\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(X0)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(X0)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(X0)\n", - " 49%|████▉ | 49/100 [00:01<00:01, 32.49it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(X0**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(_a0_/X0)\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(_a0_/X0)\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(_a0_/X0)\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return abs(log(X0))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return abs(log(X0))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return abs(log(X0))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return abs(log(X0))\n", - " 53%|█████▎ | 53/100 [00:01<00:01, 32.94it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", - " return abs(sqrt(X0))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return abs(sqrt(X0))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(X0)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(X0)\n", - " 57%|█████▋ | 57/100 [00:01<00:01, 32.46it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", - " return abs(relu(sqrt(X0)))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return abs(relu(sqrt(X0)))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return abs(relu(sqrt(X0)))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return _a0_/X0\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return _a0_/X0\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(X0)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(X0)\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(X0)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(X0)\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(_a0_/X0)\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(_a0_/X0)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sig(sig(sig(log(_a0_))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sig(sig(sig(log(_a0_))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sig(sig(sig(log(_a0_))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(X0)\n", - " 61%|██████ | 61/100 [00:02<00:01, 32.52it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", - " return abs(sqrt(X0))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(X0)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(X0)\n", - " 65%|██████▌ | 65/100 [00:02<00:01, 33.12it/s]:2: RuntimeWarning: divide by zero encountered in log\n", - " return log(relu(X0))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return _a0_/X0\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return _a0_/X0\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(X0)**X0\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(X0)**X0\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(X0)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(X0)\n", - " 69%|██████▉ | 69/100 [00:02<00:00, 33.02it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(X0)\n", - " 73%|███████▎ | 73/100 [00:02<00:00, 31.93it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(_a0_/X0)\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(_a0_/X0)\n", - " 77%|███████▋ | 77/100 [00:02<00:00, 31.69it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", - " return _a0_/X0\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return _a0_/X0\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return abs(_a0_/X0)\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return abs(_a0_/X0)\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return abs(_a0_/X0)\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(_a0_/X0)\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(_a0_/X0)\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(relu(relu(relu(X0))))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(relu(relu(relu(X0))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(sqrt(X0))\n", - " 81%|████████ | 81/100 [00:02<00:00, 32.10it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", - " return _a0_/X0\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return _a0_/X0\n", - " 85%|████████▌ | 85/100 [00:02<00:00, 31.54it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(sqrt(X0))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(sqrt(X0))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(_a0_/X0)\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(_a0_/X0)\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(_a0_/X0)\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(_a0_/X0)\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return _a0_/X0\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return _a0_/X0\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(X0)\n", - " 97%|█████████▋| 97/100 [00:03<00:00, 33.64it/s]:2: RuntimeWarning: invalid value encountered in divide\n", - " return relu(relu(X0))/X0\n", - ":2: RuntimeWarning: invalid value encountered in divide\n", - " return relu(relu(X0))/X0\n", - "100%|██████████| 100/100 [00:03<00:00, 31.19it/s]\n", - "INFO:autora.skl.bms:BMS fitting finished\n" - ] - } - ], - "source": [ - "# define seed cycle\n", - "# we will use this cycle to collect initial data and initialize the BMS model\n", - "seed_cycle = Cycle(\n", - " metadata=study_metadata,\n", - " theorist=bms_theorist,\n", - " experimentalist=random_experimentalist,\n", - " experiment_runner=synthetic_experiment_runner,\n", - ")\n", - "\n", - "# run seed cycle\n", - "seed_cycle.run(num_cycles=1)\n", - "\n", - "seed_model = seed_cycle.data.theories[0].model_\n", - "seed_x = seed_cycle.data.conditions[0]\n", - "seed_y = seed_cycle.data.observations[0][:, 1]" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": 10, - "outputs": [], - "source": [ - "# now we define the poppernet experimentalist which takes into account\n", - "# the seed data and the seed model\n", - "popper_experimentalist = Pipeline(\n", - " [\n", - " (\"popper_pool\", poppernet_pool), # type: ignore\n", - " (\"nearest_values_sampler\", nearest_values_sampler), # type: ignore\n", - " ],\n", - " {\n", - " \"popper_pool\": {\n", - " \"metadata\": study_metadata,\n", - " \"model\": seed_model,\n", - " \"x_train\": seed_x,\n", - " \"y_train\": seed_y,\n", - " \"n\": samples_per_cycle,\n", - " \"plot\": True,\n", - " },\n", - " \"nearest_values_sampler\": {\n", - " \"allowed_values\": allowed_values,\n", - " \"n\": samples_per_cycle,\n", - " },\n", - " },\n", - ")" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": 11, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Finished training Popper Network...\n" - ] - }, - { - "data": { - "text/plain": "
", - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": "
", - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": "
", - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:autora.skl.bms:BMS fitting started\n", - " 9%|▉ | 9/100 [00:00<00:03, 28.62it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return sig(_a0_**X0)\n", - " 21%|██ | 21/100 [00:00<00:02, 31.02it/s]/Users/jholla10/Library/Caches/pypoetry/virtualenvs/autora-17yK3Jyq-py3.8/lib/python3.8/site-packages/scipy/optimize/_minpack_py.py:906: OptimizeWarning: Covariance of the parameters could not be estimated\n", - " warnings.warn('Covariance of the parameters could not be estimated',\n", - "100%|██████████| 100/100 [00:03<00:00, 32.37it/s]\n", - "INFO:autora.skl.bms:BMS fitting finished\n" - ] - }, - { - "data": { - "text/plain": "
", - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# running a new cycle taking into account the seed data and model\n", - "# TODO: need to find a way to incorporate the seed data into the cycle\n", - "cycle = Cycle(\n", - " metadata=study_metadata,\n", - " theorist=bms_theorist,\n", - " experimentalist=popper_experimentalist,\n", - " experiment_runner=synthetic_experiment_runner,\n", - ")\n", - "cycle.run(num_cycles=1)\n", - "\n", - "# plot output of architecture search\n", - "all_obs = np.row_stack(seed_cycle.data.observations)\n", - "x_obs, y_obs = all_obs[:, 0], all_obs[:, 1]\n", - "plt.scatter(x_obs, y_obs, s=10, label=\"seed data\")\n", - "\n", - "all_obs = np.row_stack(cycle.data.observations)\n", - "x_obs, y_obs = all_obs[:, 0], all_obs[:, 1]\n", - "plt.scatter(x_obs, y_obs, s=10, label=\"collected data\")\n", - "\n", - "x_pred = np.array(study_metadata.independent_variables[0].allowed_values).reshape(\n", - " ground_truth_resolution, 1\n", - ")\n", - "y_pred_seed = seed_cycle.data.theories[0].predict(x_pred)\n", - "y_pred_final = cycle.data.theories[0].predict(x_pred)\n", - "plt.plot(x_pred, y_pred_seed, color=\"blue\", label=\"seed model\")\n", - "plt.plot(x_pred, y_pred_final, color=\"red\", label=\"final model\")\n", - "plt.legend()\n", - "plt.show()\n" - ], - "metadata": { - "collapsed": false - } - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 2 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython2", - "version": "2.7.6" - } - }, - "nbformat": 4, - "nbformat_minor": 0 -} diff --git a/docs/cycle/simple_cycle_uncertainty_experimentalist.ipynb b/docs/cycle/simple_cycle_uncertainty_experimentalist.ipynb deleted file mode 100644 index 7fc16de7b..000000000 --- a/docs/cycle/simple_cycle_uncertainty_experimentalist.ipynb +++ /dev/null @@ -1,350 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "source": [ - "# Simple Cycle Examples with Uncertainty vs. Random Experimentalist\n", - "The aim of this example notebook is to use the AutoRA `Cycle` to recover a ground truth theory from some noisy data using BSM.\n", - "It comparse the default \"random\" experimentalist with the \"uncertainty\" sampler." - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": [ - "# Uncomment the following line when running on Google Colab\n", - "# !pip install autora" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": [ - "import matplotlib.pyplot as plt\n", - "import numpy as np\n", - "from sklearn.dummy import DummyRegressor\n", - "\n", - "from autora.cycle import Cycle\n", - "from autora.experimentalist.sampler import random_sampler, poppernet_pooler, nearest_values_sampler\n", - "from autora.experimentalist.pipeline import make_pipeline\n", - "from autora.variable import VariableCollection, Variable" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": [ - "def ground_truth(xs):\n", - " oscillating_component = np.sin((4. * xs) - 3.)\n", - " parabolic_component = (-0.1 * xs ** 2.) + (2.5 * xs) + 1.\n", - " ys = oscillating_component + parabolic_component\n", - " return ys" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "markdown", - "source": [ - "The space of allowed x values is reals between -10 and 10 inclusive. We discretize them as we don't currently have a sampler which can sample from the uniform distribution." - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": [ - "study_metadata = VariableCollection(\n", - " independent_variables=[Variable(name=\"x1\", allowed_values=np.linspace(-10, 10, 500))],\n", - " dependent_variables=[Variable(name=\"y\")],\n", - " )" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "markdown", - "source": [ - "So that we can compare the effectiveness of the two strategies, we fix the number of observations per cycle to be 100." - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": [ - "observations_per_cycle = 100" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "markdown", - "source": [ - "When we run a synthetic experiment, we get a reproducible noisy result:" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": [ - "import numpy as np\n", - "\n", - "def get_example_synthetic_experiment_runner():\n", - " rng = np.random.default_rng(seed=180)\n", - " def runner(xs):\n", - " return ground_truth(xs) + rng.normal(0, 1.0, xs.shape)\n", - " return runner\n", - "\n", - "example_synthetic_experiment_runner = get_example_synthetic_experiment_runner()\n", - "x = np.array([1.])\n", - "example_synthetic_experiment_runner(x)" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": [ - "plt.scatter(study_metadata.independent_variables[0].allowed_values[::5,], example_synthetic_experiment_runner(study_metadata.independent_variables[0].allowed_values[::5,]), alpha=1, s=0.1, c='r', label=\"samples\")\n", - "plt.plot(study_metadata.independent_variables[0].allowed_values, ground_truth(study_metadata.independent_variables[0].allowed_values), c=\"black\", label=\"ground truth\")\n", - "plt.legend()" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "markdown", - "source": [ - "We use a common BMS regressor with a common parametrization to test the two methods." - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": [ - "from autora.skl.bms import BMSRegressor\n", - "bms_theorist = BMSRegressor(epochs=100)" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "markdown", - "source": [ - "We also define a helper function to plot the results" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": [ - "def run_and_plot_cycle(cycle, study_metadata):\n", - " cycle.run(num_cycles=1)\n", - "\n", - " all_obs = np.row_stack(cycle.data.observations)\n", - " x_obs, y_obs = all_obs[:,0], all_obs[:,1]\n", - " x_obs_new, y_obs_new = cycle.data.observations[-1][:,0], cycle.data.observations[-1][:,1]\n", - "\n", - " x_pred = np.array(study_metadata.independent_variables[0].allowed_values).reshape(-1, 1)\n", - " y_pred = cycle.data.theories[-1].predict(x_pred)\n", - "\n", - " plt.plot(study_metadata.independent_variables[0].allowed_values, ground_truth(study_metadata.independent_variables[0].allowed_values), c=\"black\", label=\"ground truth\")\n", - " plt.scatter(x_obs, y_obs, s=1, c='r', label=\"samples\")\n", - " plt.scatter(x_obs_new, y_obs_new, s=1, c='green', facecolors=\"none\", label=\"new samples\")\n", - " plt.plot(x_pred, y_pred, c=\"blue\", label=\"theorist result\")\n", - "\n", - " plt.legend()\n", - "\n", - " plt.show()" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "markdown", - "source": [ - "## Random Sampler" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": [ - "random_experimentalist = make_pipeline(\n", - " [study_metadata.independent_variables[0].allowed_values, random_sampler],\n", - " params={\"random_sampler\": {\"n\": observations_per_cycle}}\n", - ")\n", - "random_experimentalist_cycle = Cycle(\n", - " metadata=study_metadata,\n", - " theorist=bms_theorist,\n", - " experimentalist=random_experimentalist,\n", - " experiment_runner=example_synthetic_experiment_runner\n", - ")\n", - "\n", - "for _ in range(10):\n", - " run_and_plot_cycle(cycle=random_experimentalist_cycle, study_metadata=study_metadata)" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "markdown", - "source": [ - "## Popper Sampler" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": [ - "poppernet_experimentalist = make_pipeline(\n", - " [poppernet_pooler, nearest_values_sampler],\n", - ")\n", - "\n", - "poppernet_experimentalist_cycle = Cycle(\n", - " metadata=study_metadata,\n", - " theorist=bms_theorist,\n", - " experimentalist=poppernet_experimentalist,\n", - " experiment_runner=example_synthetic_experiment_runner,\n", - " params={\"experimentalist\" : {\n", - " \"poppernet_pooler\": {\n", - " \"model\": \"%theories[-1]%\",\n", - " \"x_train\": \"%observations.ivs%\",\n", - " \"y_train\": \"%observations.dvs%\",\n", - " \"metadata\": study_metadata,\n", - " \"num_samples\": observations_per_cycle,\n", - " },\n", - " \"nearest_values_sampler\": {\n", - " \"allowed_values\": study_metadata.independent_variables[0].allowed_values\n", - " }\n", - " }\n", - " }\n", - " )" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "markdown", - "source": [ - "The Popper sampler depends on having a first guess for the theory, so we add an appropriate model and an initial datapoint to the cycle's data:" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": [ - "# Experimentalist\n", - "x_seed = np.linspace(-10, 10, 20)\n", - "\n", - "# Experiment runner\n", - "y_seed = example_synthetic_experiment_runner(x_seed)\n", - "poppernet_experimentalist_cycle.data.observations.append(np.column_stack([x_seed, y_seed]))\n", - "\n", - "# Theorist\n", - "theory_seed = DummyRegressor(strategy=\"constant\", constant=y_seed[1])\n", - "theory_seed.fit(x_seed, y_seed)\n", - "poppernet_experimentalist_cycle.data.theories.append(theory_seed)" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "markdown", - "source": [ - "Now we can run the cycle and check the results." - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": [ - "for _ in range(10):\n", - " run_and_plot_cycle(cycle=poppernet_experimentalist_cycle, study_metadata=study_metadata)\n" - ], - "metadata": { - "collapsed": false - } - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 2 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython2", - "version": "2.7.6" - } - }, - "nbformat": 4, - "nbformat_minor": 0 -} diff --git a/docs/experiment-runner/index.md b/docs/experiment-runner/index.md new file mode 100644 index 000000000..fdf7cfb7e --- /dev/null +++ b/docs/experiment-runner/index.md @@ -0,0 +1,3 @@ +# Experiment Runners + +AutoRA includes tools for running synthetic and real experiments. diff --git a/docs/experimentalists/overview.md b/docs/experimentalist/index.md similarity index 83% rename from docs/experimentalists/overview.md rename to docs/experimentalist/index.md index 6d93ab709..c80896679 100644 --- a/docs/experimentalists/overview.md +++ b/docs/experimentalist/index.md @@ -28,13 +28,13 @@ experiment conditions that have already been probed $\vec{x}' \in X'$, or respective dependent measures $\vec{y}' \in Y'$. The following table includes the experimentalists currently implemented in AutoRA. -| Experimentalist | Function | Arguments | -|------------------|-------------------------------------------------------------------------------------------------------------------------------|------------| -| Random | $\vec{x_i} \sim U[a_i,b_i]$ | | -| Novelty | $\underset{\vec{x}}{\arg\max}~\min(d(\vec{x}, \vec{x}'))$ | $X'$ | -| Least Confident | $\underset{\vec{x}}{\arg\max}~1 - P_M(\hat{y}^*, \vec{x})$, $\hat{y}^* = \underset{\hat{y}}{\arg\max}~P_M(\hat{y}_i \vec{x})$ | $M$ | -| Model Comparison | $\underset{\vec{x}}{\argmax}~(P_{M_1}(\hat{y}, \vec{x}) - P_{M_2}(\hat{y} \vec{x}))^2$ | $M$ | -| Falsification | $\underset{\vec{x}}{\argmax}~\hat{\mathcal{L}}(M,X',Y',\vec{x})$ | $M, X', Y'$ | +| Experimentalist | Function | Arguments | +|------------------|-------------------------------------------------------------------------------------------------------------------------------|-------------| +| Random | $\vec{x_i} \sim U[a_i,b_i]$ | | +| Novelty | $\underset{\vec{x}}{\arg\max}~\min(d(\vec{x}, \vec{x}'))$ | $X'$ | +| Least Confident | $\underset{\vec{x}}{\arg\max}~1 - P_M(\hat{y}^*, \vec{x})$, $\hat{y}^* = \underset{\hat{y}}{\arg\max}~P_M(\hat{y}_i \vec{x})$ | $M$ | +| Model Comparison | $\underset{\vec{x}}{\arg\max}~(P_{M_1}(\hat{y}, \vec{x}) - P_{M_2}(\hat{y} \vec{x}))^2$ | $M$ | +| Falsification | $\underset{\vec{x}}{\arg\max}~\hat{\mathcal{L}}(M,X',Y',\vec{x})$ | $M, X', Y'$ | diff --git a/docs/img/experimentalist.png b/docs/img/experimentalist.png new file mode 100644 index 000000000..2efe09da1 Binary files /dev/null and b/docs/img/experimentalist.png differ diff --git a/docs/index.md b/docs/index.md index 94e5c2112..33c5410c6 100644 --- a/docs/index.md +++ b/docs/index.md @@ -1,6 +1,6 @@ # Automated Research Assistant -[AutoRA](https://pypi.org/project/autora/) (Automated Research Assistant) is an open-source framework for +[AutoRA](https://pypi.org/project/autora/) (Automated Research Assistant) is an open-source framework for automating multiple stages of the empirical research process, including model discovery, experimental design, data collection, and documentation for open science. ![Autonomous Empirical Research Paradigm](img/overview.png) diff --git a/docs/pipeline/Experimentalist Pipeline Examples.ipynb b/docs/pipeline/Experimentalist Pipeline Examples.ipynb deleted file mode 100644 index 71f367052..000000000 --- a/docs/pipeline/Experimentalist Pipeline Examples.ipynb +++ /dev/null @@ -1,311 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "source": [ - "# Introduction\n", - "This notebook demonstrates the use of the `Pipeline` class to create Experimentalists. Experimentalists consist of two main components:\n", - "1. Condition Generation - Creating combinations of independent variables to test\n", - "2. Experimental Design - Ensuring conditions meet design constraints.\n", - "\n", - "The `Pipeline` class allows us to define a series of functions to generate and process a pool of conditions that conform to an experimental design." - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": 2, - "outputs": [], - "source": [ - "# Uncomment the following line when running on Google Colab\n", - "# !pip install autora" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": 3, - "outputs": [], - "source": [ - "import numpy as np\n", - "\n", - "from autora.variable import DV, IV, ValueType, VariableCollection\n", - "from autora.experimentalist.pipeline import Pipeline\n", - "from autora.experimentalist.pooler import grid_pool\n", - "from autora.experimentalist.filter import weber_filter\n", - "from autora.experimentalist.sampler import random_sampler" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "markdown", - "source": [ - "## Implementation\n", - "\n", - "The `Pipeline` class consists of a series of steps:\n", - "1. One or no \"pool\" steps which generate experimental conditions,\n", - "2. An arbitrary number of steps to apply to the pool. Examples of steps may be:\n", - " - samplers\n", - " - conditional filters\n", - " - sequencers" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "markdown", - "source": [ - "## Example 1: Exhaustive Pool with Random Sampler\n", - "The examples in this notebook will create a Weber line-lengths experiment. The Weber experiment tests human detection of differences between the lengths of two lines. The first example will sample a pool with simple random sampling. We will first define the independent and dependent variables (IVs and DVs, respectively).\n" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": 4, - "outputs": [], - "source": [ - "# Specifying Dependent and Independent Variables\n", - "# Specify independent variables\n", - "iv1 = IV(\n", - " name=\"S1\",\n", - " allowed_values=np.linspace(0, 5, 5),\n", - " units=\"intensity\",\n", - " variable_label=\"Stimulus 1 Intensity\",\n", - ")\n", - "\n", - "iv2 = IV(\n", - " name=\"S2\",\n", - " allowed_values=np.linspace(0, 5, 5),\n", - " units=\"intensity\",\n", - " variable_label=\"Stimulus 2 Intensity\",\n", - ")\n", - "\n", - "# The experimentalist pipeline doesn't actually use DVs, they are just specified here for\n", - "# example.\n", - "dv1 = DV(\n", - " name=\"difference_detected\",\n", - " value_range=(0, 1),\n", - " units=\"probability\",\n", - " variable_label=\"P(difference detected)\",\n", - " type=ValueType.PROBABILITY,\n", - ")\n", - "\n", - "# Variable collection with ivs and dvs\n", - "metadata = VariableCollection(\n", - " independent_variables=[iv1, iv2],\n", - " dependent_variables=[dv1],\n", - ")" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "markdown", - "source": [ - "Next we set up the `Pipeline` with three functions:\n", - "1. `grid_pool` - Generates an exhaustive pool of condition combinations using the Cartesian product of discrete IV values.\n", - " - The discrete IV values are specified with the `allowed_values` attribute when defining the IVs.\n", - "2. `weber_filer` - Filter that selects the experimental design constraint where IV1 <= IV2.\n", - "3. `random_sampler` - Samples the pool of conditions\n", - "\n", - "Functions that require keyword inputs are initialized using the `partial` function before passing into `PoolPipeline`." - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": 5, - "outputs": [ - { - "data": { - "text/plain": "Pipeline(steps=[('grid_pool', ), ('weber_filer', ), ('random_sampler', )], params={'grid_pool': {'ivs': [IV(name='S1', value_range=None, allowed_values=array([0. , 1.25, 2.5 , 3.75, 5. ]), units='intensity', type=, variable_label='Stimulus 1 Intensity', rescale=1, is_covariate=False), IV(name='S2', value_range=None, allowed_values=array([0. , 1.25, 2.5 , 3.75, 5. ]), units='intensity', type=, variable_label='Stimulus 2 Intensity', rescale=1, is_covariate=False)]}, 'random_sampler': {'n': 10}})" - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "## Set up pipeline functions with the partial function\n", - "# Random Sampler\n", - "\n", - "# Initialize the pipeline\n", - "pipeline_random_samp = Pipeline([\n", - " (\"grid_pool\", grid_pool),\n", - " (\"weber_filer\", weber_filter), # Filter that selects conditions with IV1 <= IV2\n", - " (\"random_sampler\", random_sampler)\n", - "],\n", - " {\"grid_pool\": {\"ivs\": metadata.independent_variables}, \"random_sampler\": {\"n\": 10}}\n", - ")\n", - "pipeline_random_samp" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "markdown", - "source": [ - "The pipleine can be run by calling the `run` method.\n", - "\n", - "The pipeline is run twice below to illustrate that random sampling is performed. Rerunning the cell will produce different results.\n" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": 6, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Sampled Conditions:\n", - " Run 1: [(3.75, 3.75), (0.0, 3.75), (2.5, 5.0), (3.75, 5.0), (1.25, 1.25), (2.5, 3.75), (2.5, 2.5), (1.25, 3.75), (1.25, 2.5), (0.0, 0.0)]\n", - " Run 2: [(1.25, 5.0), (0.0, 5.0), (5.0, 5.0), (0.0, 1.25), (1.25, 2.5), (2.5, 2.5), (1.25, 3.75), (3.75, 3.75), (2.5, 3.75), (0.0, 0.0)]\n" - ] - } - ], - "source": [ - "# Run the Pipeline\n", - "results1 = pipeline_random_samp.run()\n", - "results2 = pipeline_random_samp.run()\n", - "print('Sampled Conditions:')\n", - "print(f' Run 1: {results1}\\n',\n", - " f'Run 2: {results2}')" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "markdown", - "source": [ - "An alternative method of passing an instantiated pool iterator is demonstrated below. Note the difference where `grid_pool` is not initialized using the `partial` function but instantiated before initializing the `Pipeline`. `grid_pool` returns an iterator of the exhaustive pool. This will result in unexpected behavior when the Pipeline is run multiple times." - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": 7, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Sampled Conditions:\n", - " Run 1: [(1.25, 2.5), (0.0, 2.5), (3.75, 5.0), (0.0, 3.75), (0.0, 0.0), (0.0, 1.25), (2.5, 2.5), (1.25, 1.25), (3.75, 3.75), (1.25, 3.75)]\n", - " Run 2: []\n" - ] - } - ], - "source": [ - "## Set up pipeline functions with the partial function\n", - "# Pool Function\n", - "pooler_iterator = grid_pool(metadata.independent_variables)\n", - "\n", - "# Initialize the pipeline\n", - "pipeline_random_samp2 = Pipeline(\n", - " [\n", - " (\"pool (iterator)\", pooler_iterator),\n", - " (\"filter\",weber_filter), # Filter that selects conditions with IV1 <= IV2\n", - " (\"sampler\", random_sampler) # Sampler defined in the first implementation example\n", - " ],\n", - " {\"sampler\": {\"n\": 10}}\n", - ")\n", - "# Run the Pipeline\n", - "results1 = pipeline_random_samp2.run()\n", - "results2 = pipeline_random_samp2.run()\n", - "print('Sampled Conditions:')\n", - "print(f' Run 1: {results1}\\n',\n", - " f'Run 2: {results2}')" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "markdown", - "source": [ - "Running the pipeline multiple times results in an empty list. This is because the iterator is exhausted after first run and no longer yields results. If the pipeline needs to be run multiple times, initializing the functions as a callable using the `partial` function is recommended because the iterator will be initialized at the start of each run." - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "markdown", - "source": [ - "You could also use the scikit-learn \"__\" syntax to pass parameter sets into the pipeline:" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": 8, - "outputs": [ - { - "data": { - "text/plain": "Pipeline(steps=[('grid_pool', ), ('weber_filer', ), ('random_sampler', )], params={'grid_pool__ivs': [IV(name='S1', value_range=None, allowed_values=array([0. , 1.25, 2.5 , 3.75, 5. ]), units='intensity', type=, variable_label='Stimulus 1 Intensity', rescale=1, is_covariate=False), IV(name='S2', value_range=None, allowed_values=array([0. , 1.25, 2.5 , 3.75, 5. ]), units='intensity', type=, variable_label='Stimulus 2 Intensity', rescale=1, is_covariate=False)], 'random_sampler__n': 10})" - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "pipeline_random_samp = Pipeline([\n", - " (\"grid_pool\", grid_pool),\n", - " (\"weber_filer\", weber_filter), # Filter that selects conditions with IV1 <= IV2\n", - " (\"random_sampler\", random_sampler)\n", - "],\n", - " {\"grid_pool__ivs\": metadata.independent_variables, \"random_sampler__n\": 10}\n", - ")\n", - "pipeline_random_samp\n" - ], - "metadata": { - "collapsed": false - } - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 2 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython2", - "version": "2.7.6" - } - }, - "nbformat": 4, - "nbformat_minor": 0 -} diff --git a/docs/synthetic/inventory.ipynb b/docs/synthetic/inventory.ipynb deleted file mode 100644 index 54be9ee17..000000000 --- a/docs/synthetic/inventory.ipynb +++ /dev/null @@ -1,68 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": [ - "# Uncomment the following line when running on Google Colab\n", - "# !pip install autora" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": [ - "from autora.synthetic import retrieve, Inventory\n", - "from sklearn.linear_model import LinearRegression" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": [ - "for id in Inventory.keys():\n", - " s = retrieve(id)\n", - " print(s)\n", - " X = s.domain()\n", - " y_exp = s.experiment_runner(X)\n", - " y_gt = s.ground_truth(X)\n", - " s.plotter() # without model\n", - " fitter = LinearRegression().fit(X, y_exp)\n", - " s.plotter(fitter)\n" - ], - "metadata": { - "collapsed": false - } - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 2 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython2", - "version": "2.7.6" - } - }, - "nbformat": 4, - "nbformat_minor": 0 -} diff --git a/docs/theorist/bms/example.ipynb b/docs/theorist/bms/example.ipynb deleted file mode 100644 index b297a26bd..000000000 --- a/docs/theorist/bms/example.ipynb +++ /dev/null @@ -1,210 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "source": [ - "# Bayesian Machine Scientist" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "markdown", - "source": [ - "## Example" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": [ - "# Uncomment the following line when running on Google Colab\n", - "# !pip install autora" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "markdown", - "source": [ - "Let's generate a simple data set with two features $x_1, x_2 \\in [0, 1]$ and a target $y$. We will use the following generative model:\n", - "$y = 2 x_1 - e^{(5 x_2)}$" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": 7, - "outputs": [], - "source": [ - "import numpy as np\n", - "\n", - "x_1 = np.linspace(0, 1, num=10)\n", - "x_2 = np.linspace(0, 1, num=10)\n", - "X = np.array(np.meshgrid(x_1, x_2)).T.reshape(-1,2)\n", - "\n", - "y = 2 * X[:,0] + np.exp(5 * X[:,1])" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "markdown", - "source": [ - "Now let us choose a prior over the primitives. In this case, we will use priors determined by Guimerà et al (2020).\n" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": 8, - "outputs": [], - "source": [ - "prior = \"Guimera2020\"" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "markdown", - "source": [ - "## Set up the BMS Regressor\n", - "\n", - "We will use the BMS Regressor to predict the outcomes. There are a number of parameters that determine how the architecture search is performed. The most important ones are listed below:\n", - "\n", - "- **`epochs`**: The number of epochs to run BMS. This corresponds to the total number of equation mutations - one mcmc step for each parallel-tempered equation and one tree swap between a pair of parallel-tempered equations.\n", - "- **`prior_par`**: A dictionary of priors for each operation. The keys correspond to operations and the respective values correspond to prior probabilities of those operations. The model comes with a default.\n", - "- **`ts`**: A list of temperature values. The machine scientist creates an equation tree for each of these values. Higher temperature trees are harder to fit, and thus they help prevent overfitting of the model.\n", - "\n", - "\n", - "Let's use the same priors over primitives that we specified on the previous page as well as an illustrative set of temperatures to set up the BMS regressor with default parameters.\n" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": 9, - "outputs": [], - "source": [ - "from autora.skl.bms import BMSRegressor\n", - "\n", - "temperatures = [1.0] + [1.04**k for k in range(1, 20)]\n", - "\n", - "primitives = {\n", - " \"Psychology\": {\n", - " \"addition\": 5.8,\n", - " \"subtraction\": 4.3,\n", - " \"multiplication\": 5.0,\n", - " \"division\": 5.5,\n", - " }\n", - "}\n", - "\n", - "bms_estimator = BMSRegressor(\n", - " epochs=1500,\n", - " prior_par=primitives,\n", - " ts=temperatures,\n", - ")" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "markdown", - "source": [ - "Now we have everything to fit and verify the model." - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": 10, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:autora.skl.bms:BMS fitting started\n", - " 0%| | 0/1500 [00:00 1\u001B[0m \u001B[43mbms_estimator\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mfit\u001B[49m\u001B[43m(\u001B[49m\u001B[43mX\u001B[49m\u001B[43m,\u001B[49m\u001B[43my\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 2\u001B[0m bms_estimator\u001B[38;5;241m.\u001B[39mpredict(X)\n", - "File \u001B[0;32m~/Developer/autora/autora/skl/bms.py:133\u001B[0m, in \u001B[0;36mBMSRegressor.fit\u001B[0;34m(self, X, y, num_param, root, custom_ops, seed)\u001B[0m\n\u001B[1;32m 120\u001B[0m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39madd_primitive(root)\n\u001B[1;32m 121\u001B[0m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mpms \u001B[38;5;241m=\u001B[39m Parallel(\n\u001B[1;32m 122\u001B[0m Ts\u001B[38;5;241m=\u001B[39m\u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mts,\n\u001B[1;32m 123\u001B[0m variables\u001B[38;5;241m=\u001B[39m\u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mvariables,\n\u001B[0;32m (...)\u001B[0m\n\u001B[1;32m 131\u001B[0m seed\u001B[38;5;241m=\u001B[39mseed,\n\u001B[1;32m 132\u001B[0m )\n\u001B[0;32m--> 133\u001B[0m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mmodel_, \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mloss_, \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mcache_ \u001B[38;5;241m=\u001B[39m \u001B[43mutils\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mrun\u001B[49m\u001B[43m(\u001B[49m\u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mpms\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mepochs\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 134\u001B[0m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mmodels_ \u001B[38;5;241m=\u001B[39m \u001B[38;5;28mlist\u001B[39m(\u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mpms\u001B[38;5;241m.\u001B[39mtrees\u001B[38;5;241m.\u001B[39mvalues())\n\u001B[1;32m 136\u001B[0m _logger\u001B[38;5;241m.\u001B[39minfo(\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mBMS fitting finished\u001B[39m\u001B[38;5;124m\"\u001B[39m)\n", - "File \u001B[0;32m~/Developer/autora/autora/theorist/bms/utils.py:35\u001B[0m, in \u001B[0;36mrun\u001B[0;34m(pms, num_steps, thinning)\u001B[0m\n\u001B[1;32m 33\u001B[0m desc_len, model, model_len \u001B[38;5;241m=\u001B[39m [], pms\u001B[38;5;241m.\u001B[39mt1, np\u001B[38;5;241m.\u001B[39minf\n\u001B[1;32m 34\u001B[0m \u001B[38;5;28;01mfor\u001B[39;00m n \u001B[38;5;129;01min\u001B[39;00m tqdm(\u001B[38;5;28mrange\u001B[39m(num_steps)):\n\u001B[0;32m---> 35\u001B[0m \u001B[43mpms\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mmcmc_step\u001B[49m\u001B[43m(\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 36\u001B[0m pms\u001B[38;5;241m.\u001B[39mtree_swap()\n\u001B[1;32m 37\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m num_steps \u001B[38;5;241m%\u001B[39m thinning \u001B[38;5;241m==\u001B[39m \u001B[38;5;241m0\u001B[39m: \u001B[38;5;66;03m# sample less often if we thin more\u001B[39;00m\n", - "File \u001B[0;32m~/Developer/autora/autora/theorist/bms/parallel.py:102\u001B[0m, in \u001B[0;36mParallel.mcmc_step\u001B[0;34m(self, verbose, p_rr, p_long)\u001B[0m\n\u001B[1;32m 99\u001B[0m p_rr \u001B[38;5;241m=\u001B[39m \u001B[38;5;241m0.0\u001B[39m\n\u001B[1;32m 100\u001B[0m \u001B[38;5;28;01mfor\u001B[39;00m T, tree \u001B[38;5;129;01min\u001B[39;00m \u001B[38;5;28mlist\u001B[39m(\u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mtrees\u001B[38;5;241m.\u001B[39mitems()):\n\u001B[1;32m 101\u001B[0m \u001B[38;5;66;03m# MCMC step\u001B[39;00m\n\u001B[0;32m--> 102\u001B[0m \u001B[43mtree\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mmcmc_step\u001B[49m\u001B[43m(\u001B[49m\u001B[43mverbose\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mverbose\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mp_rr\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mp_rr\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mp_long\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mp_long\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 103\u001B[0m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mt1 \u001B[38;5;241m=\u001B[39m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mtrees[\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124m1.0\u001B[39m\u001B[38;5;124m\"\u001B[39m]\n", - "File \u001B[0;32m~/Developer/autora/autora/theorist/bms/mcmc.py:1160\u001B[0m, in \u001B[0;36mTree.mcmc_step\u001B[0;34m(self, verbose, p_rr, p_long)\u001B[0m\n\u001B[1;32m 1157\u001B[0m \u001B[38;5;28;01melse\u001B[39;00m:\n\u001B[1;32m 1158\u001B[0m \u001B[38;5;66;03m# Try to replace the root\u001B[39;00m\n\u001B[1;32m 1159\u001B[0m newrr \u001B[38;5;241m=\u001B[39m choice(\u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mrr_space)\n\u001B[0;32m-> 1160\u001B[0m dE, dEB, dEP, par_valuesNew \u001B[38;5;241m=\u001B[39m \u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mdE_rr\u001B[49m\u001B[43m(\u001B[49m\u001B[43mrr\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mnewrr\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mverbose\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mverbose\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 1161\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mnum_rr \u001B[38;5;241m>\u001B[39m \u001B[38;5;241m0\u001B[39m \u001B[38;5;129;01mand\u001B[39;00m \u001B[38;5;241m-\u001B[39mdEB \u001B[38;5;241m/\u001B[39m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mBT \u001B[38;5;241m-\u001B[39m dEP \u001B[38;5;241m/\u001B[39m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mPT \u001B[38;5;241m>\u001B[39m \u001B[38;5;241m0\u001B[39m:\n\u001B[1;32m 1162\u001B[0m paccept \u001B[38;5;241m=\u001B[39m \u001B[38;5;241m1.0\u001B[39m\n", - "File \u001B[0;32m~/Developer/autora/autora/theorist/bms/mcmc.py:1093\u001B[0m, in \u001B[0;36mTree.dE_rr\u001B[0;34m(self, rr, verbose)\u001B[0m\n\u001B[1;32m 1090\u001B[0m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mpar_values \u001B[38;5;241m=\u001B[39m old_par_values\n\u001B[1;32m 1092\u001B[0m \u001B[38;5;66;03m# Prior: change due to the numbers of each operation\u001B[39;00m\n\u001B[0;32m-> 1093\u001B[0m dEP \u001B[38;5;241m+\u001B[39m\u001B[38;5;241m=\u001B[39m \u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mprior_par\u001B[49m\u001B[43m[\u001B[49m\u001B[38;5;124;43m\"\u001B[39;49m\u001B[38;5;124;43mNopi_\u001B[39;49m\u001B[38;5;132;43;01m%s\u001B[39;49;00m\u001B[38;5;124;43m\"\u001B[39;49m\u001B[43m \u001B[49m\u001B[38;5;241;43m%\u001B[39;49m\u001B[43m \u001B[49m\u001B[43mrr\u001B[49m\u001B[43m[\u001B[49m\u001B[38;5;241;43m0\u001B[39;49m\u001B[43m]\u001B[49m\u001B[43m]\u001B[49m\n\u001B[1;32m 1094\u001B[0m \u001B[38;5;28;01mtry\u001B[39;00m:\n\u001B[1;32m 1095\u001B[0m dEP \u001B[38;5;241m+\u001B[39m\u001B[38;5;241m=\u001B[39m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mprior_par[\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mNopi2_\u001B[39m\u001B[38;5;132;01m%s\u001B[39;00m\u001B[38;5;124m\"\u001B[39m \u001B[38;5;241m%\u001B[39m rr[\u001B[38;5;241m0\u001B[39m]] \u001B[38;5;241m*\u001B[39m (\n\u001B[1;32m 1096\u001B[0m (\u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mnops[rr[\u001B[38;5;241m0\u001B[39m]] \u001B[38;5;241m+\u001B[39m \u001B[38;5;241m1\u001B[39m) \u001B[38;5;241m*\u001B[39m\u001B[38;5;241m*\u001B[39m \u001B[38;5;241m2\u001B[39m \u001B[38;5;241m-\u001B[39m (\u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mnops[rr[\u001B[38;5;241m0\u001B[39m]]) \u001B[38;5;241m*\u001B[39m\u001B[38;5;241m*\u001B[39m \u001B[38;5;241m2\u001B[39m\n\u001B[1;32m 1097\u001B[0m )\n", - "\u001B[0;31mKeyError\u001B[0m: 'Nopi_*'" - ] - } - ], - "source": [ - "bms_estimator.fit(X,y)\n", - "bms_estimator.predict(X)" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "markdown", - "source": [ - "## Troubleshooting\n", - "\n", - "We can troubleshoot the model by playing with a few parameters:\n", - "\n", - "- Increasing the number of epochs. The original paper recommends 1500-3000 epochs for reliable fitting. The default is set to 1500.\n", - "- Using custom priors that are more relevant to the data. The default priors are over equations nonspecific to any particular scientific domain.\n", - "- Increasing the range of temperature values to escape local minima.\n", - "- Reducing the differences between parallel temperatures to escape local minima.\n" - ], - "metadata": { - "collapsed": false - } - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 2 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython2", - "version": "2.7.6" - } - }, - "nbformat": 4, - "nbformat_minor": 0 -} diff --git a/docs/theorist/bms/how_it_works.md b/docs/theorist/bms/how_it_works.md deleted file mode 100644 index 40ab6a6d5..000000000 --- a/docs/theorist/bms/how_it_works.md +++ /dev/null @@ -1,75 +0,0 @@ -# Bayesian Machine Scientist - -## How it works - -The Bayesian Machine Scientist (BMS) uses Bayesian inference to search the space of possible equations. The following are the relevant quantities in this Bayesian approach: - -- $P(x):$ Probability of $x$ -- $P(x|\theta)$: Conditional Probability of $x$ given $\theta$ -- $P(x,\theta)$: Joint Probability of $x$ and $\theta$ - -Mathematically, we know: - -$P(x,\theta)=P(x)P(\theta|x)=P(\theta)P(x|\theta)$ - -Rearranging this expression, we get Bayes rule: - -$P(\theta|x)=\dfrac{P(x|\theta)P(\theta)}{P(x)}$ - -Here, $P(\theta)$ is the prior probability, $P(x|\theta)$ is the probability of data given the prior (also known as the 'likelihood'), $P(x)$ is the probability of the data marginalized over all possible values of $\theta$, and $P(\theta|x)$ is the posterior probability. - -In essence, prior knowledge $P(\theta)$ is combined with evidence $P(x|\theta)$ to arrive at better knowledge $P(\theta|x)$. - -BMS capitalizes on this process for updating knowledge: - -1) It formulates the problem of fitting an equation to data by first specifying priors over equations. In their paper, Guimerà et al. use the empirical frequency of equations on Wikipedia to specify these priors. - -$P(f_i|D)=\dfrac{1}{Z}\int_{\Theta_i}P(D|f_i,\theta_i)P(\theta_i|f_i)P(f_i)d\theta_i$ - -$Z=P(D)$ is a constant, so we can ignore it since we are only interested in finding the best equation for the specific data at hand. - -2) It then scores different candidate equations using description length as a loss function. Formally, this description length is the number of natural units of information (nats) needed to jointly encode the data and the equation optimally. - -$\mathscr{L}(f_i)\equiv-\log[P(D,f_i)]=-\log[P(f_i|D)P(D)]=-\log[\int_{\Theta_i}P(D|f_i,\theta_i)P(\theta_i|f_i)P(f_i)d\theta_i]$ - -3) Since the loss function is computationally intractable, it uses an approximation: - -$\mathscr{L}(f_i)\approx\dfrac{B(f_i)}{2} - \log[P(f_i)]$ - -where $B(f_i)=k\log[n] - 2\log[P(D|\theta^*,f_i)]$ - -In this formulation, the goodness of fit $p(D|\theta^*,f_i)$ and likelihood $p(f_i)$ of an equation are equally and logarithmically weighted to each other (e.g., improving the fit by a factor of 2 is offset by halving the likelihood). - -To better frame the problem, equations are modeled as acyclic graphs (i.e., trees). - -Bayesian inference via MCMC is then applied to navigate the search space efficiently. Note, there are many sampling strategies other than MCMC that could be used. - -The search space is very rugged, and local minima are difficult to escape, so BMS employs parallel tempering to overcome this. - -![Parallel_Tempering](img/BMSTempering.png) - -One incremental unit of search in this approach involves two steps: - -I) Markov chain Monte Carlo Sampling: - - a) One of three mutations - Root Removal/Addition, Elementary Tree Replacement, Node Replacement - are selected for the equation tree. - b) Choosing the operator associated with the mutation relies on how likely the operator is to turn up (encoded in the priors). - c) Choosing a specific variable or parameter value is random. - d) Accepting or rejecting the mutation depends on Metropolis' rule. - -![Tree_Mutations](img/BMSEquationTreeOps.png) - -II) Parallel Tree Swap: - - a) Two parallel trees held at different temperatures are selected. - b) The temperatures of the two trees are swapped. - c) If this decreases the loss of the now colder tree, the tree temperatures are permanently swapped. - d) If not, the trees are reverted to preexisting temperatures. - -After iterating over these two steps for $n$ epochs, the tree held at the lowest temperature is returned as the best fitted model for the data provided. - -## References - -R. Guimerà et al., A Bayesian machine scientist to aid in the solution of challenging scientific problems. Sci. Adv. -6, eaav697 (2020). -Wit, Ernst; Edwin van den Heuvel; Jan-Willem Romeyn (2012). diff --git a/docs/theorist/bms/img/BMSEquationTreeOps.png b/docs/theorist/bms/img/BMSEquationTreeOps.png deleted file mode 100644 index 8d6da4193..000000000 Binary files a/docs/theorist/bms/img/BMSEquationTreeOps.png and /dev/null differ diff --git a/docs/theorist/bms/img/BMSTempering.png b/docs/theorist/bms/img/BMSTempering.png deleted file mode 100644 index a4ac5e590..000000000 Binary files a/docs/theorist/bms/img/BMSTempering.png and /dev/null differ diff --git a/docs/theorist/bms/introduction.md b/docs/theorist/bms/introduction.md deleted file mode 100644 index 6dbb19dd7..000000000 --- a/docs/theorist/bms/introduction.md +++ /dev/null @@ -1,23 +0,0 @@ -# Bayesian Machine Scientist - -## Introduction - -Symbolic regression (SR) refers to a class of algorithms that search for interpretable symbolic expressions which -capture relationships within data. More specifically, SR attempts to find compositions of simple functions -that accurately map independent variables to dependent variables within a given dataset. SR was traditionally tackled -through genetic programming, wherein evolutionary algorithms mutated and crossbred equations billions of -times in search of the best match. There are problems with genetic programming, however, which stem from its inherent search constraints as well -as its reliance upon heuristics and domain knowledge to balance goodness of fit and model complexity. To address these -problems, Guimerà et. al (2020) proposed a Bayesian Machine Scientist (BMS), which combines i) a Bayesian approach that -specifies informed priors over expressions and computes their respective posterior probabilities given the data at hand, -and ii) a Markov chain Monte Carlo (MCMC) algorithm that samples from the posterior over expressions to more effectively explore the -space of possible symbolic expressions. - -AutoRA provides an adapted version of BMS for automating the discovery of interpretable models of human information -processing. - -## References - -R. Guimerà et al., A Bayesian machine scientist to aid in the solution of challenging scientific problems. Sci. Adv. -6, eaav697 (2020). - diff --git a/docs/theorist/bms/meta_parameters.md b/docs/theorist/bms/meta_parameters.md deleted file mode 100644 index 7961f16fd..000000000 --- a/docs/theorist/bms/meta_parameters.md +++ /dev/null @@ -1,9 +0,0 @@ -# Bayesian Machine Scientist - -## Meta-Parameters - -Meta-parameters are used to control the search space and the search algorithm. This section provides a basic overview of these parameters along with a description of their effects. - -- **`epochs`**: The number of epochs to run BMS. This corresponds to the total number of equation mutations - one mcmc step for each parallel-tempered equation and one tree swap between a pair of parallel-tempered equations. -- **`prior_par`**: A dictionary of priors for each operation. The keys correspond to operations and the respective values correspond to prior probabilities of those operations. The model comes with a default. -- **`ts`**: A list of temperature values. The machine scientist creates an equation tree for each of these values. Higher temperature trees are harder to fit, and thus they help prevent overfitting of the model. diff --git a/docs/theorist/bms/search_space.ipynb b/docs/theorist/bms/search_space.ipynb deleted file mode 100644 index 07171e1c5..000000000 --- a/docs/theorist/bms/search_space.ipynb +++ /dev/null @@ -1,126 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "source": [ - "# Bayesian Machine Scientist\n", - "\n", - "## Search space\n", - "\n", - "BMS searches the space of operations according to certain parameters to find the best model. As such, the search space is defined by the set of operations that can be applied in each computation step of the model. These operations are also referred to as *primitives*. We can select from the following set of primitives:\n", - "\n", - "- **$\\textit{constant}$**: The output of the computation $x_j$ is a constant parameter value $a$ where $a$ is a fitted float value.\n", - "- **\\+**: The output of the computation $x_j$ is the sum over its two inputs $x_i, x_{ii}$: $x_j = x_i + x_{ii}$.\n", - "- **\\-**: The output of the computation $x_j$ is the respective difference between its inputs $x_i, x_{ii}$: $x_j = x_i - x_{ii}$.\n", - "- **\\***: The output of the computation $x_j$ is the product over its two inputs $x_i, x_{ii}$: $x_j = x_i * x_{ii}$.\n", - "- **\\/**: The output of the computation $x_j$ is the respective quotient between its inputs $x_i, x_{ii}$: $x_j = x_i / x_{ii}$.\n", - "- **abs**: The output of the computation $x_j$ is the absolute value of its input $x_i$: $x_j = |(x_i)|$.\n", - "- **relu**: The output of the computation $x_j$ is a rectified linear function applied to its input $x_i$: $x_j = \\max(0, x_i)$.\n", - "- **exp**: The output of the computation $x_j$ is the natural exponential function applied to its input $x_i$: $x_j = \\exp(x_i)$.\n", - "- **log**: The output of the computation $x_j$ is the natural logarithm function applied to its input $x_i$: $x_j = \\log(x_i)$.\n", - "- **sig**: The output of the computation $x_j$ is a logistic function applied to its input $x_i$: $x_j = \\frac{1}{1 + \\exp(-b * x_i)}$.\n", - "- **fac**: The output of the computation $x_j$ is the generalized factorial function applied to its input $x_i$: $x_j = \\Gamma(1 + x_i)$.\n", - "- **sqrt**: The output of the computation $x_j$ is the square root function applied to its input $x_i$: $x_j = \\sqrt(x_i)$.\n", - "- **pow2**: The output of the computation $x_j$ is the square function applied to its input $x_i$: $x_j$ = $x_i^2$.\n", - "- **pow3**: The output of the computation $x_j$ is the cube function applied to its input $x_i$: $x_j$ = $x_i^3$.\n", - "- **sin**: The output of the computation $x_j$ is the sine function applied to its input $x_i$: $x_j = \\sin(x_i)$.\n", - "- **sinh**: The output of the computation $x_j$ is the hyperbolic sine function applied to its input $x_i$: $x_j = \\sinh(x_i)$.\n", - "- **cos**: The output of the computation $x_j$ is the cosine function applied to its input $x_i$: $x_j = \\cos(x_i)$.\n", - "- **cosh**: The output of the computation $x_j$ is the hyperbolic cosine function applied to its input $x_i$: $x_j = \\cosh(x_i)$.\n", - "- **tan**: The output of the computation $x_j$ is the tangent function applied to its input $x_i$: $x_j = \\tan(x_i)$.\n", - "- **tanh**: The output of the computation $x_j$ is the hyperbolic tangent function applied to its input $x_i$: $x_j = \\tanh(x_i)$.\n", - "- **\\*\\***: The output of the computation $x_j$ is the first input raised to the power of the second input $x_i,x_{ii}$: $x_j$ = $x_i^{x_{ii}}$.\n", - "\n", - "## Example" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": 0, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "# Uncomment the following line when running on Google Colab\n", - "# !pip install autora" - ] - }, - { - "cell_type": "markdown", - "source": [ - "The following example sets up a search space over four illustrative operations found in Wikipedia pages that are tagged by psychology. These operations are our primitives:" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": 1, - "outputs": [], - "source": [ - "\n", - "primitives = {\n", - " \"Psychology\": {\n", - " \"addition\": 5.8,\n", - " \"subtraction\": 4.3,\n", - " \"multiplication\": 5.0,\n", - " \"division\": 5.5,\n", - " }\n", - "}" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "markdown", - "source": [ - "We can then pass these primitives directly to the BMS regressor as follows:" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": 2, - "outputs": [], - "source": [ - "from autora.skl.bms import BMSRegressor\n", - "\n", - "bms_estimator = BMSRegressor(\n", - " prior_par=primitives\n", - ")\n" - ], - "metadata": { - "collapsed": false - } - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 2 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython2", - "version": "2.7.6" - } - }, - "nbformat": 4, - "nbformat_minor": 0 -} diff --git a/docs/theorist/bms/weber.ipynb b/docs/theorist/bms/weber.ipynb deleted file mode 100644 index ecd2759df..000000000 --- a/docs/theorist/bms/weber.ipynb +++ /dev/null @@ -1,14324 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "3ba2ff78", - "metadata": {}, - "source": [ - "Example file which shows some simple curve fitting using BMSRegressor and some other estimators." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": [ - "# Uncomment the following line when running on Google Colab\n", - "# !pip install autora" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": 21, - "id": "41b221c2", - "metadata": {}, - "outputs": [], - "source": [ - "from functools import partial\n", - "\n", - "import pandas as pd\n", - "import numpy as np\n", - "from sklearn.linear_model import LinearRegression\n", - "from sklearn.model_selection import GridSearchCV\n", - "from sklearn.pipeline import make_pipeline\n", - "from sklearn.preprocessing import PolynomialFeatures\n", - "import matplotlib.pyplot as plt\n", - "from autora.skl.bms import BMSRegressor\n", - "from autora.synthetic import retrieve" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "id": "343e2f03", - "metadata": {}, - "outputs": [], - "source": [ - "def show_results_complete(\n", - " data_: pd.DataFrame,\n", - " estimator=None,\n", - " show_results=True,\n", - " projection=\"2d\",\n", - " label=None,\n", - "):\n", - " \"\"\"\n", - " Function to plot input data (x_, y_) and the predictions of an estimator for the same x_.\n", - " \"\"\"\n", - " if projection == \"2d\":\n", - " plt.figure()\n", - " data_.plot.scatter(\n", - " \"S1\", \"S2\", c=\"difference_detected\", cmap=\"viridis\", zorder=10\n", - " )\n", - " elif projection == \"3d\":\n", - " fig = plt.figure()\n", - " ax = fig.add_subplot(projection=\"3d\")\n", - " ax.scatter(data_[\"S1\"], data[\"S2\"], data[\"difference_detected\"])\n", - " if estimator is not None:\n", - " xs, ys = np.mgrid[0:5:0.2, 0:5:0.2] # type: ignore\n", - " zs = estimator.predict(np.column_stack((xs.ravel(), ys.ravel())))\n", - " ax.plot_surface(xs, ys, zs.reshape(xs.shape), alpha=0.5)\n", - "\n", - " if label is not None:\n", - " plt.title(label)\n", - "\n", - " if show_results:\n", - " plt.show()\n", - "\n", - " return" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "outputs": [], - "source": [], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": 28, - "id": "5bfd6747", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": "
", - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# %% Load the data\n", - "s = retrieve(\"weber_fechner\",rng=np.random.default_rng(seed=180), resolution=20)\n", - "X_ = s.domain()\n", - "y_ = s.experiment_runner(X_)\n", - "data = pd.DataFrame(np.column_stack([X_, y_]), columns=[\"S1\", \"S2\", \"difference_detected\"])\n", - "show_results = partial(show_results_complete, data_=data, projection=\"3d\")\n", - "show_results(label=\"input data\")\n", - "X, y = data[[\"S1\", \"S2\"]], data[\"difference_detected\"]" - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "id": "89405909", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/jholla10/Library/Caches/pypoetry/virtualenvs/autora-17yK3Jyq-py3.8/lib/python3.8/site-packages/sklearn/base.py:439: UserWarning: X does not have valid feature names, but LinearRegression was fitted with feature names\n", - " warnings.warn(\n" - ] - }, - { - "data": { - "text/plain": "
", - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# %% Fit first using a super-simple linear regression\n", - "\n", - "first_order_linear_estimator = LinearRegression()\n", - "first_order_linear_estimator.fit(X, y)\n", - "\n", - "show_results(estimator=first_order_linear_estimator, label=\"1st order linear\")" - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "id": "f67dbeeb", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/jholla10/Library/Caches/pypoetry/virtualenvs/autora-17yK3Jyq-py3.8/lib/python3.8/site-packages/sklearn/base.py:439: UserWarning: X does not have valid feature names, but PolynomialFeatures was fitted with feature names\n", - " warnings.warn(\n" - ] - }, - { - "data": { - "text/plain": "
", - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# %% Fit using a 0-3 order polynomial, getting the best fit for the data.\n", - "polynomial_estimator = GridSearchCV(\n", - " make_pipeline(PolynomialFeatures(), LinearRegression(fit_intercept=False)),\n", - " param_grid=dict(polynomialfeatures__degree=range(4)),\n", - ")\n", - "polynomial_estimator.fit(X, y)\n", - "\n", - "show_results(estimator=polynomial_estimator, label=\"[0th-3rd]-order linear\")" - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "id": "3d870dbb", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:autora.skl.bms:BMS fitting started\n", - " 0%| | 7/1500 [00:00<01:15, 19.80it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return S2**2*_a0_**S1\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return -_a0_**S2\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return -_a0_**S2\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return -_a0_**S2\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(cos(S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(cos(S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(cos(S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return _a0_**S1/S2\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(S1/_a0_)\n", - " 1%| | 10/1500 [00:00<01:11, 20.75it/s]/Users/jholla10/Library/Caches/pypoetry/virtualenvs/autora-17yK3Jyq-py3.8/lib/python3.8/site-packages/scipy/optimize/_minpack_py.py:906: OptimizeWarning: Covariance of the parameters could not be estimated\n", - " warnings.warn('Covariance of the parameters could not be estimated',\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(_a0_/S2**2)\n", - " 1%| | 16/1500 [00:00<01:10, 21.08it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(cos(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(cos(S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return S2*cos(S2)**(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return S2*cos(S2)**(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return S2*cos(S2)**(-S1)\n", - " 1%|▏ | 19/1500 [00:00<01:09, 21.32it/s]:2: RuntimeWarning: invalid value encountered in scalar power\n", - " return (_a0_**3)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return (_a0_**3)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return (_a0_**3)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return _a0_**(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2 + _a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2 + _a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2 + _a0_)**_a0_\n", - " 1%|▏ | 22/1500 [00:01<01:06, 22.25it/s]:2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return fac(_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return fac(_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return fac(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S1 + _a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S1 + _a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S1 + _a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2 + _a0_)**S1\n", - " 2%|▏ | 25/1500 [00:01<01:11, 20.69it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return S2*_a0_**sin(S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return _a0_**(-S1)*sig(_a0_/S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return _a0_**(-S1)*sig(_a0_/S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return _a0_**(-S1)*sig(_a0_/S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return tan(S2)**(_a0_/S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return tan(S2)**(_a0_/S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return tan(S2)**(_a0_/S1)\n", - " 2%|▏ | 28/1500 [00:01<01:11, 20.71it/s]:2: RuntimeWarning: overflow encountered in power\n", - " return S1**(S2**S2)\n", - "/Users/jholla10/Library/Caches/pypoetry/virtualenvs/autora-17yK3Jyq-py3.8/lib/python3.8/site-packages/pandas/core/arraylike.py:402: RuntimeWarning: overflow encountered in square\n", - " result = getattr(ufunc, method)(*inputs, **kwargs)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return S1**(S2**S2)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return S1**(S2**S2)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return -_a0_*_a0_**(-S1)\n", - " 2%|▏ | 34/1500 [00:01<01:13, 20.01it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return sig(_a0_**S1)/S1\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sig(_a0_**S1)/S1\n", - " 3%|▎ | 40/1500 [00:01<01:15, 19.45it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return S2*_a0_**(-S2)\n", - " 3%|▎ | 42/1500 [00:02<01:16, 19.18it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return S2*_a0_**(-S2 - _a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return S1**3 + sig(_a0_**S1)**S1\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(cos(S1))\n", - " 3%|▎ | 44/1500 [00:02<01:19, 18.29it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return sin(S1)**((1/2)*_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sin(S1)**((1/2)*_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return -_a0_**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return -_a0_**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return -_a0_**_a0_\n", - " 3%|▎ | 46/1500 [00:02<01:25, 17.02it/s]:2: RuntimeWarning: overflow encountered in exp\n", - " return exp(S2**S2)\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return exp(S2**S2)\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return exp(S2**S2)\n", - " 3%|▎ | 48/1500 [00:02<01:29, 16.20it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(log(_a0_)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(log(_a0_)/S1)\n", - " 3%|▎ | 52/1500 [00:02<01:28, 16.33it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(cos(S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sig(_a0_**S1)/S1\n", - " 4%|▎ | 56/1500 [00:02<01:29, 16.12it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return cos(S1)**((1/2)*_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return cos(S1)**((1/2)*_a0_)\n", - " 4%|▍ | 58/1500 [00:03<01:27, 16.48it/s]:2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(_a0_**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(_a0_**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(sin(S2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(sin(S2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(sin(S2))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return S2*_a0_**(S2**S2)\n", - "/Users/jholla10/Library/Caches/pypoetry/virtualenvs/autora-17yK3Jyq-py3.8/lib/python3.8/site-packages/scipy/optimize/_minpack_py.py:862: RuntimeWarning: overflow encountered in square\n", - " cost = np.sum(infodict['fvec'] ** 2)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return S2*_a0_**(S2**S2)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return S2*_a0_**(S2**S2)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-S1 - _a0_*(S1 + S2))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-S1 - _a0_*(S1 + S2))\n", - " 4%|▍ | 60/1500 [00:03<01:26, 16.62it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(S1)**((1/2)*sqrt(_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(S1)**((1/2)*sqrt(_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(S1)**((1/2)*sqrt(_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2*(S1*S2)**(1/4)/_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(_a0_)/sqrt(sin(S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(_a0_)/sqrt(sin(S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(_a0_)/sqrt(sin(S1))\n", - " 4%|▍ | 62/1500 [00:03<01:24, 17.07it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return relu((_a0_**S1)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu((_a0_**S1)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu((_a0_**S1)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(log(S2)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(log(S2)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(log(S2)/S1)\n", - " 4%|▍ | 64/1500 [00:03<01:22, 17.31it/s]:2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(_a0_)**((1/2)*_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(_a0_)**((1/2)*_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return S2 + _a0_**relu(S1)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(S1**(S1**S1))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(S1**(S1**S1))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(S1**(S1**S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-(S1 + S2)*(S1 + _a0_)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-(S1 + S2)*(S1 + _a0_)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-(S1 + S2)*(S1 + _a0_)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-_a0_*(S1 + _a0_)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-_a0_*(S1 + _a0_)/S1)\n", - " 4%|▍ | 66/1500 [00:03<01:26, 16.57it/s]:2: RuntimeWarning: invalid value encountered in scalar power\n", - " return _a0_**((1/2)*_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return _a0_**((1/2)*_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return _a0_**((1/2)*_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-(S1 + S2)*cosh(S2)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-(S1 + S2)*cosh(S2)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-(S1 + S2)*cosh(S2)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-_a0_/S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-_a0_/S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-_a0_/S1)\n", - " 5%|▍ | 68/1500 [00:03<01:29, 16.04it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return tan(relu(S1))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return tan(relu(S1))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return S1**(_a0_**S2)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return S1**(_a0_**S2)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return S1**(_a0_**S2)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-_a0_*(S1 + tan(_a0_))/S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-_a0_*(S1 + tan(_a0_))/S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-_a0_*(S1 + tan(_a0_))/S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S1/_a0_)**(_a0_/S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S1/_a0_)**(_a0_/S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S1/_a0_)**(_a0_/S1)\n", - " 5%|▍ | 70/1500 [00:04<02:30, 9.48it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return relu((S2/_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu((S2/_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu((S2/_a0_)**_a0_)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return S1**(-relu(fac(_a0_)))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(log(_a0_/S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(log(_a0_/S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(tan(_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(tan(_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(tan(_a0_))\n", - " 5%|▍ | 72/1500 [00:04<02:14, 10.63it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return ((S1*S2)**(1/4)/_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return S1**(_a0_**S2)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return S1**(_a0_**S2)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return S2*_a0_**relu(_a0_/S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(tan(S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(tan(S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(tan(S1))\n", - " 5%|▍ | 74/1500 [00:04<02:05, 11.35it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-S2**_a0_*(S2 + _a0_**2)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-S2**_a0_*(S2 + _a0_**2)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-S2**_a0_*(S2 + _a0_**2)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return _a0_**sin(_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return _a0_**sin(_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(cos(S2))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(cos(S2))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(cos(S2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(_a0_/S1)/S1\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(_a0_/S1)/S1\n", - " 5%|▌ | 76/1500 [00:04<01:55, 12.38it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return _a0_*sig(sig(log(_a0_)))**(_a0_**2)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (tan(sqrt(S2*_a0_*relu(S1)))/S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (tan(sqrt(S2*_a0_*relu(S1)))/S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sig(sig(log(_a0_)))**(S1*_a0_)*tanh(_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-_a0_*(S2 + 2*_a0_)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-_a0_*(S2 + 2*_a0_)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-_a0_*(S2 + 2*_a0_)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return S1**(_a0_**S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return S1**(_a0_**S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return S1**(_a0_**S1)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return log(_a0_*_a0_**(-_a0_))\n", - " 5%|▌ | 78/1500 [00:04<01:53, 12.52it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return (S2*_a0_*relu(S1))**(1/4)/S1\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-S2 - _a0_**2)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-S2 - _a0_**2)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return (2*_a0_)**tanh(_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return (2*_a0_)**tanh(_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return (2*_a0_)**tanh(_a0_)\n", - " 5%|▌ | 80/1500 [00:04<01:43, 13.68it/s]:2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(S2*_a0_))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(S2*_a0_))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(S2*_a0_))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-_a0_*(_a0_**2 + _a0_)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-_a0_*(_a0_**2 + _a0_)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(_a0_)/sqrt(log(S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(_a0_)/sqrt(log(S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(_a0_)/sqrt(log(S1))\n", - " 5%|▌ | 82/1500 [00:04<01:41, 13.98it/s]:2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return _a0_**tanh(_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return _a0_**tanh(_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-_a0_*(_a0_**2 + _a0_)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-_a0_/S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-_a0_/S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-_a0_/S1)\n", - " 6%|▌ | 84/1500 [00:05<01:38, 14.37it/s]:2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(_a0_/S2)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(_a0_/S2)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(_a0_/S2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(S2/tan(S2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(S2/tan(S2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(S2/tan(S2))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-_a0_*(S2 + fac(S2))/S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(_a0_)**sin(_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(_a0_)**sin(_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(_a0_)**sin(_a0_)\n", - " 6%|▌ | 86/1500 [00:05<01:40, 14.08it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return S1**(_a0_**S2)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return S1**(_a0_**S2)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return S1**(-relu(_a0_**S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(cos(S2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(cos(S2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(cos(S2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(S1**log(_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(S1**log(_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(S1**log(_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return _a0_**(-S2)*sig(_a0_/S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return _a0_**(-S2)*sig(_a0_/S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return _a0_**(-S2)*sig(_a0_/S1)\n", - " 6%|▌ | 88/1500 [00:05<01:40, 14.06it/s]:2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(_a0_/S2)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(_a0_/S2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return S2*(_a0_**_a0_)**relu(S1)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return S2*(_a0_**_a0_)**relu(S1)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return S2*(_a0_**_a0_)**relu(S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sqrt(2)*sqrt(-S2*_a0_**S2/S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sqrt(2)*sqrt(-S2*_a0_**S2/S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sqrt(2)*sqrt(-S2*_a0_**S2/S1)\n", - ":2: RuntimeWarning: overflow encountered in cosh\n", - " return cosh(S1**(-S2)*_a0_)\n", - ":2: RuntimeWarning: overflow encountered in cosh\n", - " return cosh(S1**(-S2)*_a0_)\n", - ":2: RuntimeWarning: overflow encountered in cosh\n", - " return cosh(S1**(-S2)*_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(cos(S2)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(cos(S2)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(cos(S2)/S1)\n", - " 6%|▌ | 90/1500 [00:05<01:36, 14.56it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return relu((S1 + _a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu((S1 + _a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu((S1 + _a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-_a0_*(S2 + _a0_)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-_a0_*(S2 + _a0_)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sin(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sin(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sin(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(2)*sqrt(-S2*_a0_/S1)/S1\n", - " 6%|▌ | 92/1500 [00:05<01:40, 14.05it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-_a0_*fac(S2)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(2)*sqrt(-S2*(S2 + _a0_)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(2)*sqrt(-S2*(S2 + _a0_)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(2)*sqrt(-S2*(S2 + _a0_)/S1)\n", - " 6%|▋ | 94/1500 [00:05<01:35, 14.65it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return ((-S1)**(1/4)/S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return ((-S1)**(1/4)/S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return ((-S1)**(1/4)/S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sqrt(-(2*S2*_a0_)**S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sqrt(-(2*S2*_a0_)**S1)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(log(S1))**(-relu(_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(log(S1))**(-relu(_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(log(S1))**(-relu(_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sin(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sin(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sqrt(-(2*S2*_a0_)**S1)\n", - " 6%|▋ | 96/1500 [00:05<01:32, 15.17it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(sqrt(_a0_)))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(sqrt(_a0_)))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(sqrt(_a0_)))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(_a0_))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(_a0_))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-_a0_*cosh(S2)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2 + _a0_)**sin(_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2 + _a0_)**sin(_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2 + _a0_)**sin(_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return _a0_**(-_a0_)*sig(_a0_/S1)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return _a0_**(-_a0_)*sig(_a0_/S1)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return _a0_**(-_a0_)*sig(_a0_/S1)\n", - " 7%|▋ | 98/1500 [00:06<01:34, 14.82it/s]:2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-_a0_*relu(S2)/tan(S2))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-_a0_*relu(S2)/tan(S2))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-_a0_*relu(S2)/tan(S2))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(cos(S1))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(cos(S1))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(sinh(_a0_*relu(S2)/S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(sinh(_a0_*relu(S2)/S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(_a0_/S1)/S1\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(_a0_/S1)/S1\n", - " 7%|▋ | 100/1500 [00:06<01:29, 15.56it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return S1**sin(_a0_**S2)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return S1**sin(_a0_**S2)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return S1**sin(_a0_**S2)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return _a0_**S1/S1\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S1 + _a0_)**S1\n", - " 7%|▋ | 102/1500 [00:06<01:30, 15.40it/s]:2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-relu(S2)/(S2*_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return cosh(log(_a0_)**S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return cosh(log(_a0_)**S1)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(S1*_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(S1*_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(S1*_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sqrt(-_a0_**(-S2)*relu(S2)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sqrt(-_a0_**(-S2)*relu(S2)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sqrt(-_a0_**(-S2)*relu(S2)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(_a0_/S1**3)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return cosh((1/2)*log(_a0_)/_a0_)\n", - " 7%|▋ | 104/1500 [00:06<01:32, 15.04it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return ((S2*_a0_)**(1/4)/S2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return S1**(_a0_**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return S1**(_a0_**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return S1**(_a0_**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(_a0_/tan(S2))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(_a0_/tan(S2))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(_a0_/tan(S2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(cos(S1 + _a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(cos(S1 + _a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return ((1/2)*(S2*_a0_)**(1/4)/S2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(sinh(relu(S2)/(S1*_a0_)))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(sinh(relu(S2)/(S1*_a0_)))\n", - " 7%|▋ | 106/1500 [00:06<01:32, 15.00it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-1/S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-1/S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-1/S1)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return _a0_**sin(_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2 + _a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2 + _a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return tan(sinh(S1))**(-relu(_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return tan(sinh(S1))**(-relu(_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2/_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2/_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2/_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sig(sqrt(_a0_))/S1\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sig(sqrt(_a0_))/S1\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sig(sqrt(_a0_))/S1\n", - " 7%|▋ | 108/1500 [00:06<01:34, 14.81it/s]:2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(sin(S2)))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(sin(S2)))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(sin(S2)))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sin(S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sin(S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sin(S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S1*_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S1*_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S1*_a0_)**_a0_\n", - " 7%|▋ | 110/1500 [00:06<01:34, 14.76it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-relu(S1)/(S1*_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2 + _a0_)**cos(_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2 + _a0_)**cos(_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2 + _a0_)**cos(_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2*_a0_)**(1/4)/S1\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (-relu(S2)/(S1*_a0_))**(1/4)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return -_a0_**cos(_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return -_a0_**cos(_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return -_a0_**cos(_a0_)\n", - " 7%|▋ | 112/1500 [00:06<01:32, 15.00it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return (cos(S2)**(1/4)/S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (cos(S2)**(1/4)/S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (cos(S2)**(1/4)/S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(S1))**(-relu(_a0_**S2))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-1/S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-1/S1)\n", - " 8%|▊ | 114/1500 [00:07<01:29, 15.41it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return S1**(_a0_**S2)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return S1**(_a0_**S2)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-relu(S2)/_a0_**3)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(S2/_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(S2/_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(S2/_a0_)**_a0_\n", - " 8%|▊ | 116/1500 [00:07<01:26, 15.92it/s]:2: RuntimeWarning: invalid value encountered in divide\n", - " return relu(_a0_)/(sqrt(S1)*_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return tan(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return tan(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return tan(_a0_)**_a0_\n", - " 8%|▊ | 118/1500 [00:07<01:27, 15.84it/s]:2: RuntimeWarning: invalid value encountered in scalar power\n", - " return _a0_**_a0_*sig(_a0_)**S1\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return _a0_**_a0_*sig(_a0_)**S1\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return _a0_**_a0_*sig(_a0_)**S1\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(log(S1))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(log(S1))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S2/S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S2/S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S2/S1)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return (S1 + S2)*sig(S2*_a0_)**(S1*_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-S2/(S1*_a0_**2))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-S2/(S1*_a0_**2))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-S2/(S1*_a0_**2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(cos(S1 + _a0_)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(cos(S1 + _a0_)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return _a0_/log(_a0_)\n", - " 8%|▊ | 120/1500 [00:07<01:35, 14.40it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return S1**log(_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return S1**log(_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return tan(S1)**cos(_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return tan(S1)**cos(_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return tan(S1)**cos(_a0_)\n", - " 8%|▊ | 122/1500 [00:07<01:33, 14.68it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-(_a0_ + relu(S2))/S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-(_a0_ + relu(S2))/S1)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(S2/_a0_))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(S2/_a0_))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(S2/_a0_))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-S1**_a0_/(S1*_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return _a0_**(-S2)*sig(_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return _a0_**(-S2)*sig(_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return _a0_**(-S2)*sig(_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(_a0_**S2))**(-_a0_)\n", - " 8%|▊ | 124/1500 [00:07<01:27, 15.69it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-1/S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-1/S1)\n", - " 8%|▊ | 126/1500 [00:07<01:23, 16.43it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return sig(_a0_/S1)/log(_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sig(_a0_/S1)/log(_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sig(_a0_/S1)/log(_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S1 + _a0_)**(2*S1)\n", - " 9%|▊ | 128/1500 [00:07<01:23, 16.42it/s]:2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(S2 + _a0_))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(S2 + _a0_))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(S2 + _a0_))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sin(S1))**(-_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sin(S1))**(-_a0_)\n", - " 9%|▊ | 130/1500 [00:08<01:23, 16.46it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return ((S2*_a0_)**(1/4)/S1)**(sqrt(S2))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(-S1)**(-_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(-S1)**(-_a0_)\n", - " 9%|▉ | 132/1500 [00:08<01:23, 16.47it/s]:2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(S2 + _a0_))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(S2 + _a0_))**_a0_\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return S1**(S1**S1)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return S1**(S1**S1)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return S1**(S1**S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sig(_a0_/S1)/log(_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sig(_a0_/S1)/log(_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return _a0_**S2/S1\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return _a0_**S2/S1\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return _a0_**S2/S1\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(_a0_/S1**2)\n", - " 9%|▉ | 134/1500 [00:08<01:21, 16.67it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-relu(S2)/(_a0_*sin(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-relu(S2)/(_a0_*sin(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2 + _a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2 + _a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return S2*tanh(_a0_)**S1\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return S2*tanh(_a0_)**S1\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(_a0_)/sqrt(sin(S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(_a0_)/sqrt(sin(S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(_a0_/S1)/S1\n", - " 9%|▉ | 136/1500 [00:08<01:23, 16.40it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-1/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-1/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-1/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(tan(S1)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(tan(S1)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(tan(S1)/S1)\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return sqrt(-relu(S2)/(_a0_*relu(sinh(_a0_))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return sqrt(-relu(S2)/(_a0_*relu(sinh(_a0_))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return sqrt(-relu(S2)/(_a0_*relu(sinh(_a0_))))\n", - " 9%|▉ | 138/1500 [00:08<01:24, 16.21it/s]:2: RuntimeWarning: overflow encountered in power\n", - " return (S1 + S2)*sig(S1 + _a0_)**(S1*_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return sqrt(-relu(S2)/(_a0_*relu(_a0_)))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return sqrt(-relu(S2)/(_a0_*relu(_a0_)))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return S1**(_a0_**S2)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return S1**(_a0_**S2)\n", - " 9%|▉ | 140/1500 [00:08<01:28, 15.31it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(sin(relu(S2)/(_a0_*relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(sin(relu(S2)/(_a0_*relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return (_a0_**3)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return (_a0_**3)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(log(S1)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(log(S1)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(log(S1)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return ((S2*_a0_)**((1/4)*S1))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-relu(S2)/(S2*relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-relu(S2)/(S2*relu(S1)))\n", - " 9%|▉ | 142/1500 [00:08<01:26, 15.68it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-relu(S2)*exp(-S1)/_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(S2 + _a0_)**_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(S2 + _a0_)**_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(S2 + _a0_)**_a0_)\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(exp(cos(S1 + _a0_ + exp(S2/_a0_))))\n", - ":2: RuntimeWarning: invalid value encountered in cos\n", - " return relu(exp(cos(S1 + _a0_ + exp(S2/_a0_))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-S2**(-S1)*relu(S2)/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-S2**(-S1)*relu(S2)/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-S2**(-S1)*relu(S2)/relu(S1))\n", - " 10%|▉ | 144/1500 [00:08<01:25, 15.78it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-relu(S2)**_a0_/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-relu(S2)**_a0_/relu(S1))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(sin(S2)))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(sin(S2)))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(sin(S2)))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-relu(S2)/(S1*relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-relu(S2)/(S1*relu(S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(S2 + _a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(S2 + _a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(S2 + _a0_)**_a0_\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(exp(cos(S1 + exp(S1**S1/_a0_))))\n", - ":2: RuntimeWarning: invalid value encountered in cos\n", - " return relu(exp(cos(S1 + exp(S1**S1/_a0_))))\n", - " 10%|▉ | 146/1500 [00:09<01:27, 15.42it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(relu(S2)**3/(_a0_**3*relu(S1)**3))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(relu(S2)**3/(_a0_**3*relu(S1)**3))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-relu(S2)/(S1**2*relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-relu(S2)/(S1**2*relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-relu(S2)/(S1**2*relu(S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(S1 + _a0_))**_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(S1 + _a0_))**_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(S1 + _a0_))**_a0_)\n", - " 10%|▉ | 148/1500 [00:09<01:37, 13.83it/s]:2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(sin(S1)))**_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(sin(S1)))**_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(sin(S1)))**_a0_)\n", - " 10%|█ | 150/1500 [00:09<01:41, 13.26it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_**(-S2)*sqrt(sinh(S2*_a0_)))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (_a0_**(-S2)*sqrt(sinh(S2*_a0_)))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-relu(S2)/(S2*relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S2)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S2)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S2)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(_a0_/relu(S1**2))\n", - " 10%|█ | 152/1500 [00:09<01:39, 13.55it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(log(S2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(log(S2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(log(S2))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(tan(S1)/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(tan(S1)/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(tan(S1)/relu(S1))\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return exp(_a0_/(S2 + _a0_))/S1\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/(_a0_*relu(S1)))\n", - "/Users/jholla10/Developer/autora/autora/theorist/bms/mcmc.py:1197: RuntimeWarning: overflow encountered in exp\n", - " paccept = np.exp(-dEB / self.BT - dEP / self.PT)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(S2/_a0_))**_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(S2/_a0_))**_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(S2/_a0_))**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return (2*_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return (2*_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return (2*_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2*_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2*_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2*_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(_a0_**_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(_a0_**_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(_a0_**_a0_)**_a0_\n", - " 10%|█ | 154/1500 [00:09<01:43, 13.03it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S1**(-_a0_)*relu(S2)/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S1**(-_a0_)*relu(S2)/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S1**(-_a0_)*relu(S2)/relu(S1))\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return relu(sinh(S2**S2))**_a0_\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return relu(sinh(S2**S2))**_a0_\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return relu(sinh(S2**S2))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return _a0_/sqrt(tan(_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/(_a0_*(S2 + _a0_)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/(_a0_*(S2 + _a0_)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/(_a0_*(S2 + _a0_)))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(cos(S1))**_a0_\n", - " 10%|█ | 156/1500 [00:09<01:49, 12.27it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-1/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-1/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-1/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return S2*_a0_**((1/2)*S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return S2*_a0_**((1/2)*S1)\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return sinh(S2**S2)**_a0_\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return sinh(S2**S2)**_a0_\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return sinh(S2**S2)**_a0_\n", - " 11%|█ | 158/1500 [00:10<01:45, 12.67it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/(S2**2*relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/(S2**2*relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/(S2**2*relu(S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(S1 + _a0_)**_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(S1 + _a0_)**_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(S1 + _a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(tanh(_a0_))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(tanh(_a0_))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(tanh(_a0_))**_a0_\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(exp(exp(S1 + exp(S2/_a0_))))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return sinh(S1)**(S2**S2)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return sinh(S1)**(S2**S2)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return sinh(S1)**(S2**S2)\n", - " 11%|█ | 160/1500 [00:10<01:40, 13.33it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return S2*(S2/_a0_)**S1\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return S2*(S2/_a0_)**S1\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return S2*(S2/_a0_)**S1\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(_a0_)**_a0_\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return exp(_a0_/(S1 + _a0_))/S1\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sig(sqrt(_a0_))/S1\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sig(sqrt(_a0_))/S1\n", - " 11%|█ | 162/1500 [00:10<01:38, 13.56it/s]:2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(S2*_a0_))**_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(S2*_a0_))**_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(S2*_a0_))**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sin(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sin(_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sin(S1))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sin(S1))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(exp(cos(S1 + exp(1/sqrt(_a0_)))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(exp(cos(S1 + exp(1/sqrt(_a0_)))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(exp(cos(S1 + exp(1/sqrt(_a0_)))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-1/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-1/relu(S1))\n", - " 11%|█ | 164/1500 [00:10<01:35, 14.01it/s]:2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu(relu(_a0_**_a0_))**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu(relu(_a0_**_a0_))**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu(relu(_a0_**_a0_))**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-1/_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(tan(_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(tan(_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(tan(_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return _a0_/sqrt(sin(S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return _a0_/sqrt(sin(S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return _a0_/sqrt(sin(S1))\n", - " 11%|█ | 166/1500 [00:10<01:39, 13.38it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return (S1 + _a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S1 + _a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-(S1 + _a0_)/(_a0_*relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-(S1 + _a0_)/(_a0_*relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-(S1 + _a0_)/(_a0_*relu(S1)))\n", - " 11%|█ | 168/1500 [00:10<01:36, 13.78it/s]:2: RuntimeWarning: overflow encountered in power\n", - " return sinh(S1**2)**exp(S2)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return sinh(S1**2)**exp(S2)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return sinh(S1**2)**exp(S2)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(_a0_/S2))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(_a0_/S2))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(_a0_/S2))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return _a0_**(-S2)*(S1 + _a0_)/S1\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return _a0_**(-S2)*(S1 + _a0_)/S1\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return _a0_**(-S2)*(S1 + _a0_)/S1\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return tan(S1**2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return tan(S1**2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return (_a0_ + _a0_**_a0_)/S1**2\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return (_a0_ + _a0_**_a0_)/S1**2\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return (_a0_ + _a0_**_a0_)/S1**2\n", - " 11%|█▏ | 170/1500 [00:10<01:32, 14.42it/s]:2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(_a0_))**_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(_a0_))**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return exp(_a0_**S1)/S1\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return exp(_a0_**S1)/S1\n", - " 11%|█▏ | 172/1500 [00:11<01:27, 15.13it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/(_a0_*log(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/(_a0_*log(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sig(_a0_)/log(_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sig(_a0_)/log(_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sig(_a0_)/log(_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(-sinh(S1))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(-sinh(S1))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(-sinh(S1))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/(S2*_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (sqrt(sinh(_a0_*tan(S2)))/S1)**sig(S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (sqrt(sinh(_a0_*tan(S2)))/S1)**sig(S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (sqrt(sinh(_a0_*tan(S2)))/S1)**sig(S1)\n", - " 12%|█▏ | 174/1500 [00:11<01:27, 15.10it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return S2*(2*_a0_)**S1\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return S2*(2*_a0_)**S1\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return S2*(2*_a0_)**S1\n", - " 12%|█▏ | 176/1500 [00:11<01:27, 15.21it/s]:2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return exp(sinh(S1**2))**_a0_\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return exp(sinh(S1**2))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(sin(S2)))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(sin(S2)))**_a0_\n", - " 12%|█▏ | 178/1500 [00:11<01:27, 15.18it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)*exp(-S1)/_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(S2*_a0_))**_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(S2*_a0_))**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/(_a0_*relu(S1*S2)))\n", - " 12%|█▏ | 180/1500 [00:11<01:24, 15.69it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return relu(log(relu(S1))**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(log(relu(S1))**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2/_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2/_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(_a0_)/S1\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(_a0_)/S1\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log((S2 + _a0_)/S1)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(S1*_a0_))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(S1*_a0_))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/S2)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/S2)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/S2)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return (S1 + S2)*sig(2*_a0_)**(S1*_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(relu(relu(S1))**log(_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(relu(relu(S1))**log(_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(relu(relu(S1))**log(_a0_))\n", - " 12%|█▏ | 182/1500 [00:11<01:27, 14.99it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-log(S2)/(_a0_*relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-log(S2)/(_a0_*relu(S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(_a0_))**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return _a0_**((1/2)*_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return _a0_**((1/2)*_a0_)\n", - " 12%|█▏ | 184/1500 [00:11<01:30, 14.61it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/relu(relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/relu(relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/relu(relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu(_a0_**_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu(_a0_**_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu(_a0_**_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S1 + _a0_)**(S1**2)\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return log(-relu(S2)/(_a0_*relu(log(S1))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return log(-relu(S2)/(_a0_*relu(log(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu((_a0_/S2)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu((_a0_/S2)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu((_a0_/S2)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (S1 + sqrt(_a0_))/S1\n", - " 12%|█▏ | 186/1500 [00:11<01:35, 13.75it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", - " return log(-relu(S2)/(_a0_*relu(relu(_a0_))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return log(-relu(S2)/(_a0_*relu(relu(_a0_))))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(sinh(_a0_))**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(sinh(_a0_))**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(sinh(_a0_))**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (S2 + sqrt(_a0_) + _a0_)/S1\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return _a0_**(-S2)*(S1 + _a0_)/S1\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return _a0_**(-S2)*(S1 + _a0_)/S1\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/(_a0_**2*relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/(_a0_**2*relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/(_a0_**2*relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (tanh(sinh(_a0_*abs(S2)))/S1)**sig(S2**2)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return tan(sinh(S1))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return tan(sinh(S1))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(_a0_/log(S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(_a0_/log(S1))\n", - " 13%|█▎ | 188/1500 [00:12<01:34, 13.84it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return relu(S2*sin(_a0_)**S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(S2*sin(_a0_)**S1)\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(_a0_)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(_a0_)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(_a0_)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(sinh(S1))**(S1**S2)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(sinh(S1))**(S1**S2)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(sinh(S1))**(S1**S2)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S1**(-S2)*relu(S2)/relu(relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S1**(-S2)*relu(S2)/relu(relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S1**(-S2)*relu(S2)/relu(relu(S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(_a0_/S1)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(_a0_/S1)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(_a0_/S1)**_a0_))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return sinh(S1**2)**(S1**3)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return sinh(S1**2)**(S1**3)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return sinh(S1**2)**(S1**3)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(exp(cos(S1 + sqrt(S2*_a0_))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(exp(cos(S1 + sqrt(S2*_a0_))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (S1 + sqrt(_a0_))/S2\n", - " 13%|█▎ | 190/1500 [00:12<01:34, 13.90it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/(_a0_*relu(S2**_a0_)))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(sinh(_a0_))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(sinh(_a0_))**_a0_\n", - " 13%|█▎ | 192/1500 [00:12<01:32, 14.20it/s]:2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return S1**_a0_/fac(_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(cos(S2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(cos(S2))\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(exp(tan(S1 + exp(S2*_a0_))))\n", - " 13%|█▎ | 194/1500 [00:12<01:30, 14.50it/s]:2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(_a0_**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(_a0_**_a0_)\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return exp(cosh(S2)/S1)/S1\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return exp(cosh(S2)/S1)/S1\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return exp(cosh(S2)/S1)/S1\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return log(-relu(S2)/(_a0_*relu(_a0_)))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return log(-relu(S2)/(_a0_*relu(_a0_)))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return log(-relu(S2)/(_a0_*relu(_a0_)))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(S2*(S1*_a0_)**S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(S2*(S1*_a0_)**S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(S2*(S1*_a0_)**S1)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(_a0_**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(_a0_**_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sin(S1))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return _a0_**(-_a0_)*(S1 + sqrt(_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return _a0_**(-_a0_)*(S1 + sqrt(_a0_))\n", - " 13%|█▎ | 196/1500 [00:12<01:30, 14.39it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/(S2**2*relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/(S2**2*relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/(S2**2*relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(_a0_**S2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(_a0_**S2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(_a0_**S2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(S2*_a0_)/sqrt(S1*_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(sin(relu(S2)/(_a0_*relu(relu(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(sin(relu(S2)/(_a0_*relu(relu(S1)))))\n", - " 13%|█▎ | 198/1500 [00:12<01:31, 14.17it/s]:2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-relu(S2 + _a0_)/(_a0_*relu(relu(S1))))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-relu(S2 + _a0_)/(_a0_*relu(relu(S1))))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-relu(S2 + _a0_)/(_a0_*relu(relu(S1))))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(relu(_a0_))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(relu(_a0_))**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S1 + _a0_)**(S1**(3/2))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return tan(S1**2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(_a0_/log(S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return S1 + sqrt(_a0_)\n", - " 13%|█▎ | 200/1500 [00:12<01:31, 14.18it/s]:2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-relu(_a0_)/(_a0_*relu(relu(S1))))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-relu(_a0_)/(_a0_*relu(relu(S1))))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return S1**(S2**S2)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return S1**(S2**S2)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu((2*_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu((2*_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu((2*_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (S2 + sqrt(_a0_))/S1\n", - " 13%|█▎ | 202/1500 [00:13<01:30, 14.29it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-1/2*relu(S2)/(S2*relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-1/2*relu(S2)/(S2*relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-1/2*relu(S2)/(S2*relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(S2*_a0_**S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(S2*_a0_**S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(S2*_a0_**S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(sin(S1))**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(sin(S1))**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(sin(S1))**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(S2*_a0_)/sqrt(_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(S2*_a0_)/sqrt(S1*sin(S2))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(S2*_a0_)/sqrt(S1*sin(S2))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(S2*_a0_)/sqrt(S1*sin(S2))\n", - " 14%|█▎ | 204/1500 [00:13<01:26, 14.90it/s]:2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-relu(S1*_a0_)/(_a0_*relu(relu(S1))))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-relu(S1*_a0_)/(_a0_*relu(relu(S1))))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-relu(S1*_a0_)/(_a0_*relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(cos(_a0_)/S1)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(S1 + _a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(S1 + _a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(S1 + _a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(S2*_a0_)/sqrt(S1*_a0_/S2)\n", - " 14%|█▎ | 206/1500 [00:13<01:28, 14.63it/s]:2: RuntimeWarning: overflow encountered in power\n", - " return relu(S2)*sig(S1 + _a0_)**(S1*_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(_a0_/S2)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(_a0_/S2)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(_a0_/S2)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return log(-relu(S2)/(_a0_*relu(relu(S1 + _a0_))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return log(-relu(S2)/(_a0_*relu(relu(S1 + _a0_))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return log(-relu(S2)/(_a0_*relu(relu(S1 + _a0_))))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(relu(_a0_))**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(_a0_)/S1**(3/2)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(_a0_)/S1**(3/2)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(_a0_)/S1**(3/2)\n", - " 14%|█▍ | 208/1500 [00:13<01:28, 14.62it/s]:2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-relu(S2 + _a0_)/(_a0_*relu(relu(S1))))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-relu(S2 + _a0_)/(_a0_*relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/(S1*relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/(S1*relu(relu(S1))))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(tan(S1))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(tan(S1))**_a0_))\n", - " 14%|█▍ | 210/1500 [00:13<01:26, 14.87it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return log(-(relu(S2)/_a0_)**relu(relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return log(-(relu(S2)/_a0_)**relu(relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(exp(cos(_a0_**_a0_ + exp(S2*_a0_))))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(exp(cos(_a0_**_a0_ + exp(S2*_a0_))))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(exp(cos(_a0_**_a0_ + exp(S2*_a0_))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(sin(relu(S2)/(_a0_*relu(relu(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return log(sinh(S1))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return log(sinh(S1))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu((_a0_**S2)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu((_a0_**S2)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu((_a0_**S2)**_a0_)\n", - " 14%|█▍ | 212/1500 [00:13<01:26, 14.91it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/(S1*relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(S2*(cos(_a0_)**3)**S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(S2*(cos(_a0_)**3)**S1)\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return sinh(exp(2*S2))**_a0_\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return sinh(exp(2*S2))**_a0_\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return sinh(exp(2*S2))**_a0_\n", - " 14%|█▍ | 214/1500 [00:13<01:24, 15.17it/s]:2: RuntimeWarning: overflow encountered in power\n", - " return relu(S2)*sig(S1*_a0_)**(S1*_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return _a0_**2/sqrt(-_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return _a0_**2/sqrt(-_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return _a0_**2/sqrt(-_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(cos(S1))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(cos(S1))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(tan(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(tan(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(tan(S1))\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return exp(S2/(S1*_a0_))/S1\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return exp(S2/(S1*_a0_))/S1\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return exp(S2/(S1*_a0_))/S1\n", - " 14%|█▍ | 216/1500 [00:14<01:28, 14.46it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return relu(S2*sinh(cos(2*_a0_))**S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(S2*sinh(cos(2*_a0_))**S1)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/((S1 + _a0_)*relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/((S1 + _a0_)*relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/((S1 + _a0_)*relu(relu(S1))))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return sinh(S1**2)**(S1**S2)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return sinh(S1**2)**(S1**S2)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return sinh(S1**2)**(S1**S2)\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(_a0_)**_a0_\n", - " 15%|█▍ | 218/1500 [00:14<01:32, 13.88it/s]:2: RuntimeWarning: invalid value encountered in scalar power\n", - " return _a0_**((1/2)*_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return _a0_**((1/2)*_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(S1 + _a0_)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(S1 + _a0_)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(S1 + _a0_)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(S2*sig(sqrt(_a0_))**S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(S2*sig(sqrt(_a0_))**S1)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(relu(_a0_**S2)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(_a0_**S2)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(relu(_a0_**S2)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(_a0_**S2)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(relu(_a0_**S2)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(_a0_**S2)**_a0_))\n", - " 15%|█▍ | 220/1500 [00:14<02:08, 9.97it/s]:2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(log(S1))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(exp(cos(S1 + exp(_a0_**(3/2)))))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(exp(cos(S1 + exp(_a0_**(3/2)))))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(exp(cos(S1 + exp(_a0_**(3/2)))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return exp(sqrt(_a0_)/S1)/S1\n", - " 15%|█▍ | 222/1500 [00:14<01:54, 11.13it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(tan(S1)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(tan(S1)/S1)\n", - " 15%|█▍ | 224/1500 [00:14<01:50, 11.55it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", - " return log(-relu(S2)/(_a0_*relu(relu(_a0_))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(tan(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(tan(S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(exp(cos(S1 + exp(S2*_a0_**S1))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(exp(cos(S1 + exp(S2*_a0_**S1))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(exp(cos(S1 + exp(S2*_a0_**S1))))\n", - " 15%|█▌ | 226/1500 [00:14<01:43, 12.34it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return log(-relu(S2)/(_a0_*relu(relu(_a0_**S1))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return log(-relu(S2)/(_a0_*relu(relu(_a0_**S1))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return log(-relu(S2)/(_a0_*relu(relu(_a0_**S1))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return log(-relu(S2)/(_a0_*relu(relu(_a0_**S1))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return log(-relu(S2)/(_a0_*relu(relu(_a0_**S1))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return log(-relu(S2)/(_a0_*relu(relu(_a0_**S1))))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(relu(log(S1)))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(relu(log(S1)))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(relu(log(S1)))**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(cos(S2)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(cos(S2)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(cos(S2)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(S2/_a0_)/sqrt(tan(S2))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(S2/_a0_)/sqrt(tan(S2))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(S2/_a0_)/sqrt(tan(S2))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(_a0_**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(_a0_**_a0_)\n", - " 15%|█▌ | 228/1500 [00:15<01:37, 13.01it/s]:2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(_a0_)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(_a0_)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(_a0_/S2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(_a0_/S2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(_a0_/S2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(tan(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(tan(S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (S1 + _a0_)/(S1*sqrt(sin(_a0_)))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (S1 + _a0_)/(S1*sqrt(sin(_a0_)))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (S1 + _a0_)/(S1*sqrt(sin(_a0_)))\n", - " 15%|█▌ | 230/1500 [00:15<01:30, 14.06it/s]:2: RuntimeWarning: invalid value encountered in scalar power\n", - " return tanh(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return tanh(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return tanh(_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(tan(S1))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(tan(S1))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(_a0_)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(_a0_)**_a0_))\n", - " 15%|█▌ | 232/1500 [00:15<01:25, 14.76it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", - " return log(-relu(S2)/(sqrt(_a0_)*relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return log(-relu(S2)/(sqrt(_a0_)*relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return log(-relu(S2)/(sqrt(_a0_)*relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(_a0_)/S1**(3/2)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(_a0_)/S1**(3/2)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return log(-relu(S2)/(_a0_*relu(_a0_**S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return log(-relu(S2)/(_a0_*relu(_a0_**S1)))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return log(-relu(S2)/(_a0_*relu(_a0_**S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return log(-relu(S2)/(_a0_*relu(_a0_**S1)))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return log(-relu(S2)/(_a0_*relu(_a0_**S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return log(-relu(S2)/(_a0_*relu(_a0_**S1)))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(S2*_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(S2*_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(S2*_a0_)**_a0_)\n", - " 16%|█▌ | 234/1500 [00:15<01:22, 15.28it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return (log(sinh(_a0_*abs(S2)))/S1)**sig(S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (log(sinh(_a0_*abs(S2)))/S1)**sig(S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-_a0_/S1)/S1\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-_a0_/S1)/S1\n", - " 16%|█▌ | 236/1500 [00:15<01:21, 15.52it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-2/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-2/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-2/relu(S1))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(_a0_)**_a0_\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return S1**(S1**S2)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return S1**(S1**S2)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return S1**(S1**S2)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(cos(S1))**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(cos(S1))**_a0_)\n", - " 16%|█▌ | 238/1500 [00:15<01:19, 15.85it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/(relu(S1)*cosh(S2)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/(relu(S1)*cosh(S2)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/(relu(S1)*cosh(S2)))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(sqrt(cos(S1 + exp(S2*_a0_))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(sqrt(cos(S1 + exp(S2*_a0_))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/(_a0_*(S1 + _a0_)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/(_a0_*(S1 + _a0_)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/(_a0_*(S1 + _a0_)))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(relu(S2 + _a0_))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(relu(S2 + _a0_))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(relu(S2 + _a0_))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(sinh(_a0_))**_a0_\n", - " 16%|█▌ | 240/1500 [00:15<01:20, 15.63it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-1/(_a0_*relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return cos(S1**2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return cos(S1**2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(sinh(sqrt(_a0_)))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(sinh(sqrt(_a0_)))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(sinh(sqrt(_a0_)))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(_a0_**S2)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(_a0_**S2)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(_a0_**S2)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S2)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S2)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return cos(sinh(S1))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return cos(sinh(S1))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(_a0_**(2*S1))**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(_a0_**(2*S1))**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(_a0_**(2*S1))**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (S1 + _a0_)/(S1*sqrt(_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (S1 + _a0_)/(S1*sqrt(_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(S2/log(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(S2/log(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(S2/log(S1))\n", - " 16%|█▌ | 242/1500 [00:15<01:17, 16.17it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-1/2*relu(S2)/(S2*_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(S2)*sig(_a0_/S1)**(S1*log(_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return cos(S2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return cos(S2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return cos(S2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (S1 + _a0_)/(S1*sqrt(-S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (S1 + _a0_)/(S1*sqrt(-S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (S1 + _a0_)/(S1*sqrt(-S1))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(_a0_)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(_a0_)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(_a0_)**_a0_)\n", - " 16%|█▋ | 244/1500 [00:16<01:23, 15.12it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", - " return log(-relu(S2)/(_a0_*relu(sin(_a0_))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return log(-relu(S2)/(_a0_*relu(sin(_a0_))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return log(-relu(S2)/(_a0_*relu(sin(_a0_))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(_a0_**(-1.0))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(-S1)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(-S1)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(tan(S1**2)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(tan(S1**2)**_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-relu(log(S1))/(_a0_*relu(S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-relu(log(S1))/(_a0_*relu(S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-relu(log(S1))/(_a0_*relu(S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(_a0_)**_a0_\n", - " 16%|█▋ | 246/1500 [00:16<01:23, 15.06it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return relu(S2*_a0_**S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(S2*_a0_**S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(sin(S2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(sin(S2))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(S1*_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(S1*_a0_)**_a0_\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return relu(sinh(fac(S1)**2)**_a0_)\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return relu(sinh(fac(S1)**2)**_a0_)\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return relu(sinh(fac(S1)**2)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-cos(S2)/(_a0_*relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-cos(S2)/(_a0_*relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(S2*(_a0_/S1)**S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(S2*(_a0_/S1)**S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(S2*(_a0_/S1)**S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(S1 + _a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(S1 + _a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(S1 + _a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(_a0_)**_a0_\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return relu(sinh(S1**S2)**_a0_)\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return relu(sinh(S1**S2)**_a0_)\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return relu(sinh(S1**S2)**_a0_)\n", - " 17%|█▋ | 248/1500 [00:16<01:20, 15.55it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)*exp(-S1)/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)*exp(-S1)/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)*exp(-S1)/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(tan(S2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(tan(S2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(tan(S2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S1**(-_a0_)*relu(S2)/_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(S2*(S1 + _a0_)**S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(S2*(S1 + _a0_)**S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(S2*(S1 + _a0_)**S1)\n", - " 17%|█▋ | 250/1500 [00:16<01:17, 16.16it/s]:2: RuntimeWarning: overflow encountered in power\n", - " return relu(S2)*sig(S2 + _a0_)**(S1*_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(S2*_a0_**S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(S2*_a0_**S1)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(S2/_a0_)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(S2/_a0_)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(S2/_a0_)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return -sqrt(_a0_/S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(S2*_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(S2*_a0_)**_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return cos(S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return cos(S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return cos(S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(tan(S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(tan(S1))\n", - " 17%|█▋ | 252/1500 [00:16<01:14, 16.74it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(log(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(log(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(log(S1))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(relu(_a0_))**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(_a0_**_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(_a0_**_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(_a0_**_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-log(S2)/(_a0_*relu(S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(_a0_)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(_a0_)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(S2*_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(S2*_a0_)**_a0_)\n", - " 17%|█▋ | 254/1500 [00:16<01:13, 16.90it/s]:2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-relu(_a0_)/(_a0_*relu(S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-relu(_a0_)/(_a0_*relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(S1 + _a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(S1 + _a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(S2*(_a0_**S1)**S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(S2*(_a0_**S1)**S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(S2*(_a0_**S1)**S1)\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(relu(_a0_))**_a0_))\n", - " 17%|█▋ | 256/1500 [00:16<01:11, 17.46it/s]:2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(relu(S1 + _a0_))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(relu(S1 + _a0_))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(relu(S1 + _a0_))**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/S2)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/S2)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2/_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2/_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(S1 + _a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(S1 + _a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(S1 + _a0_)**_a0_)\n", - " 17%|█▋ | 260/1500 [00:17<01:13, 16.92it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return relu(S2*_a0_**S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(S2*_a0_**S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(_a0_/sin(S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(_a0_/sin(S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(_a0_/sin(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/(relu(S1)*cos(_a0_)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/(relu(S1)*cos(_a0_)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/(relu(S1)*cos(_a0_)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(log(S2)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(log(S2)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(log(S2)/S1)\n", - " 17%|█▋ | 262/1500 [00:17<01:12, 17.03it/s]:2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(_a0_/S1)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(_a0_/S1)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(_a0_/S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(sin(S1))**_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(-S1)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(-S1)**_a0_\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return relu(sinh(S1**(2*S2))**_a0_)\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return relu(sinh(S1**(2*S2))**_a0_)\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return relu(sinh(S1**(2*S2))**_a0_)\n", - " 18%|█▊ | 264/1500 [00:17<01:12, 16.98it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return log(-_a0_**(-S2)*relu(S2)/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return log(-_a0_**(-S2)*relu(S2)/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return log(-_a0_**(-S2)*relu(S2)/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(_a0_**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(sin(relu(S1))**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(sin(relu(S1))**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_/S2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_/S2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_/S2)**_a0_\n", - " 18%|█▊ | 266/1500 [00:17<01:15, 16.41it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(sin(relu(S2)/(_a0_*relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(sin(relu(S2)/(_a0_*relu(S1))))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(relu(-S2))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(relu(-S2))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(relu(-S2))**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2 + _a0_)**exp(S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/(_a0_*(S1 + _a0_)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/(_a0_*(S1 + _a0_)))\n", - " 18%|█▊ | 268/1500 [00:17<01:17, 15.94it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return tan(sinh(S1))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/(S2*relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/(S2*relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(S2*sig(_a0_**S1)**S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(S2*sig(_a0_**S1)**S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(S2*sig(_a0_**S1)**S1)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(-sinh(S1))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(-sinh(S1))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2/_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2/_a0_)**_a0_\n", - " 18%|█▊ | 270/1500 [00:17<01:18, 15.57it/s]:2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(S2*_a0_))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(S2*_a0_))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(S2*_a0_))**_a0_\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return sinh(S1)**(S1**S1)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return sinh(S1)**(S1**S1)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return sinh(S1)**(S1**S1)\n", - " 18%|█▊ | 272/1500 [00:17<01:16, 16.10it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S1**_a0_/(_a0_*relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(S1/_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(S1/_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(S1/_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(cos(S1))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sin(S2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sin(S2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sin(S2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/(S2**2*relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/(S2**2*relu(S1)))\n", - " 18%|█▊ | 274/1500 [00:17<01:17, 15.88it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(S2/_a0_)/sqrt(-_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(S2/_a0_)/sqrt(-_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(S2/_a0_)/sqrt(-_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(relu(cos(S2)))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(relu(cos(S2)))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(relu(cos(S2)))**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-S2)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-S2)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-S2)\n", - " 18%|█▊ | 276/1500 [00:18<01:16, 16.03it/s]:2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-relu(_a0_/S1)/(_a0_*relu(S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-relu(_a0_/S1)/(_a0_*relu(S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-relu(_a0_/S1)/(_a0_*relu(S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(_a0_)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(_a0_)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(tan(S2))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(tan(S2))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(tan(S2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S1*relu(S2)/(S2*relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S1*relu(S2)/(S2*relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S1*relu(S2)/(S2*relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_**_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_**_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_**_a0_)**_a0_\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return relu(sinh(S2**S2))**_a0_\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return relu(sinh(S2**S2))**_a0_\n", - " 19%|█▊ | 278/1500 [00:18<01:14, 16.35it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/(S1*relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/(S1*relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(S2/_a0_)/sqrt(sin(S2))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(S2/_a0_)/sqrt(sin(S2))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(S2/_a0_)/sqrt(sin(S2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/(relu(S1)*sinh(S2)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/(relu(S1)*sinh(S2)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/(relu(S1)*sinh(S2)))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(relu(relu(relu(S1))**(S2**S2)))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(relu(relu(relu(S1))**(S2**S2)))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(relu(relu(relu(S1))**(S2**S2)))\n", - " 19%|█▊ | 280/1500 [00:18<01:13, 16.57it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(cos(S2))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(cos(S2))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(cos(S2))**_a0_\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return S1**(S2**S1)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return S1**(S2**S1)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return S1**(S2**S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(S2 + _a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(S2 + _a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(S2 + _a0_)**_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(relu(sin(S1)))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(relu(sin(S1)))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(relu(sin(S1)))**_a0_))\n", - " 19%|█▉ | 282/1500 [00:18<01:12, 16.81it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-1/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-1/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(tan(S1)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(tan(S1)/S1)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(cos(S1))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(2*_a0_)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(2*_a0_)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(2*_a0_)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-relu(tan(_a0_))/(_a0_*relu(S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-relu(tan(_a0_))/(_a0_*relu(S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-relu(tan(_a0_))/(_a0_*relu(S1)))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(S2)*sig(2*_a0_)**(S1*_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return S2**_a0_/log(_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(cos(S2)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(cos(S2)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(cos(S2)**_a0_)\n", - " 19%|█▉ | 284/1500 [00:18<01:14, 16.43it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-1/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-1/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(sin(S2))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(sin(S2))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(sin(S2))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu((_a0_**S2)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu((_a0_**S2)**_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-relu(_a0_)/(_a0_*relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(S1**(_a0_**S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(S1**(_a0_**S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(S1**(_a0_**S1))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(sinh(S1**2)**(S2**S2))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(sinh(S1**2)**(S2**S2))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(sinh(S1**2)**(S2**S2))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(log(_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(log(_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(log(_a0_))\n", - " 19%|█▉ | 286/1500 [00:18<01:12, 16.81it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S1/(_a0_*relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(S1*_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(S1*_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(S1*_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(cos(S1 + exp(S2*_a0_))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(cos(S1 + exp(S2*_a0_))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(log(S1))**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(log(S1))**_a0_)\n", - " 19%|█▉ | 288/1500 [00:18<01:12, 16.65it/s]:2: RuntimeWarning: divide by zero encountered in log\n", - " return log(fac(relu(S2)/(_a0_*relu(S1))))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(fac(relu(S2)/(_a0_*relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (S1 + _a0_)/(S1*sqrt(_a0_**3))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (S1 + _a0_)/(S1*sqrt(_a0_**3))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (S1 + _a0_)/(S1*sqrt(_a0_**3))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return tanh(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return tanh(_a0_)**_a0_\n", - " 19%|█▉ | 290/1500 [00:18<01:13, 16.36it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return relu(S2*(_a0_/S1)**S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(S2*(_a0_/S1)**S1)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(sinh(S1))**(S2**S2)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(sinh(S1))**(S2**S2)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(sinh(S1))**(S2**S2)\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return relu(sinh(S1**S1)**_a0_)\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return relu(sinh(S1**S1)**_a0_)\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return relu(sinh(S1**S1)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(log(S2)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(log(S2)/S1)\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(sinh(_a0_))**_a0_\n", - " 19%|█▉ | 292/1500 [00:18<01:11, 16.96it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-tan(S2)/(_a0_*relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-tan(S2)/(_a0_*relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu(_a0_**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu(_a0_**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu(_a0_**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/(relu(S1)*tanh(S2)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/(relu(S1)*tanh(S2)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/(relu(S1)*tanh(S2)))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - " 20%|█▉ | 294/1500 [00:19<01:11, 16.78it/s]:2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(sinh(_a0_))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return fac(_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return fac(_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(sinh(_a0_))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(cos(S1))**_a0_)\n", - " 20%|█▉ | 296/1500 [00:19<01:26, 13.94it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return log(-(relu(S2)/_a0_)**S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return log(-(relu(S2)/_a0_)**S1)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return cos(S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*(S1*_a0_)**S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*(S1*_a0_)**S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*(S1*_a0_)**S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-S2)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-S2)\n", - " 20%|█▉ | 298/1500 [00:19<01:19, 15.12it/s]:2: RuntimeWarning: divide by zero encountered in log\n", - " return log(fac(relu(S2)/(S1*_a0_)))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(fac(relu(S2)/(S1*_a0_)))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(sinh(relu(_a0_)))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(sinh(relu(_a0_)))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(sinh(relu(_a0_)))**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu((S2 + _a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu((S2 + _a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu((S2 + _a0_)**_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(S1*_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(S1*_a0_)**_a0_)\n", - " 20%|██ | 300/1500 [00:19<01:15, 15.97it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return relu(S2)*log(sig(S1))**(S1*_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(S2)*log(sig(S1))**(S1*_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(_a0_)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(_a0_)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(tan(S2)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(tan(S2)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(tan(S2)/S1)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(tan(S1))**_a0_))\n", - " 20%|██ | 302/1500 [00:19<01:14, 15.98it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-(_a0_ + relu(S2))/S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-(_a0_ + relu(S2))/S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/(S1*S2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/(S1*S2))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sin(S1)**_a0_\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(S2)*sig(S2*_a0_)**(S1*_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(tan(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(tan(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(tan(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(tan(S1))\n", - " 20%|██ | 304/1500 [00:19<01:13, 16.20it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2**_a0_)/(S1*_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*(_a0_**3)**S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*(_a0_**3)**S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return exp(-sig(_a0_)/log(_a0_))/S1\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return exp(-sig(_a0_)/log(_a0_))/S1\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return exp(-sig(_a0_)/log(_a0_))/S1\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(S2 + _a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(S2 + _a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(cos(S2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(cos(S2))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return _a0_/sqrt(tan(S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return _a0_/sqrt(tan(S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return _a0_/sqrt(tan(S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(exp(cos(S1 + exp(_a0_*_a0_**S2))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(exp(cos(S1 + exp(_a0_*_a0_**S2))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(exp(cos(S1 + exp(_a0_*_a0_**S2))))\n", - " 20%|██ | 306/1500 [00:19<01:15, 15.75it/s]:2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(_a0_/S1)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(_a0_/S1)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(_a0_/sin(S2))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(_a0_/sin(S2))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(_a0_/sin(S2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S1)/(S1*_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(tan(_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(tan(_a0_))\n", - " 21%|██ | 308/1500 [00:20<01:12, 16.36it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(tan(relu(S2)/(S1*_a0_)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(tan(relu(S2)/(S1*_a0_)))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2/_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2/_a0_)**_a0_\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return S2**(S1**S1)/(S1 + _a0_)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return S2**(S1**S1)/(S1 + _a0_)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return S2**(S1**S1)/(S1 + _a0_)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (S2 + sig(_a0_))*exp(-sqrt(_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (S2 + sig(_a0_))*exp(-sqrt(_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (S2 + sig(_a0_))*exp(-sqrt(_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/(S1*S2))\n", - " 21%|██ | 310/1500 [00:20<01:12, 16.40it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)**_a0_/S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)**_a0_/S1)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return log(sqrt(relu(S2)/(S1*_a0_)))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return log(sqrt(relu(S2)/(S1*_a0_)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(log(S1)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(log(S1)/S1)\n", - " 21%|██ | 312/1500 [00:20<01:12, 16.36it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return log(-_a0_**(-S2)*relu(S2)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return log(-_a0_**(-S2)*relu(S2)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return log(-_a0_**(-S2)*relu(S2)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(S1*_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(S1*_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(S1*_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(S2/(S1 + _a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(sinh(_a0_**3))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(sinh(_a0_**3))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(sinh(_a0_**3))**_a0_\n", - " 21%|██ | 314/1500 [00:20<01:12, 16.35it/s]:2: RuntimeWarning: invalid value encountered in scalar power\n", - " return (_a0_**3)**_a0_/(S1 + _a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*_a0_**S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*_a0_**S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*_a0_**S1))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return log(-_a0_**_a0_/(S1*_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return log(-_a0_**_a0_/(S1*_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return log(-_a0_**_a0_/(S1*_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(cos(_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu((_a0_/S2)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu((_a0_/S2)**_a0_)\n", - " 21%|██ | 316/1500 [00:20<01:11, 16.59it/s]:2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(_a0_**_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(_a0_**_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(_a0_**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(_a0_**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(_a0_**_a0_)\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(exp(cos(S1 + exp(S1**S2*S2))))\n", - ":2: RuntimeWarning: invalid value encountered in cos\n", - " return relu(exp(cos(S1 + exp(S1**S2*S2))))\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(exp(cos(S1 + exp(S1**S2*S2))))\n", - ":2: RuntimeWarning: invalid value encountered in cos\n", - " return relu(exp(cos(S1 + exp(S1**S2*S2))))\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(exp(cos(S1 + exp(S1**S2*S2))))\n", - ":2: RuntimeWarning: invalid value encountered in cos\n", - " return relu(exp(cos(S1 + exp(S1**S2*S2))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(tan(_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(tan(_a0_))\n", - " 21%|██ | 318/1500 [00:20<01:11, 16.58it/s]:2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(sinh(_a0_))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-tanh(S2)/(S1*_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(_a0_**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(_a0_**_a0_)\n", - " 21%|██▏ | 320/1500 [00:20<01:10, 16.71it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/(S1*tan(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/(S1*tan(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/(S1*tan(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(sin(sinh(S1))**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(sin(sinh(S1))**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/(S1*S2**2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/(S1*S2**2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/(S1*S2**2))\n", - " 21%|██▏ | 322/1500 [00:20<01:11, 16.46it/s]:2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(S1))**(_a0_**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(S1))**(_a0_**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(S1))**(_a0_**_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(-sinh(S1))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(-sinh(S1))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(-sinh(S1))**_a0_))\n", - " 22%|██▏ | 324/1500 [00:20<01:09, 16.87it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*(S2*_a0_)**S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*(S2*_a0_)**S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*(S2*_a0_)**S1))\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return relu(relu(relu(sinh(S2**S2))**_a0_))\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return relu(relu(relu(sinh(S2**S2))**_a0_))\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return relu(relu(relu(sinh(S2**S2))**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2/_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2/_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-1/S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-1/S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-1/S1)\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(_a0_)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(_a0_)**_a0_))\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return exp(-sig(_a0_)/(S2 + _a0_))/S1\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_**S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_**S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_**S1)**_a0_\n", - " 22%|██▏ | 326/1500 [00:21<01:13, 16.02it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", - " return exp(-sqrt(_a0_)/S1)/S1\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return exp(-sqrt(_a0_)/S1)/S1\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/(S1*log(S2)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/(S1*log(S2)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/(S1*log(S2)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(tan(S2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(tan(S2))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return S2**(S2**S2)/(S1 + _a0_)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return S2**(S2**S2)/(S1 + _a0_)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return S2**(S2**S2)/(S1 + _a0_)\n", - " 22%|██▏ | 328/1500 [00:21<01:10, 16.52it/s]:2: RuntimeWarning: invalid value encountered in scalar power\n", - " return (_a0_**_a0_ + sig(_a0_))*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return (_a0_**_a0_ + sig(_a0_))*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return (_a0_**_a0_ + sig(_a0_))*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(_a0_**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(_a0_**_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(log(_a0_)/S1)\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(log(_a0_)/S1)\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(log(_a0_)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return log(-_a0_**(-S1)*relu(S2)/_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-_a0_**(-S1)*relu(S2)/_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return log(-_a0_**(-S1)*relu(S2)/_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-_a0_**(-S1)*relu(S2)/_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return log(-_a0_**(-S1)*relu(S2)/_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-_a0_**(-S1)*relu(S2)/_a0_)\n", - " 22%|██▏ | 330/1500 [00:21<01:11, 16.48it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*(S2*_a0_)**S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*(S2*_a0_)**S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(cos(sinh(S1))**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(cos(sinh(S1))**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu((S2*_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu((S2*_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu((S2*_a0_)**_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(S1*_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(S1*_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(cos(S2))**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(cos(S2))**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(cos(S2))**_a0_)\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(exp(cos(S1 + exp(S2*exp(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in cos\n", - " return relu(exp(cos(S1 + exp(S2*exp(S1)))))\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(exp(cos(S1 + exp(S2*exp(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in cos\n", - " return relu(exp(cos(S1 + exp(S2*exp(S1)))))\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(exp(cos(S1 + exp(S2*exp(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in cos\n", - " return relu(exp(cos(S1 + exp(S2*exp(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(tan(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(tan(S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return _a0_**S1/S1**(3/2)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return _a0_**S1/S1**(3/2)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*(S1 + _a0_)**S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*(S1 + _a0_)**S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*(S1 + _a0_)**S1))\n", - " 22%|██▏ | 332/1500 [00:21<01:09, 16.71it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*(S2*_a0_)**S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*(S2*_a0_)**S1))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(S2 + _a0_)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(S2 + _a0_)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(S2 + _a0_)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(log(S1)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(log(S1)**_a0_)\n", - " 22%|██▏ | 334/1500 [00:21<01:10, 16.49it/s]:2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(sqrt(cos(S1 + exp(S2*_a0_))))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-relu(_a0_)/(S1*_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-relu(_a0_)/(S1*_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(sin(S2))/sqrt(S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(sin(S2))/sqrt(S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(sin(S2))/sqrt(S1)\n", - " 22%|██▏ | 336/1500 [00:21<01:10, 16.62it/s]:2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(sinh(_a0_/S1))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(sinh(_a0_/S1))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(sinh(_a0_/S1))**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(cos(S2)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(cos(S2)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(tanh(_a0_))**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(tanh(_a0_))**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(tanh(_a0_))**_a0_)\n", - " 23%|██▎ | 338/1500 [00:21<01:10, 16.51it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/(S1*(S1 + S2)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/(S1*(S1 + S2)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/(S1*(S1 + S2)))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sin(_a0_)**abs(_a0_)/(S1 + _a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(sin(_a0_))**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(sin(_a0_))**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(sin(_a0_))**_a0_)\n", - " 23%|██▎ | 340/1500 [00:21<01:12, 16.08it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(cos(S2)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(cos(S2)/S1)\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-relu(S1 + _a0_)/(S1*_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-relu(S1 + _a0_)/(S1*_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-relu(S1 + _a0_)/(S1*_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (relu(relu(S2*_a0_))/tan(S1))**sig(relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (relu(relu(S2*_a0_))/tan(S1))**sig(relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (relu(relu(S2*_a0_))/tan(S1))**sig(relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*_a0_**S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*_a0_**S1))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(_a0_**_a0_)\n", - " 23%|██▎ | 342/1500 [00:22<01:11, 16.17it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/S1**2)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/S1**2)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sin(S1)**_a0_\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(S2)*sig(sig(S1))**(_a0_*exp(S2))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(_a0_)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(_a0_)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(S2 + _a0_)/sqrt(S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(S2*_a0_/S1)/sqrt(S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(cos(S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(cos(S1))\n", - " 23%|██▎ | 344/1500 [00:22<01:28, 13.07it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(S2 + _a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(S2 + _a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(S2 + _a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(_a0_)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(_a0_)**_a0_))\n", - " 23%|██▎ | 346/1500 [00:22<01:22, 14.00it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return tan(S2)**abs(_a0_)/(S1 + _a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return tan(S2)**abs(_a0_)/(S1 + _a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return tan(S2)**abs(_a0_)/(S1 + _a0_)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(S2/_a0_)/sqrt(S2*cos(S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(S2/_a0_)/sqrt(S2*cos(S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(S2/_a0_)/sqrt(S2*cos(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-sig(_a0_)/S1)/S1\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-sig(_a0_)/S1)/S1\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(cos(S2))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(cos(S2))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return log(sinh(S1))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return (_a0_ + _a0_**_a0_)/S1**(3/2)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return (_a0_ + _a0_**_a0_)/S1**(3/2)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return (_a0_ + _a0_**_a0_)/S1**(3/2)\n", - " 23%|██▎ | 348/1500 [00:22<01:19, 14.51it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return relu(relu(S2*sig(log(_a0_))**S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(relu(S2*sig(log(_a0_))**S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(relu(S2*sig(log(_a0_))**S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(_a0_/S1)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(_a0_/S1)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(_a0_/S1)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sin(S1)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sin(S1)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return S1**(_a0_**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return S1**(_a0_**_a0_)\n", - " 23%|██▎ | 350/1500 [00:22<01:14, 15.51it/s]:2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(sinh(cos(S2)))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(sinh(cos(S2)))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(sinh(cos(S2)))**_a0_))\n", - " 23%|██▎ | 352/1500 [00:22<01:11, 15.99it/s]:2: RuntimeWarning: overflow encountered in sinh\n", - " return relu(sinh(S1**S1)**_a0_)\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return relu(sinh(S1**S1)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(log(S2)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(log(S2)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return log(-(relu(S2)/_a0_)**S1)\n", - " 24%|██▎ | 354/1500 [00:22<01:08, 16.79it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(S2/_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(S2/_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(S2/_a0_)**_a0_\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(exp(cos(S1 + exp(S2*S2**S2))))\n", - ":2: RuntimeWarning: invalid value encountered in cos\n", - " return relu(exp(cos(S1 + exp(S2*S2**S2))))\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(exp(cos(S1 + exp(S2*S2**S2))))\n", - ":2: RuntimeWarning: invalid value encountered in cos\n", - " return relu(exp(cos(S1 + exp(S2*S2**S2))))\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(exp(cos(S1 + exp(S2*S2**S2))))\n", - ":2: RuntimeWarning: invalid value encountered in cos\n", - " return relu(exp(cos(S1 + exp(S2*S2**S2))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return log(-(relu(S2)/_a0_)**S1)\n", - " 24%|██▎ | 356/1500 [00:22<01:08, 16.81it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(sinh(relu(S2)/(S1*_a0_)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(sinh(relu(S2)/(S1*_a0_)))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu(relu(sinh(S1))**(_a0_**_a0_)))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu(relu(sinh(S1))**(_a0_**_a0_)))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu(relu(sinh(S1))**(_a0_**_a0_)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(exp(cos(exp(S2*_a0_) + log(_a0_))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(exp(cos(exp(S2*_a0_) + log(_a0_))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(exp(cos(exp(S2*_a0_) + log(_a0_))))\n", - " 24%|██▍ | 358/1500 [00:23<01:10, 16.27it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return log(-relu(S2)/(S1*_a0_))**S1\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return S2**(S2**S1)/(S1 + _a0_)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return S2**(S2**S1)/(S1 + _a0_)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return S2**(S2**S1)/(S1 + _a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(2*_a0_)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(2*_a0_)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-(S2 + _a0_)/(S1*_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-(S2 + _a0_)/(S1*_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-(S2 + _a0_)/(S1*_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(sin(S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(sin(S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(sin(S1))\n", - " 24%|██▍ | 360/1500 [00:23<01:10, 16.16it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S2*relu(S2)/_a0_**2)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S2*relu(S2)/_a0_**2)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S2*relu(S2)/_a0_**2)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return (2*_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return (2*_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(sin(S2)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(sin(S2)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(sin(S2)/S1)\n", - " 24%|██▍ | 362/1500 [00:23<01:09, 16.27it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_**S1 + sin(S2**_a0_))*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(exp(cos(S1 + sqrt(S2*_a0_))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(log(S2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(log(S2))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return log(-(relu(S2)/_a0_)**S1)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return S2**abs(S2**S1)/(S1 + _a0_)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return S2**abs(S2**S1)/(S1 + _a0_)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return S2**abs(S2**S1)/(S1 + _a0_)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(S2/_a0_)/sqrt(cos(S2))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(S2/_a0_)/sqrt(cos(S2))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(S2/_a0_)/sqrt(cos(S2))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(S2*_a0_)/sin(S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(log(_a0_)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(log(_a0_)/S1)\n", - " 24%|██▍ | 364/1500 [00:23<01:07, 16.73it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(tanh(S2))/(S1*_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu(S2*(_a0_**_a0_)**S1))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu(S2*(_a0_**_a0_)**S1))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu(S2*(_a0_**_a0_)**S1))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(sinh(relu(_a0_)))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(sinh(relu(_a0_)))**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu((S2/_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu((S2/_a0_)**_a0_)\n", - " 24%|██▍ | 366/1500 [00:23<01:08, 16.50it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sin(S1)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/(S1*S2*_a0_))\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(exp(cos(S1 + exp(S1**S1*S2))))\n", - ":2: RuntimeWarning: invalid value encountered in cos\n", - " return relu(exp(cos(S1 + exp(S1**S1*S2))))\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(exp(cos(S1 + exp(S1**S1*S2))))\n", - ":2: RuntimeWarning: invalid value encountered in cos\n", - " return relu(exp(cos(S1 + exp(S1**S1*S2))))\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(exp(cos(S1 + exp(S1**S1*S2))))\n", - ":2: RuntimeWarning: invalid value encountered in cos\n", - " return relu(exp(cos(S1 + exp(S1**S1*S2))))\n", - " 25%|██▍ | 368/1500 [00:23<01:10, 16.15it/s]:2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(S2/cos(S2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(S2/cos(S2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(S2/cos(S2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-cos(S2)/(S1*_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-cos(S2)/(S1*_a0_))\n", - " 25%|██▍ | 370/1500 [00:23<01:10, 16.05it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return relu((_a0_/S2)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu((_a0_/S2)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(_a0_**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(_a0_**_a0_)\n", - " 25%|██▍ | 372/1500 [00:23<01:10, 16.10it/s]:2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(sinh(_a0_))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(sinh(_a0_))**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return log(-_a0_**_a0_/(S1*_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return log(-_a0_**_a0_/(S1*_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(-S1)**_a0_))\n", - " 25%|██▍ | 374/1500 [00:24<01:41, 11.07it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/_a0_**2)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/_a0_**2)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-S2)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-S2)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return log(-(relu(S2)/_a0_)**S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return _a0_**(sqrt(S1))/S1**(3/2)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return _a0_**(sqrt(S1))/S1**(3/2)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(S2*_a0_) + exp(S1)\n", - " 25%|██▌ | 376/1500 [00:24<01:32, 12.09it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/(S1*tan(S2)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/(S1*tan(S2)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/(S1*tan(S2)))\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return exp(-_a0_/(S1*S2))/S1\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return exp(-_a0_/(S1*S2))/S1\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return exp(-_a0_/(S1*S2))/S1\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return (_a0_ + _a0_**_a0_)/S1**(3/2)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return (_a0_ + _a0_**_a0_)/S1**(3/2)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu(S2*sig(_a0_)**(_a0_**_a0_)))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu(S2*sig(_a0_)**(_a0_**_a0_)))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu(S2*sig(_a0_)**(_a0_**_a0_)))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return S1*sqrt(S2*_a0_)/S2\n", - " 25%|██▌ | 378/1500 [00:24<01:25, 13.05it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/(_a0_*sin(_a0_)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/(_a0_*sin(_a0_)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/(_a0_*sin(_a0_)))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return _a0_**abs(_a0_)/(S1 + _a0_)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (sqrt(S1) + _a0_)/(S1*sqrt(_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (sqrt(S1) + _a0_)/(S1*sqrt(_a0_))\n", - " 25%|██▌ | 380/1500 [00:24<01:20, 13.87it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(log(S2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(log(S2))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return exp(-S1)*sin(S2**_a0_)**S2\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return exp(-S1)*sin(S2**_a0_)**S2\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(sqrt(_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(sqrt(_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(sqrt(_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(S2/_a0_)/sqrt(S1*S2)\n", - " 25%|██▌ | 382/1500 [00:24<01:16, 14.53it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(log(S2)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(log(S2)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sinh(S1)**log(_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sinh(S1)**log(_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sinh(S1)**log(_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(tan(sinh(S1))**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(tan(sinh(S1))**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-sig(_a0_)/S1)/S1\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sin(sinh(S1))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sin(sinh(S1))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return S1**(-S1)*sqrt(S2*_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S2**(-S2)*relu(S2)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S2**(-S2)*relu(S2)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S2**(-S2)*relu(S2)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return exp(-_a0_**_a0_/S1)/S1\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return exp(-_a0_**_a0_/S1)/S1\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return exp(-_a0_**_a0_/S1)/S1\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return log(sinh(S1))**_a0_\n", - " 26%|██▌ | 384/1500 [00:24<01:13, 15.10it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(relu(S2)/(S2*_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(relu(S2)/(S2*_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(relu(S2)/(S2*_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(S2/_a0_)/sqrt(-S1*_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(S2/_a0_)/sqrt(-S1*_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(S2/_a0_)/sqrt(-S1*_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-relu(_a0_)/(S1*_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(S2/_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(S2/_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(S1))**(_a0_**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(S1))**(_a0_**_a0_)\n", - " 26%|██▌ | 386/1500 [00:25<01:14, 15.03it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return log(S2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return log(S2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return log(S2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(_a0_**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(_a0_**_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(sinh(sin(S2)))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(sinh(sin(S2)))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(sinh(sin(S2)))**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/(S1*fac(S2)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/(S1*fac(S2)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/(S1*fac(S2)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(_a0_*sinh(S2))*exp(-S1)\n", - " 26%|██▌ | 388/1500 [00:25<01:16, 14.58it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return exp(-S1)*sin(S2**_a0_)**S2\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(S2*_a0_)*exp(-S1 - _a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-relu(log(S2))/(S1*_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-relu(log(S2))/(S1*_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-relu(log(S2))/(S1*_a0_))\n", - " 26%|██▌ | 390/1500 [00:25<01:14, 14.90it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return (S2/_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2/_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-1/S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-1/S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2/_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2/_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(S2 + _a0_)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(S2 + _a0_)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return (sqrt(S1) + _a0_)/(S1*sqrt(relu(_a0_)))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return (sqrt(S1) + _a0_)/(S1*sqrt(relu(_a0_)))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return (sqrt(S1) + _a0_)/(S1*sqrt(relu(_a0_)))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return S1 + sqrt(_a0_/S1)\n", - " 26%|██▌ | 392/1500 [00:25<01:16, 14.52it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*tanh(_a0_)**S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*tanh(_a0_)**S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(S2/tan(S2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(S2/tan(S2))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_ + _a0_**S1)/S1**(3/2)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_ + _a0_**S1)/S1**(3/2)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_ + _a0_**S1)/S1**(3/2)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sinh(S1)**(sqrt(_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sinh(S1)**(sqrt(_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sinh(S1)**(sqrt(_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (sqrt(S1) + _a0_)/(S1*sqrt(sin(_a0_)))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (sqrt(S1) + _a0_)/(S1*sqrt(sin(_a0_)))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (sqrt(S1) + _a0_)/(S1*sqrt(sin(_a0_)))\n", - " 26%|██▋ | 394/1500 [00:25<01:12, 15.36it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-1/S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-1/S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2 + _a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2 + _a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu((S1*_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu((S1*_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu((S1*_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return S2*sqrt(S2*_a0_)*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(cos(S2))**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(cos(S2))**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(sinh(sqrt(_a0_)))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(sinh(sqrt(_a0_)))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(S2*_a0_)*exp(-_a0_)\n", - " 26%|██▋ | 396/1500 [00:25<01:13, 15.04it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/S2)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/S2)\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(2*_a0_)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(2*_a0_)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sin(sinh(S1))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(exp(cos(S1 + exp(S2*_a0_*_a0_**(2*S2)))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(exp(cos(S1 + exp(S2*_a0_*_a0_**(2*S2)))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(exp(cos(S1 + exp(S2*_a0_*_a0_**(2*S2)))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return exp(-S1)*sqrt(cos(S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return exp(-S1)*sqrt(cos(S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return exp(-S1)*sqrt(cos(S1))\n", - " 27%|██▋ | 398/1500 [00:25<01:08, 16.01it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return (relu(relu(S2*_a0_))/tan(S2))**sig(S1**2)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (relu(relu(S2*_a0_))/tan(S2))**sig(S1**2)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (relu(relu(S2*_a0_))/tan(S2))**sig(S1**2)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(S2/_a0_)/sqrt(tan(S2))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(S2/_a0_)/sqrt(tan(S2))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(sinh(_a0_))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - " 27%|██▋ | 400/1500 [00:25<01:08, 15.96it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S1**(-_a0_)*relu(S2)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S1**(-_a0_)*relu(S2)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S1**(-_a0_)*relu(S2)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return (_a0_**3)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return (_a0_**3)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(sin(S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(sin(S1))\n", - " 27%|██▋ | 402/1500 [00:26<01:10, 15.62it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*(S1 + _a0_)**S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*(S1 + _a0_)**S1))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(sinh(S1)**(S1**S1))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(sinh(S1)**(S1**S1))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(sinh(S1)**(S1**S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(log(S1)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(log(S1)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(S2*_a0_)*exp(-S1)/S1\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/_a0_**2)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(sinh(sqrt(_a0_)))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(sinh(sqrt(_a0_)))**_a0_\n", - " 27%|██▋ | 404/1500 [00:26<01:09, 15.86it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)**_a0_/S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*(_a0_**2)**(_a0_**S2)))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*(_a0_**2)**(_a0_**S2)))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*(_a0_**2)**(_a0_**S2)))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-relu(_a0_)/(S1*_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sin(S1))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)**_a0_/S1)\n", - " 27%|██▋ | 407/1500 [00:26<01:02, 17.37it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S2**(-S2)*relu(S2)/_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(log(S1))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (sqrt(S1) + _a0_)**(S1**(3/2))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return S2**(S2**S1)/(S1 + _a0_)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return S2**(S2**S1)/(S1 + _a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(S1)**(_a0_**S2))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(S1)**(_a0_**S2))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(S1)**(_a0_**S2))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(_a0_)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(_a0_)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(sinh(_a0_))**_a0_\n", - " 27%|██▋ | 409/1500 [00:26<01:02, 17.47it/s]:2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-relu(tan(_a0_))/(S1*_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-relu(tan(_a0_))/(S1*_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-relu(tan(_a0_))/(S1*_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(log(S1)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (S2 + sin(sqrt(_a0_)))*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(S2/_a0_)/sqrt(S1*cos(S2)))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(S2/_a0_)/sqrt(S1*cos(S2)))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(S2/_a0_)/sqrt(S1*cos(S2)))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-_a0_/S2)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-_a0_/S2)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-_a0_/S2)\n", - " 27%|██▋ | 411/1500 [00:26<01:00, 17.88it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/_a0_**2)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(sin(S1))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(sin(S1))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(sin(S1))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-1/_a0_**2)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-1/_a0_**2)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-1/_a0_**2)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(tan(S1))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(tan(S1))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(tan(S1))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(tan(S2))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(tan(S2))\n", - " 28%|██▊ | 413/1500 [00:26<01:01, 17.66it/s]:2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(sin(S2)))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(sin(S2)))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(sinh(relu(S2)/(S1*_a0_)))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(sinh(S1)**(S2**S1))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(sinh(S1)**(S2**S1))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(sinh(S1)**(S2**S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (sqrt(S1) + _a0_)/(S1*sqrt(_a0_))\n", - " 28%|██▊ | 415/1500 [00:26<01:03, 17.10it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-(_a0_ + relu(S2))/S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (relu(relu(S2/_a0_))/sin(_a0_))**sig(S1**2)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (relu(relu(S2/_a0_))/sin(_a0_))**sig(S1**2)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (relu(relu(S2/_a0_))/sin(_a0_))**sig(S1**2)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(sinh(log(_a0_))**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(sinh(log(_a0_))**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(sinh(log(_a0_))**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(relu(_a0_**S2)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(_a0_**S2)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(relu(_a0_**S2)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(_a0_**S2)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(S2*_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(S2*_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(S2*_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(S2*_a0_)/(S1*S2)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-1/(S1*_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return exp(-S1)*sin(S2**_a0_)**S2\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(S2/_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(S2/_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(S2/_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(S2*_a0_)\n", - " 28%|██▊ | 417/1500 [00:26<01:05, 16.59it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(S2*_a0_)/S1**2\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-sig(S2)/_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-sig(S2)/_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-sig(S2)/_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(S2/_a0_)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(S2/_a0_)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (sqrt(_a0_) + _a0_)/S1**(3/2)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (sqrt(_a0_) + _a0_)/S1**(3/2)\n", - " 28%|██▊ | 419/1500 [00:27<01:04, 16.66it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return relu((_a0_/S2)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu((_a0_/S2)**_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-relu(_a0_)/(S1*_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(_a0_/S2))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(_a0_/S2))**_a0_\n", - " 28%|██▊ | 421/1500 [00:27<01:05, 16.39it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S1**(-_a0_)*relu(S2)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S1**(-_a0_)*relu(S2)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(_a0_**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(_a0_**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return _a0_**(S2/_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return _a0_**(S2/_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(S1)**(_a0_**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(S1)**(_a0_**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(S1)**(_a0_**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(sin(S2))**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(sin(S2))**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(sin(S2))**_a0_)\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(exp(fac(S1 + exp(S2**2/_a0_))))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(-sinh(S2))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(-sinh(S2))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(-sinh(S2))**_a0_\n", - " 28%|██▊ | 423/1500 [00:27<01:07, 15.92it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(tan(relu(S2)/(S1*_a0_)))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*(S2 + _a0_)**S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*(S2 + _a0_)**S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*(S2 + _a0_)**S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-1/S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-1/S1)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(S2*_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(S2*_a0_)**_a0_\n", - " 28%|██▊ | 425/1500 [00:27<01:04, 16.67it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(_a0_**S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(_a0_**S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(_a0_**S1)**_a0_\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return S1**(S1**S2)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return S1**(S1**S2)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(sinh(S1))**(S1**S1)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(sinh(S1))**(S1**S1)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(sinh(S1))**(S1**S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(cos(sinh(S1))**_a0_))\n", - " 28%|██▊ | 427/1500 [00:27<01:05, 16.38it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/S1**4)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/S1**4)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/S1**4)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(S2/_a0_)/sqrt(S1*S2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-1/(S2*_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(sinh(tan(S1)))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(sinh(tan(S1)))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(sinh(tan(S1)))**_a0_))\n", - " 29%|██▊ | 429/1500 [00:27<01:06, 16.11it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(S1 + _a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(S1 + _a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(sinh(sin(S1)))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(sinh(sin(S1)))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(sinh(sin(S1)))**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*(S2/_a0_)**S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*(S2/_a0_)**S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*(S2/_a0_)**S1))\n", - " 29%|██▊ | 431/1500 [00:27<01:05, 16.25it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(S2/tan(S2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(S2/tan(S2))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(S2*(_a0_**2)**(sqrt(_a0_))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(S2*(_a0_**2)**(sqrt(_a0_))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(S2*(_a0_**2)**(sqrt(_a0_))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(log(S2)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu((S2*_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu((S2*_a0_)**_a0_)\n", - " 29%|██▉ | 433/1500 [00:27<01:07, 15.74it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-sin(S2)/(S1*_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-sin(S2)/(S1*_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*sin(_a0_)**S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*sin(_a0_)**S1))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(_a0_**_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(_a0_**_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(exp(cos(S1 + sqrt(S2**2/_a0_))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(exp(cos(S1 + sqrt(S2**2/_a0_))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(_a0_**S2)*sig(sig(S1))**(-S1*_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(_a0_**S2)*sig(sig(S1))**(-S1*_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(_a0_**S2)*sig(sig(S1))**(-S1*_a0_)\n", - " 29%|██▉ | 435/1500 [00:28<01:08, 15.44it/s]:2: RuntimeWarning: overflow encountered in sinh\n", - " return sinh(S2**S1)**_a0_\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return sinh(S2**S1)**_a0_\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return sinh(S2**S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return (2*_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return (2*_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(_a0_*cos(S1))*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(_a0_*cos(S1))*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(_a0_*cos(S1))*exp(-S1)\n", - " 29%|██▉ | 437/1500 [00:28<01:06, 16.04it/s]:2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-relu(_a0_/S2)/(S1*_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-relu(_a0_/S2)/(S1*_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-relu(_a0_/S2)/(S1*_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(tan(S1)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(tan(S1)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (log(relu(S2/_a0_))/S1)**sig(S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (log(relu(S2/_a0_))/S1)**sig(S1)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(S2 + _a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(S2 + _a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(_a0_*log(S2))*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(_a0_*log(S2))*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(_a0_*log(S2))*exp(-S1)\n", - " 29%|██▉ | 439/1500 [00:28<01:09, 15.35it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(relu(S2)/(S1*_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(relu(S2)/(S1*_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(relu(S2)/(S1*_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*(_a0_/S1)**S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*(_a0_/S1)**S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*(_a0_/S1)**S1))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(sinh(S2*_a0_))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(sinh(S2*_a0_))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(sinh(S2*_a0_))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(log(S1)))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(log(S1)))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(log(S1)))**_a0_\n", - " 29%|██▉ | 441/1500 [00:28<01:09, 15.14it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_**S2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_**S2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_**S2)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(log(_a0_)/S1)\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(log(_a0_)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu((S2 + _a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu((S2 + _a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(S2*_a0_)*exp(-tan(S1))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-relu(-S1)/(S1*_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-relu(-S1)/(S1*_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-relu(-S1)/(S1*_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S2)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S2)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return tan(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return tan(_a0_)**_a0_\n", - " 30%|██▉ | 443/1500 [00:28<01:11, 14.86it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(relu(S2)/cos(S2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(relu(S2)/cos(S2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(relu(S2)/cos(S2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/(_a0_*sinh(_a0_)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/(_a0_*sinh(_a0_)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/(_a0_*sinh(_a0_)))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*sin(_a0_)**S1))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(_a0_**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(_a0_**_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(S1*_a0_)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(S1*_a0_)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(S1*_a0_)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return tan(S2)**_a0_/(S1 + _a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return tan(S2)**_a0_/(S1 + _a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return tan(S2)**_a0_/(S1 + _a0_)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(relu(relu(sinh(S1))**(S2**S1)))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(relu(relu(sinh(S1))**(S2**S1)))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(relu(relu(sinh(S1))**(S2**S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(sinh(_a0_))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return _a0_**(-_a0_)*sqrt(S2*_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return _a0_**(-_a0_)*sqrt(S2*_a0_)\n", - " 30%|██▉ | 445/1500 [00:28<01:09, 15.13it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(exp(_a0_))/(S1*_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(S2)*sig(sig(S1))**(_a0_*_a0_**S2)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(S2)*sig(sig(S1))**(_a0_*_a0_**S2)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(S2)*sig(sig(S1))**(_a0_*_a0_**S2)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(cos(S1)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(cos(S1)**_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(tan(S1)))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(tan(S1)))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(tan(S1)))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return cos(S1)**_a0_\n", - " 30%|██▉ | 447/1500 [00:28<01:08, 15.45it/s]:2: RuntimeWarning: invalid value encountered in scalar power\n", - " return (2*_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return (2*_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(sinh(fac(_a0_))**_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(sinh(fac(_a0_))**_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(sinh(fac(_a0_))**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-S2*_a0_)*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-S2*_a0_)*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-S2*_a0_)*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-sig(log(S2))/S2)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-sig(log(S2))/S2)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-sig(log(S2))/S2)\n", - " 30%|██▉ | 449/1500 [00:28<01:05, 15.98it/s]:2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(_a0_)**_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(_a0_)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(_a0_)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return tan(sinh(S1))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (-sinh(S1))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (-sinh(S1))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (-sinh(S1))**_a0_\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return relu(exp(sinh(S1 + exp(S2**2/_a0_))))\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(exp(sinh(S1 + exp(S2**2/_a0_))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sin(sinh(S1))**_a0_\n", - " 30%|███ | 451/1500 [00:29<01:11, 14.60it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return tan(S2)**_a0_/(S1 + _a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return tan(S2)**_a0_/(S1 + _a0_)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(sinh(S1))**(S1**S1)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(sinh(S1))**(S1**S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-1/S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-1/S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sin(S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return tan(S2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return tan(S2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return tan(S2)**_a0_\n", - " 30%|███ | 453/1500 [00:29<01:10, 14.79it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/(S1*sin(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/(S1*sin(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/(S1*sin(S1)))\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return exp(-_a0_/S1**2)/S1\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return exp(-_a0_/S1**2)/S1\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return exp(-_a0_/S1**2)/S1\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(-S1)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(exp(cos(S1 + exp(S2*_a0_**_a0_/_a0_))))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(exp(cos(S1 + exp(S2*_a0_**_a0_/_a0_))))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(exp(cos(S1 + exp(S2*_a0_**_a0_/_a0_))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(S2*_a0_)/tanh(S1)\n", - " 30%|███ | 455/1500 [00:29<01:08, 15.37it/s]:2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(_a0_)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(_a0_)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(_a0_**_a0_))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(_a0_**_a0_))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(_a0_**_a0_))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(relu(log(_a0_))/S1)\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(relu(log(_a0_))/S1)\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(relu(log(_a0_))/S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(S2*_a0_)/tan(S1)\n", - " 30%|███ | 457/1500 [00:29<01:09, 14.96it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return log(-(relu(S2)/_a0_)**S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S2)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S2)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(S2*_a0_)/relu(S1)\n", - " 31%|███ | 459/1500 [00:29<01:06, 15.75it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*(_a0_**S2)**S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*(_a0_**S2)**S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*(_a0_**S2)**S1))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(-S1)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return exp(-_a0_**(-_a0_)*sig(_a0_))/S1\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return exp(-_a0_**(-_a0_)*sig(_a0_))/S1\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return exp(-_a0_**(-_a0_)*sig(_a0_))/S1\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)**_a0_/S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return _a0_**S1*sig(sig(S1))**(-S1*_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return _a0_**S1*sig(sig(S1))**(-S1*_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return _a0_**S1*sig(sig(S1))**(-S1*_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (_a0_ + sqrt(S2*_a0_))/S1**(3/2)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (_a0_ + sqrt(S2*_a0_))/S1**(3/2)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (_a0_ + sqrt(S2*_a0_))/S1**(3/2)\n", - " 31%|███ | 461/1500 [00:29<01:06, 15.52it/s]:2: RuntimeWarning: overflow encountered in sinh\n", - " return relu(sinh(S1**S1)**_a0_)\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return relu(sinh(S1**S1)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(S2*_a0_)/S1\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(_a0_**_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(_a0_**_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(S2*_a0_)/abs(S1)\n", - " 31%|███ | 463/1500 [00:29<01:06, 15.65it/s]:2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-relu(cos(S2))/(S1*_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-relu(cos(S2))/(S1*_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-relu(cos(S2))/(S1*_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(S2 + _a0_)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(S2 + _a0_)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return log(S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return log(S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return log(S1)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(cos(relu(S2)/(S1*_a0_)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(cos(relu(S2)/(S1*_a0_)))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (sqrt(S1) + _a0_)/(S1*sqrt(_a0_))\n", - " 31%|███ | 465/1500 [00:30<01:07, 15.30it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return abs(sinh(S1)**(_a0_**S2))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return abs(sinh(S1)**(_a0_**S2))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return abs(sinh(S1)**(_a0_**S2))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(_a0_/S2)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(_a0_/S2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return abs(sinh(_a0_/S2)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return abs(sinh(_a0_/S2)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return abs(sinh(_a0_/S2)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(_a0_**_a0_))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(_a0_**_a0_))**_a0_\n", - " 31%|███ | 467/1500 [00:30<01:10, 14.55it/s]:2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-relu(_a0_)/(S1*_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(S2)*sig(sig(S1))**(_a0_**(-S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(S2)*sig(sig(S1))**(_a0_**(-S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sqrt(sig(log(S1/_a0_))/S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S1 + _a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S1 + _a0_)**_a0_\n", - " 31%|███▏ | 469/1500 [00:30<01:09, 14.81it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(cos(sinh(S1))**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(sqrt(_a0_))*sig(sig(S1))**(-S1*_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(sqrt(_a0_))*sig(sig(S1))**(-S1*_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(sqrt(_a0_))*sig(sig(S1))**(-S1*_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_**S2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_**S2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return log(-_a0_**S2/(S1*_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-_a0_**S2/(S1*_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return log(-_a0_**S2/(S1*_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-_a0_**S2/(S1*_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return log(-_a0_**S2/(S1*_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-_a0_**S2/(S1*_a0_))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(relu(relu(sinh(S1))**(S1**S2)))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(relu(relu(sinh(S1))**(S1**S2)))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(relu(relu(sinh(S1))**(S1**S2)))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(S2 + _a0_))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(S2 + _a0_))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(S2 + _a0_))**_a0_\n", - " 31%|███▏ | 471/1500 [00:30<01:10, 14.51it/s]:2: RuntimeWarning: overflow encountered in power\n", - " return relu(sinh(S1))**(S1**S2)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(sinh(S1))**(S1**S2)\n", - " 32%|███▏ | 473/1500 [00:30<01:08, 14.96it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*(-S1**2)**S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*(-S1**2)**S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*(-S1**2)**S1))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(sinh(S2 + _a0_))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(sinh(S2 + _a0_))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(sinh(S2 + _a0_))**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (sqrt(S1) + _a0_)/(S1*sqrt(S2*_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (sqrt(S1) + _a0_)/(S1*sqrt(S2*_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (sqrt(S1) + _a0_)/(S1*sqrt(S2*_a0_))\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return relu(sinh(S1**S1))**_a0_\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return relu(sinh(S1**S1))**_a0_\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return relu(sinh(S1**S1))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(relu(cos(S2))/S1)\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(relu(cos(S2))/S1)\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(relu(cos(S2))/S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S2)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S2)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return exp(-S1)*sqrt(tan(S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return exp(-S1)*sqrt(tan(S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return exp(-S1)*sqrt(tan(S1))\n", - " 32%|███▏ | 475/1500 [00:30<01:12, 14.17it/s]:2: RuntimeWarning: overflow encountered in power\n", - " return abs(sinh(S1)**(S1**S2))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return abs(sinh(S1)**(S1**S2))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return abs(sinh(S1)**(S1**S2))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(-sinh(S2))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(-sinh(S2))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S2/S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(S2*_a0_)/log(S1)\n", - " 32%|███▏ | 477/1500 [00:30<01:10, 14.53it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/S1**2)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(S2/tan(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(S2/tan(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(S2/tan(S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return log(S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return log(S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(tan(log(S2**3))/S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(tan(log(S2**3))/S1)\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(sinh(_a0_))**_a0_\n", - " 32%|███▏ | 479/1500 [00:31<01:10, 14.55it/s]:2: RuntimeWarning: invalid value encountered in scalar power\n", - " return abs(_a0_**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return abs(_a0_**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return abs(_a0_**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(_a0_**3)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(_a0_**3)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(_a0_**3)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(S2)*log(sig(S1))**(-S1*_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(S2)*log(sig(S1))**(-S1*_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(log(S2**3)**3/S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(log(S2**3)**3/S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return abs((_a0_**S1)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return abs((_a0_**S1)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return abs((_a0_**S1)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(relu(_a0_**S2)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(_a0_**S2)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(relu(_a0_**S2)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(_a0_**S2)**_a0_))\n", - " 32%|███▏ | 481/1500 [00:31<01:09, 14.77it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", - " return log(-relu(S2)/(S1*fac(_a0_)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/(S1*fac(_a0_)))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return log(-relu(S2)/(S1*fac(_a0_)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/(S1*fac(_a0_)))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return log(-relu(S2)/(S1*fac(_a0_)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/(S1*fac(_a0_)))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return sqrt(sig(log(log(_a0_)**3))/S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sqrt(sig(log(log(_a0_)**3))/S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-_a0_)*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-_a0_)*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-_a0_)*exp(-S1)\n", - " 32%|███▏ | 483/1500 [00:31<01:13, 13.85it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return relu(S2)*sig(sig(S1))**(_a0_**(-S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S2/(S1*_a0_**2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S2/(S1*_a0_**2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S2/(S1*_a0_**2))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2*_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2*_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*(_a0_**2)**(_a0_**S1)))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*(_a0_**2)**(_a0_**S1)))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*(_a0_**2)**(_a0_**S1)))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(S2*_a0_)*exp(S1)\n", - " 32%|███▏ | 485/1500 [00:31<01:12, 14.00it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*_a0_**S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*_a0_**S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2 + sin(cos(S1)**_a0_))*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2 + sin(cos(S1)**_a0_))*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2 + sin(cos(S1)**_a0_))*exp(-S1)\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(exp(cos(S1 + log(relu(S2)/_a0_))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(exp(cos(S1 + log(relu(S2)/_a0_))))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(relu((sinh(S1)**2)**(S1**S1)))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(relu((sinh(S1)**2)**(S1**S1)))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(relu((sinh(S1)**2)**(S1**S1)))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (sqrt(S1) + _a0_)/(S1*sqrt(_a0_**3))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (sqrt(S1) + _a0_)/(S1*sqrt(_a0_**3))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (sqrt(S1) + _a0_)/(S1*sqrt(_a0_**3))\n", - " 32%|███▏ | 487/1500 [00:31<01:11, 14.12it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/_a0_**2)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_**3)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_**3)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_**3)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(sinh(2*_a0_))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(sinh(2*_a0_))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(sinh(2*_a0_))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(exp(cos(S1 + exp(relu(sqrt(_a0_))/_a0_))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(exp(cos(S1 + exp(relu(sqrt(_a0_))/_a0_))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(exp(cos(S1 + exp(relu(sqrt(_a0_))/_a0_))))\n", - " 33%|███▎ | 489/1500 [00:31<01:14, 13.63it/s]:2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-relu(sin(S2))/(S1*_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-relu(sin(S2))/(S1*_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-relu(sin(S2))/(S1*_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu((2*_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu((2*_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/(S1*S2))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return (S2/_a0_ + sin(log(_a0_)**_a0_))*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return (S2/_a0_ + sin(log(_a0_)**_a0_))*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return (S2/_a0_ + sin(log(_a0_)**_a0_))*exp(-S1)\n", - " 33%|███▎ | 491/1500 [00:31<01:11, 14.06it/s]:2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2/_a0_ + sin((S2 - _a0_)**_a0_))*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2/_a0_ + sin((S2 - _a0_)**_a0_))*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2/_a0_ + sin((S2 - _a0_)**_a0_))*exp(-S1)\n", - " 33%|███▎ | 493/1500 [00:32<01:09, 14.51it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S2/S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return log(-_a0_**S1/(S1*_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-_a0_**S1/(S1*_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return log(-_a0_**S1/(S1*_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-_a0_**S1/(S1*_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return log(-_a0_**S1/(S1*_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-_a0_**S1/(S1*_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S2/_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S2/_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S2/_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return sinh(fac(_a0_))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return sinh(fac(_a0_))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return sinh(fac(_a0_))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_/S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_/S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_/S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(S2/_a0_)*exp(-S1)\n", - " 33%|███▎ | 495/1500 [00:32<01:12, 13.82it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S2*relu(S2)/_a0_**2)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S2*relu(S2)/_a0_**2)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(sin(S2)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(sin(S2)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return exp(-sig(_a0_**_a0_)/S1)/S1\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return exp(-sig(_a0_**_a0_)/S1)/S1\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return exp(-sig(_a0_**_a0_)/S1)/S1\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(S2/_a0_)*exp(-S2)\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-relu(_a0_)/(S1*_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(-S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (sqrt(S1) + _a0_)/(S1*sqrt(_a0_))\n", - " 33%|███▎ | 497/1500 [00:32<01:17, 12.93it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return log(-(relu(S2)/_a0_)**S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(sin(sinh(S1))**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/(S1*fac(S2)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/(S1*fac(S2)))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*(_a0_/S1)**S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*(_a0_/S1)**S1))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(sin(S2)))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(sin(S2)))**_a0_\n", - " 33%|███▎ | 499/1500 [00:32<01:11, 13.91it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(S2 + _a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(S2 + _a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(exp(cos(S1 + exp(_a0_**(-S2)*relu(S2))))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(exp(cos(S1 + exp(_a0_**(-S2)*relu(S2))))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(exp(cos(S1 + exp(_a0_**(-S2)*relu(S2))))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S1/_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S1/_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S1/_a0_)**_a0_\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(S2)*sig(sig(S1))**(S1**S1*_a0_)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(S2)*sig(sig(S1))**(S1**S1*_a0_)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(S2)*sig(sig(S1))**(S1**S1*_a0_)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return S1**(S1**S1)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return S1**(S1**S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (_a0_ + sqrt(sin(_a0_)))/S1**(3/2)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (_a0_ + sqrt(sin(_a0_)))/S1**(3/2)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (_a0_ + sqrt(sin(_a0_)))/S1**(3/2)\n", - " 33%|███▎ | 501/1500 [00:32<01:08, 14.61it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_/S1)**_a0_/(S1 + _a0_)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-(S1 + _a0_)/(S1*_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-(S1 + _a0_)/(S1*_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-(S1 + _a0_)/(S1*_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(_a0_)**_a0_\n", - " 34%|███▎ | 503/1500 [00:32<01:09, 14.39it/s]:2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-(_a0_ + relu(S2))/S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(sin(S2)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return tan(S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return tan(S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sin(S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sin(S1)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(sinh(_a0_))**_a0_\n", - " 34%|███▎ | 505/1500 [00:32<01:10, 14.10it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(sin(S2)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(sin(S2)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(cos(S1)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(S2)*sig(sig(S1))**(_a0_**(-S1))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(_a0_/S1)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(_a0_/S1)**_a0_\n", - " 34%|███▍ | 507/1500 [00:33<01:09, 14.26it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", - " return log(S2/log(_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return log(S2/log(_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return log(S2/log(_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*_a0_**S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*_a0_**S1))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S1 + _a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S1 + _a0_)**_a0_\n", - " 34%|███▍ | 509/1500 [00:33<01:06, 14.87it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S1**(-_a0_)*relu(S2)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S1**(-_a0_)*relu(S2)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(tan(S2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(tan(S2))\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return relu(sinh(S1**S1))**(2*_a0_)\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return relu(sinh(S1**S1))**(2*_a0_)\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return relu(sinh(S1**S1))**(2*_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-relu(_a0_)/(S1*_a0_))\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(relu(exp(cos(S1 + exp(S1**(-S2)*relu(S2))))))\n", - ":2: RuntimeWarning: invalid value encountered in cos\n", - " return relu(relu(exp(cos(S1 + exp(S1**(-S2)*relu(S2))))))\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(relu(exp(cos(S1 + exp(S1**(-S2)*relu(S2))))))\n", - ":2: RuntimeWarning: invalid value encountered in cos\n", - " return relu(relu(exp(cos(S1 + exp(S1**(-S2)*relu(S2))))))\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(relu(exp(cos(S1 + exp(S1**(-S2)*relu(S2))))))\n", - ":2: RuntimeWarning: invalid value encountered in cos\n", - " return relu(relu(exp(cos(S1 + exp(S1**(-S2)*relu(S2))))))\n", - " 34%|███▍ | 511/1500 [00:33<01:10, 14.09it/s]:2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(_a0_**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(_a0_**_a0_)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return S1**(S2**S2)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return S1**(S2**S2)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_ + _a0_**S2)/S1**(3/2)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_ + _a0_**S2)/S1**(3/2)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_ + _a0_**S2)/S1**(3/2)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(S2/log(S2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(S2/log(S2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(S2/log(S2))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sin(sinh(S1))**(2*_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sin(sinh(S1))**(2*_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return _a0_**(-S2)*sqrt(S2*_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return _a0_**(-S2)*sqrt(S2*_a0_)\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(relu(exp(tan(S1 + exp(relu(S2)/_a0_)))))\n", - " 34%|███▍ | 513/1500 [00:33<01:10, 13.98it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)**_a0_/S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu((_a0_/S2)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu((_a0_/S2)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(tanh(log(S2**3))/S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(tanh(log(S2**3))/S1)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return _a0_**(-_a0_)*exp(-sig(_a0_)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return _a0_**(-_a0_)*exp(-sig(_a0_)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return _a0_**(-_a0_)*exp(-sig(_a0_)/S1)\n", - " 34%|███▍ | 515/1500 [00:33<01:11, 13.72it/s]:2: RuntimeWarning: overflow encountered in power\n", - " return S1**(S1**S1)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return S1**(S1**S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (_a0_ + sqrt(cos(S2)))/S1**(3/2)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (_a0_ + sqrt(cos(S2)))/S1**(3/2)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (_a0_ + sqrt(cos(S2)))/S1**(3/2)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(S2*_a0_)*exp(-fac(_a0_))\n", - " 34%|███▍ | 517/1500 [00:33<01:09, 14.06it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(sig(log(S2**3))/(S1 + _a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(exp(cos(S1 + exp(_a0_**(-S1)*relu(S2))))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(exp(cos(S1 + exp(_a0_**(-S1)*relu(S2))))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(exp(cos(S1 + exp(_a0_**(-S1)*relu(S2))))))\n", - " 35%|███▍ | 519/1500 [00:33<01:10, 13.99it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(sin(relu(S2)/(S1*_a0_)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(sin(relu(S2)/(S1*_a0_)))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*_a0_**S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*_a0_**S1))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(log(S1))**(-_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(log(S1))**(-_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*(_a0_**S1)**S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*(_a0_**S1)**S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*(_a0_**S1)**S1))\n", - ":2: RuntimeWarning: overflow encountered in cosh\n", - " return relu(relu(exp(cosh(S1 + exp(relu(S2)/_a0_)))))\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(relu(exp(cosh(S1 + exp(relu(S2)/_a0_)))))\n", - " 35%|███▍ | 521/1500 [00:34<01:13, 13.28it/s]:2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-relu(cos(S2))/(S1*_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-relu(cos(S2))/(S1*_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(cos(S1))**_a0_\n", - " 35%|███▍ | 523/1500 [00:34<01:13, 13.25it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/S1**(3/2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/S1**(3/2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/S1**(3/2))\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return sinh(S2**S2)**_a0_\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return sinh(S2**S2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return log(-_a0_**(-S1)*relu(S2)/_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-_a0_**(-S1)*relu(S2)/_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return log(-_a0_**(-S1)*relu(S2)/_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-_a0_**(-S1)*relu(S2)/_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(cos(S2)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(cos(S2)/S1)\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(_a0_)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(_a0_)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(_a0_**S1)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(_a0_**S1)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(_a0_**S1)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(sinh(log(S2**3))/(S1 + _a0_))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(sinh(log(S2**3))/(S1 + _a0_))\n", - " 35%|███▌ | 525/1500 [00:34<01:12, 13.37it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_ + _a0_**S2)/S1**(3/2)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_ + _a0_**S2)/S1**(3/2)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(sqrt(_a0_))/sqrt(S1*S2))\n", - " 35%|███▌ | 527/1500 [00:34<01:09, 14.03it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*_a0_**S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*_a0_**S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(S2*_a0_)/sig(S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(_a0_**3*relu(S2)**3/S1**3)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(_a0_**3*relu(S2)**3/S1**3)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(sig(log(S1))/(S1 + _a0_))\n", - " 35%|███▌ | 529/1500 [00:34<01:10, 13.84it/s]:2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(_a0_**_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(_a0_**_a0_)**_a0_)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return S1**(S2**S2)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return S1**(S2**S2)\n", - " 35%|███▌ | 531/1500 [00:34<01:11, 13.56it/s]:2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-_a0_*relu(sin(S1))/S1)\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-_a0_*relu(sin(S1))/S1)\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-_a0_*relu(sin(S1))/S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return exp(-S1)*sin((S1 + S2)**_a0_)**(S2/_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return exp(-S1)*sin((S1 + S2)**_a0_)**(S2/_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(sinh(_a0_))**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return log(relu(S1))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return log(relu(S1))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)**_a0_/S1)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu((2*_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu((2*_a0_)**_a0_)\n", - " 36%|███▌ | 533/1500 [00:34<01:10, 13.63it/s]:2: RuntimeWarning: divide by zero encountered in log\n", - " return log(fac(_a0_*relu(S2)/S1))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(fac(_a0_*relu(S2)/S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(S2*_a0_)/cos(S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_/S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_/S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*(_a0_**(2*S1))**S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*(_a0_**(2*S1))**S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*(_a0_**(2*S1))**S1))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(sinh(cos(S1)))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(sinh(cos(S1)))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(sinh(cos(S1)))**_a0_))\n", - " 36%|███▌ | 535/1500 [00:35<01:13, 13.13it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S2*relu(S2)/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S2*relu(S2)/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return S2**_a0_/(_a0_ + log(_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu((S2*_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu((S2*_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S1*_a0_**2/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S1*_a0_**2/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S1*_a0_**2/relu(S1))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(sinh(relu(_a0_))**_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(sinh(relu(_a0_))**_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(sinh(relu(_a0_))**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(exp(-sqrt(_a0_)/S1)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(exp(-sqrt(_a0_)/S1)/S1)\n", - " 36%|███▌ | 537/1500 [00:35<01:13, 13.03it/s]:2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return cos(sinh(S1))**(-_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return cos(sinh(S1))**(-_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (sqrt(S1) + _a0_)/(S1*sqrt(_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S1*relu(S2)/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S1*relu(S2)/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_**_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_**_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return S2*sqrt(S2*_a0_)/S1\n", - " 36%|███▌ | 539/1500 [00:35<01:11, 13.38it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(exp(cos(_a0_**S2 + exp(_a0_*relu(S2))))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(exp(cos(_a0_**S2 + exp(_a0_*relu(S2))))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(exp(cos(_a0_**S2 + exp(_a0_*relu(S2))))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-2*_a0_**2/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-2*_a0_**2/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-2*_a0_**2/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*tanh(_a0_)**S1))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(sinh(S1*_a0_))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(sinh(S1*_a0_))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(sinh(S1*_a0_))**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(S2*_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(S2*_a0_)**_a0_)\n", - " 36%|███▌ | 541/1500 [00:35<01:12, 13.24it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(cos(_a0_*relu(S2)/relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(cos(_a0_*relu(S2)/relu(S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return sinh(relu(_a0_))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return sinh(relu(_a0_))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu((S2*_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu((S2*_a0_)**_a0_)\n", - " 36%|███▌ | 543/1500 [00:35<01:09, 13.68it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-_a0_*fac(S2)/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(exp(-_a0_**(-S1)*sig(_a0_))/S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(exp(-_a0_**(-S1)*sig(_a0_))/S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(exp(-_a0_**(-S1)*sig(_a0_))/S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(sig(log(S2**2))/(_a0_ + cos(S2)))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(sig(log(S2**2))/(_a0_ + cos(S2)))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(sig(log(S2**2))/(_a0_ + cos(S2)))\n", - " 36%|███▋ | 545/1500 [00:35<01:13, 12.95it/s]:2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(sin(S1))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(sin(S1))**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(_a0_**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(_a0_**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(relu(S2)/(S1 + _a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*(_a0_/S2)**S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*(_a0_/S2)**S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*(_a0_/S2)**S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return abs(relu(relu(S2/_a0_)/sqrt(S2*cos(_a0_))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return abs(relu(relu(S2/_a0_)/sqrt(S2*cos(_a0_))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return abs(relu(relu(S2/_a0_)/sqrt(S2*cos(_a0_))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(_a0_**(-S2)*exp(-sig(_a0_)/S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(_a0_**(-S2)*exp(-sig(_a0_)/S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(_a0_**(-S2)*exp(-sig(_a0_)/S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(sinh(S1))**(sqrt(_a0_))\n", - " 36%|███▋ | 547/1500 [00:36<01:14, 12.86it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(tan(_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(tan(_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(sig(log(S2*tanh(S1)))/(S1 + _a0_))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return (sqrt(S1) + _a0_)/(S1*sqrt(_a0_**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return (sqrt(S1) + _a0_)/(S1*sqrt(_a0_**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return (sqrt(S1) + _a0_)/(S1*sqrt(_a0_**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(sig(log(S1*S2))/(S1 + _a0_))\n", - " 37%|███▋ | 549/1500 [00:36<01:11, 13.35it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", - " return log(-_a0_*relu(S2)/relu(S1*_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return log(-_a0_*relu(S2)/relu(S1*_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return log(-_a0_*relu(S2)/relu(S1*_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(S2/_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(S2/_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return log(-(_a0_*relu(S2))**relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return log(-(_a0_*relu(S2))**relu(S1))\n", - " 37%|███▋ | 551/1500 [00:36<01:10, 13.53it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(log(S2)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(log(S2)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(S2/_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(S2/_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (sqrt(S1) + _a0_)/(S1*sqrt(_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*tanh(_a0_)**S1))\n", - " 37%|███▋ | 553/1500 [00:36<01:07, 14.01it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(sin(relu(S2)/(_a0_*relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu((_a0_/S1)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu((_a0_/S1)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu((_a0_/S1)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/(S2*_a0_*relu(S1)))\n", - " 37%|███▋ | 555/1500 [00:36<01:06, 14.23it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S2**(-_a0_)*relu(S2)/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S2**(-_a0_)*relu(S2)/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S2**(-_a0_)*relu(S2)/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(sinh(_a0_))**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(sinh(_a0_))**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/(S1*relu(S1)))\n", - " 37%|███▋ | 557/1500 [00:36<01:02, 15.12it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-(_a0_ + relu(S2))/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-(_a0_ + relu(S2))/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (_a0_ + sqrt(S2 + _a0_))/S1**(3/2)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (_a0_ + sqrt(S2 + _a0_))/S1**(3/2)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (_a0_ + sqrt(S2 + _a0_))/S1**(3/2)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/_a0_**2)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/_a0_**2)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_ + _a0_**S1)/S1**(3/2)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_ + _a0_**S1)/S1**(3/2)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sin(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sin(_a0_)**_a0_\n", - " 37%|███▋ | 559/1500 [00:36<01:02, 15.03it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(sin(relu(S2)/(_a0_*relu(S1))))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(log(S1)))**(-_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(log(S1)))**(-_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(log(S1)))**(-_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(log(S2**2)**3/S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(log(S2**2)**3/S1)\n", - " 37%|███▋ | 561/1500 [00:36<01:05, 14.42it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(sqrt(-sig(_a0_)/S1)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(sqrt(-sig(_a0_)/S1)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu(relu(sinh(_a0_**_a0_))**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu(relu(sinh(_a0_**_a0_))**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu(relu(sinh(_a0_**_a0_))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(relu(tan(S1)))**_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(relu(tan(S1)))**_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(relu(tan(S1)))**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(exp(-_a0_**(-_a0_)*sig(_a0_))/S1)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(exp(-_a0_**(-_a0_)*sig(_a0_))/S1)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(exp(-_a0_**(-_a0_)*sig(_a0_))/S1)\n", - " 38%|███▊ | 563/1500 [00:37<01:40, 9.33it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)**_a0_/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)**_a0_/relu(S1))\n", - " 38%|███▊ | 565/1500 [00:37<01:29, 10.45it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(S2/_a0_)/sqrt(log(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(S2/_a0_)/sqrt(log(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(S2/_a0_)/sqrt(log(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(_a0_/S1)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(_a0_/S1)**_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(-S1)**(-_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return log(S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (sqrt(_a0_) + _a0_)/S1**(3/2)\n", - " 38%|███▊ | 567/1500 [00:37<01:23, 11.24it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", - " return log(-relu(relu(S2))/(_a0_*relu(_a0_)))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return log(-relu(relu(S2))/(_a0_*relu(_a0_)))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(S2/_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(S2/_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(tan(S1)/_a0_)*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(tan(S1)/_a0_)*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(tan(S1)/_a0_)*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(exp(cos(S1 + exp(sqrt(_a0_))))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(exp(cos(S1 + exp(sqrt(_a0_))))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(exp(cos(S1 + exp(sqrt(_a0_))))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*_a0_**S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*_a0_**S1))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(relu(S1 + _a0_))**_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(relu(S1 + _a0_))**_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(relu(S1 + _a0_))**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return exp(-S1)/_a0_**(1/4)\n", - " 38%|███▊ | 569/1500 [00:37<01:18, 11.85it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(-S2*_a0_**S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(-S2*_a0_**S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(relu(sinh(sqrt(_a0_)))**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(relu(sinh(sqrt(_a0_)))**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(relu(sinh(sqrt(_a0_)))**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(exp(-_a0_**(-_a0_)*sig(_a0_))/S1)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(exp(-_a0_**(-_a0_)*sig(_a0_))/S1)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(sinh(S1))**(S2**S1)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(sinh(S1))**(S2**S1)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(sinh(S1))**(S2**S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*(S1 + _a0_)**S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*(S1 + _a0_)**S1))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu(relu(sinh(_a0_**_a0_))**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu(relu(sinh(_a0_**_a0_))**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return exp(-S1)*sqrt(sin(S2))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return exp(-S1)*sqrt(sin(S2))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return exp(-S1)*sqrt(sin(S2))\n", - " 38%|███▊ | 571/1500 [00:37<01:13, 12.64it/s]:2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-relu(_a0_)/(_a0_*relu(S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-relu(_a0_)/(_a0_*relu(S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(sinh(S1 + _a0_))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(sinh(S1 + _a0_))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(sinh(S1 + _a0_))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-relu(relu(S2/_a0_))/(_a0_*relu(S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-relu(relu(S2/_a0_))/(_a0_*relu(S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-relu(relu(S2/_a0_))/(_a0_*relu(S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(_a0_)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(_a0_)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(S2/_a0_)/sqrt(log(S2)))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(S2/_a0_)/sqrt(log(S2)))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(S2/_a0_)/sqrt(log(S2)))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(log(S1))**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(sin(S2))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(sin(S2))**_a0_\n", - " 38%|███▊ | 573/1500 [00:38<01:10, 13.14it/s]:2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu(S2*(_a0_**_a0_)**S1))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu(S2*(_a0_**_a0_)**S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(tan(S1))**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(tan(S1))**_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(relu(S2))/(_a0_*relu(2*S2)))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(S1/_a0_)*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_/S2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_/S2)**_a0_\n", - " 38%|███▊ | 575/1500 [00:38<01:07, 13.65it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(relu(S2))**_a0_/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(relu(S2))**_a0_/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(sinh(relu(_a0_))**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(_a0_**_a0_/(S1 + _a0_))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(sinh(relu(S1))**(sqrt(_a0_)))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(sinh(relu(S1))**(sqrt(_a0_)))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(sinh(relu(S1))**(sqrt(_a0_)))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(log(S1))**(-_a0_)\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(relu(exp(relu(S1 + exp(S2/_a0_)))))\n", - " 38%|███▊ | 577/1500 [00:38<01:07, 13.71it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return relu(relu(S2*log(_a0_)**S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(relu(S2*log(_a0_)**S1))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(S2/_a0_)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(S2/_a0_)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(exp(-sig(_a0_**S2)/S1)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(exp(-sig(_a0_**S2)/S1)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(exp(-sig(_a0_**S2)/S1)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return cos(sinh(S1))**(-_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(_a0_)**_a0_)\n", - " 39%|███▊ | 579/1500 [00:38<01:06, 13.77it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return log(-(relu(relu(S2))/_a0_)**relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return log(-(relu(relu(S2))/_a0_)**relu(S1))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(sinh(log(S1)))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(sinh(log(S1)))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(sinh(log(S1)))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return log(-relu(relu(S2))/(_a0_*relu(sin(S1))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return log(-relu(relu(S2))/(_a0_*relu(sin(S1))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return log(-relu(relu(S2))/(_a0_*relu(sin(S1))))\n", - " 39%|███▊ | 581/1500 [00:38<01:06, 13.85it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(relu(S2))/(_a0_*(S1 + S2)))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return sinh(relu(_a0_))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sqrt(sig(log(S2*_a0_/S1))/S1)\n", - " 39%|███▉ | 583/1500 [00:38<01:07, 13.58it/s]:2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(S1**2/_a0_)*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(relu(S2))/((S1 + _a0_)*relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(relu(S2))/((S1 + _a0_)*relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(relu(S2))/((S1 + _a0_)*relu(S1)))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return S1**(S2**S1)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return S1**(S2**S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return log(S1)**_a0_\n", - " 39%|███▉ | 585/1500 [00:38<01:09, 13.22it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return log(-_a0_**(-S1)*relu(relu(S2))/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return log(-_a0_**(-S1)*relu(relu(S2))/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return log(-_a0_**(-S1)*relu(relu(S2))/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(_a0_)**_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return sinh(relu(cos(S2)))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return sinh(relu(cos(S2)))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return sinh(relu(cos(S2)))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return _a0_*sqrt(S2/_a0_)/S1\n", - " 39%|███▉ | 587/1500 [00:39<01:11, 12.77it/s]:2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return sinh(relu(_a0_))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(S1 + _a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(S1 + _a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(relu(log(S2/S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(relu(log(S2/S1)))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(S2/_a0_)*exp(-sqrt(S2))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return cos(sinh(S1))**(-_a0_)\n", - " 39%|███▉ | 589/1500 [00:39<01:08, 13.36it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", - " return log(-relu(relu(S2))/(_a0_*relu(S1 + _a0_)))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return log(-relu(relu(S2))/(_a0_*relu(S1 + _a0_)))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return log(-relu(relu(S2))/(_a0_*relu(S1 + _a0_)))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(_a0_)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(_a0_)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sqrt(sig(log(S2*sin(S2)))/S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sqrt(sig(log(S2*sin(S2)))/S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(S2/_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(S2/_a0_)**_a0_)\n", - " 39%|███▉ | 591/1500 [00:39<01:08, 13.24it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S2**(-S1)*relu(relu(S2))/_a0_)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(sinh(S1))**(-S2**S2)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(sinh(S1))**(-S2**S2)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(sinh(S1))**(-S2**S2)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(relu(S2))/(S2*relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(relu(S2))/(S2*relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(cos(S1)**_a0_/(S1 + _a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(cos(S1)**_a0_/(S1 + _a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(cos(S1)**_a0_/(S1 + _a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(_a0_)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(_a0_)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(S2/_a0_)*exp(-2*S2)\n", - " 40%|███▉ | 593/1500 [00:39<01:10, 12.85it/s]:2: RuntimeWarning: overflow encountered in power\n", - " return (S2/_a0_ + sin((2*S1 + S2)**(S1**S1)))*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in sin\n", - " return (S2/_a0_ + sin((2*S1 + S2)**(S1**S1)))*exp(-S1)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return (S2/_a0_ + sin((2*S1 + S2)**(S1**S1)))*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in sin\n", - " return (S2/_a0_ + sin((2*S1 + S2)**(S1**S1)))*exp(-S1)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return (S2/_a0_ + sin((2*S1 + S2)**(S1**S1)))*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in sin\n", - " return (S2/_a0_ + sin((2*S1 + S2)**(S1**S1)))*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(relu(S2*log(_a0_)**S1))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(_a0_)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(_a0_)**_a0_))\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(relu(exp((S1 + exp(S2/_a0_))**3)))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(sinh(S1))**fac(_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-relu(S2 + _a0_)/(_a0_*relu(S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-relu(S2 + _a0_)/(_a0_*relu(S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-relu(S2 + _a0_)/(_a0_*relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(sig(log(S2*relu(S2)))/(S1 + _a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu((-sinh(S1))**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu((-sinh(S1))**_a0_)\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(exp(-_a0_/(S1*S2))/S1)\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(exp(-_a0_/(S1*S2))/S1)\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(exp(-_a0_/(S1*S2))/S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (sqrt(S1) + _a0_)/(S1*sqrt(_a0_))\n", - " 40%|███▉ | 595/1500 [00:39<01:09, 13.01it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(cos(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(cos(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu((S1*_a0_)**_a0_/(S1 + _a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return cos(S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(cos(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(cos(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(cos(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*(_a0_/S2)**S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*(_a0_/S2)**S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(relu(_a0_**S2)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(_a0_**S2)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(relu(_a0_**S2)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(_a0_**S2)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(tan(S1))**_a0_\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return sinh(S1)**(S2**S2)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return sinh(S1)**(S2**S2)\n", - " 40%|███▉ | 597/1500 [00:39<01:05, 13.81it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(sin(S1)/_a0_)*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(sin(S1)/_a0_)*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(sin(S1)/_a0_)*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(tan(S1))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(tan(S1))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(relu(S2))/(_a0_*relu(S2)))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_**_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_**_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(tan(log(S2*relu(S2)))/S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(tan(log(S2*relu(S2)))/S1)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(_a0_)**_a0_)\n", - " 40%|███▉ | 599/1500 [00:40<01:13, 12.18it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(S2/_a0_)/sqrt(sin(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(S2/_a0_)/sqrt(sin(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(S2/_a0_)/sqrt(sin(S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-relu(relu(cos(S2)))/(_a0_*relu(S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-relu(relu(cos(S2)))/(_a0_*relu(S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-relu(relu(cos(S2)))/(_a0_*relu(S1)))\n", - " 40%|████ | 601/1500 [00:40<01:34, 9.49it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(_a0_))\n", - " 40%|████ | 603/1500 [00:40<01:30, 9.91it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S2**(-S2)*relu(relu(S2))/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S2**(-S2)*relu(relu(S2))/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S2**(-S2)*relu(relu(S2))/relu(S1))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(S2)*sig(sinh(_a0_))**(S1*_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return exp(-S1)*sqrt(cos(_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return S1**(_a0_**S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return S1**(_a0_**S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(exp(cos(sqrt(_a0_) + exp(S2/_a0_)))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(exp(cos(sqrt(_a0_) + exp(S2/_a0_)))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(exp(cos(sqrt(_a0_) + exp(S2/_a0_)))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(tan(S1))**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(tanh(_a0_))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(tanh(_a0_))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return _a0_**(sqrt(S1))/S1**(3/2)\n", - " 40%|████ | 605/1500 [00:40<01:26, 10.32it/s]:2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(_a0_)**_a0_)\n", - " 40%|████ | 607/1500 [00:40<01:24, 10.55it/s]:2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-relu(relu(_a0_))/(_a0_*relu(S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-relu(relu(_a0_))/(_a0_*relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(relu(_a0_**S2)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(_a0_**S2)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(relu(_a0_**S2)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(_a0_**S2)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(relu(S2 + _a0_))**_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(relu(S2 + _a0_))**_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(relu(S2 + _a0_))**_a0_)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(relu(S2*exp(2*exp(S2))**S1))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(relu(S2*exp(2*exp(S2))**S1))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(relu(S2*exp(2*exp(S2))**S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(tan(log(S2*relu(S2)))/S1)\n", - " 41%|████ | 609/1500 [00:41<01:17, 11.55it/s]:2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(sinh(_a0_))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(log(S1)))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(log(S1)))**_a0_\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(relu(exp(cos(S1 + exp(S2**_a0_)))))\n", - ":2: RuntimeWarning: invalid value encountered in cos\n", - " return relu(relu(exp(cos(S1 + exp(S2**_a0_)))))\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(relu(exp(cos(S1 + exp(S2**_a0_)))))\n", - ":2: RuntimeWarning: invalid value encountered in cos\n", - " return relu(relu(exp(cos(S1 + exp(S2**_a0_)))))\n", - " 41%|████ | 611/1500 [00:41<01:15, 11.80it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(cos(S2)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(cos(S2)/S1)\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-relu(relu(_a0_/S1))/(_a0_*relu(S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-relu(relu(_a0_/S1))/(_a0_*relu(S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-relu(relu(_a0_/S1))/(_a0_*relu(S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-relu(relu(S2/_a0_))/(_a0_*relu(S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-relu(relu(S2/_a0_))/(_a0_*relu(S1)))\n", - " 41%|████ | 613/1500 [00:41<01:16, 11.60it/s]:2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(relu(tan(S2)))**_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(relu(tan(S2)))**_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(relu(tan(S2)))**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(exp(-_a0_**_a0_/S1)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(exp(-_a0_**_a0_/S1)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(exp(-_a0_**_a0_/S1)/S1)\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return sinh(S2**S2)**_a0_\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return sinh(S2**S2)**_a0_\n", - " 41%|████ | 615/1500 [00:41<01:14, 11.81it/s]:2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(relu(-S2))**_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(relu(-S2))**_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(relu(-S2))**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2**_a0_)/(_a0_*relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(exp(cos(S1 + sqrt(S2/_a0_)))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(exp(cos(S1 + sqrt(S2/_a0_)))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (sqrt(_a0_) + _a0_)/S1**(3/2)\n", - " 41%|████ | 617/1500 [00:41<01:11, 12.32it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-(_a0_ + relu(relu(S2)))/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-(_a0_ + relu(relu(S2)))/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(cos(S1)/S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(cos(S1)/S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(cos(S1)/S1))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(sinh(tan(_a0_)))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(sinh(tan(_a0_)))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(sinh(tan(_a0_)))**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(log(relu(S1))**_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(sinh(sin(_a0_)))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(sinh(sin(_a0_)))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(sinh(sin(_a0_)))**_a0_\n", - " 41%|████▏ | 619/1500 [00:41<01:12, 12.20it/s]:2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(sinh(relu(_a0_))**_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(sinh(relu(_a0_)))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(sinh(relu(_a0_)))**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(tanh(log(S2*relu(S2)))/S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(tanh(log(S2*relu(S2)))/S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(S1))**(_a0_**S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(S1))**(_a0_**S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(S1))**(_a0_**S1)\n", - " 41%|████▏ | 621/1500 [00:42<01:12, 12.11it/s]:2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-relu(relu(log(S1)))/(_a0_*relu(S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-relu(relu(log(S1)))/(_a0_*relu(S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-relu(relu(log(S1)))/(_a0_*relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sqrt(sig(log(S2*(S2 + _a0_)))/S1)\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return relu(sinh(S2**S2)**_a0_)\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return relu(sinh(S2**S2)**_a0_)\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return relu(sinh(S2**S2)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(exp(-sig(_a0_**_a0_)/S1)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(exp(-sig(_a0_**_a0_)/S1)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(exp(-sig(_a0_**_a0_)/S1)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return _a0_**(sqrt(S1))/S1**(3/2)\n", - " 42%|████▏ | 623/1500 [00:42<01:12, 12.14it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(relu(S2))**_a0_/relu(S1))\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(relu(exp(cos(S1 + exp(S1**S1/_a0_)))))\n", - ":2: RuntimeWarning: invalid value encountered in cos\n", - " return relu(relu(exp(cos(S1 + exp(S1**S1/_a0_)))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (_a0_ + sqrt(S1*_a0_))/S1**(3/2)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (_a0_ + sqrt(S1*_a0_))/S1**(3/2)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (_a0_ + sqrt(S1*_a0_))/S1**(3/2)\n", - " 42%|████▏ | 625/1500 [00:42<01:09, 12.64it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(_a0_**S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(_a0_**S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sqrt(sig(log(S2*log(S2)))/S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sqrt(sig(log(S2*log(S2)))/S1)\n", - " 42%|████▏ | 627/1500 [00:42<01:09, 12.65it/s]:2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-relu(_a0_)/(_a0_*relu(S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-relu(_a0_)/(_a0_*relu(S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-relu(2*_a0_)/(_a0_*relu(S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-relu(2*_a0_)/(_a0_*relu(S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-relu(2*_a0_)/(_a0_*relu(S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(sinh(S1 + _a0_))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(sinh(S1 + _a0_))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(relu(-S2))**_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(relu(-S2))**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sin(S1)**_a0_\n", - " 42%|████▏ | 629/1500 [00:42<01:10, 12.31it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(cos(S2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(cos(S2))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return log(-relu(relu(S2))/(_a0_*relu(2*_a0_)))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return log(-relu(relu(S2))/(_a0_*relu(2*_a0_)))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return log(-relu(relu(S2))/(_a0_*relu(2*_a0_)))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(sinh(S1/_a0_))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(sinh(S1/_a0_))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(sinh(S1/_a0_))**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sin(relu(S1))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sin(relu(S1))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S2**(-_a0_)*relu(relu(S2))/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S2**(-_a0_)*relu(relu(S2))/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S2**(-_a0_)*relu(relu(S2))/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2/_a0_ + sin((S1 + tan(S2))**_a0_))*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2/_a0_ + sin((S1 + tan(S2))**_a0_))*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2/_a0_ + sin((S1 + tan(S2))**_a0_))*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_**S2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_**S2)**_a0_\n", - " 42%|████▏ | 631/1500 [00:42<01:14, 11.74it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S2)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S2)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(2*_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(2*_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(2*_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_**S2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_**S2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(S2/cos(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(S2/cos(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(S2/cos(S1))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-relu(_a0_)/(_a0_*relu(S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-relu(_a0_)/(_a0_*relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return _a0_**(-S1)*(sqrt(S1) + _a0_)/S1\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return _a0_**(-S1)*(sqrt(S1) + _a0_)/S1\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return _a0_**(-S1)*(sqrt(S1) + _a0_)/S1\n", - " 42%|████▏ | 633/1500 [00:42<01:09, 12.43it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return (S1*_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S1*_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(tan(S1)))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(tan(S1)))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return log(-relu(relu(S2))/(relu(S1)*relu(_a0_)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(relu(S2))/(relu(S1)*relu(_a0_)))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return log(-relu(relu(S2))/(relu(S1)*relu(_a0_)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(relu(S2))/(relu(S1)*relu(_a0_)))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return log(-relu(relu(S2))/(relu(S1)*relu(_a0_)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(relu(S2))/(relu(S1)*relu(_a0_)))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(_a0_**S1)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(_a0_**S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(_a0_**S1)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(_a0_**S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(_a0_**S1)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(_a0_**S1)**_a0_\n", - " 42%|████▏ | 635/1500 [00:43<01:08, 12.67it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(S2/sin(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(S2/sin(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(S2/sin(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(log(S2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(log(S2))\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return relu(sinh(S1**S2))**_a0_\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return relu(sinh(S1**S2))**_a0_\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return relu(sinh(S1**S2))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(sinh(relu(S1))**log(_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(sinh(relu(S1))**log(_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(sinh(relu(S1))**log(_a0_))\n", - " 42%|████▏ | 637/1500 [00:43<01:07, 12.74it/s]:2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-relu(sin(S2))/(_a0_*relu(S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-relu(sin(S2))/(_a0_*relu(S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-relu(sin(S2))/(_a0_*relu(S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(S2*_a0_)*exp(-_a0_**2)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(cos(relu(S1))**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(cos(relu(S1))**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(sinh(log(_a0_)))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(sinh(log(_a0_)))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(sinh(log(_a0_)))**_a0_\n", - " 43%|████▎ | 639/1500 [00:43<01:06, 12.93it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return sqrt(sig(log(S2*tan(S2)))/S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sqrt(sig(log(S2*tan(S2)))/S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/(S2*relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - " 43%|████▎ | 641/1500 [00:43<01:06, 12.96it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(cos(relu(S2)/(_a0_*relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(cos(relu(S2)/(_a0_*relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(S2/_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(S2/_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2/_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2/_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(sinh(sin(S1)))**_a0_))**2\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(sinh(sin(S1)))**_a0_))**2\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(sinh(sin(S1)))**_a0_))**2\n", - " 43%|████▎ | 643/1500 [00:43<01:07, 12.62it/s]:2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(_a0_/S1)**_a0_))**2\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(_a0_/S1)**_a0_))**2\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(_a0_/S1)**_a0_))**2\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sin(S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_ + sqrt(_a0_**S2))/S1**(3/2)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (_a0_ + sqrt(_a0_**S2))/S1**(3/2)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_ + sqrt(_a0_**S2))/S1**(3/2)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (_a0_ + sqrt(_a0_**S2))/S1**(3/2)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_ + sqrt(_a0_**S2))/S1**(3/2)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (_a0_ + sqrt(_a0_**S2))/S1**(3/2)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return sinh(relu(sin(S2)))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return sinh(relu(sin(S2)))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return sinh(relu(sin(S2)))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (sqrt(_a0_) + _a0_)/S1**(3/2)\n", - " 43%|████▎ | 645/1500 [00:43<01:07, 12.70it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", - " return log(-relu(S2)/(_a0_*relu(sin(_a0_))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return log(-relu(S2)/(_a0_*relu(sin(_a0_))))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(sinh(fac(_a0_)))**_a0_))**2\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(sinh(fac(_a0_)))**_a0_))**2\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(sinh(fac(_a0_)))**_a0_))**2\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(_a0_)**_a0_)\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(relu(exp(sqrt(S1 + exp(S2/_a0_)))))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(_a0_**_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(_a0_**_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(S2*_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(S2*_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(S2*_a0_)**_a0_\n", - " 43%|████▎ | 647/1500 [00:44<01:05, 13.02it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-1/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-1/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(S2*_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(S2*_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S1 + _a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S1 + _a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(S1 + _a0_)**_a0_))**2\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(S1 + _a0_)**_a0_))**2\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(S1 + _a0_)**_a0_))**2\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return log(relu(S1))**_a0_\n", - " 43%|████▎ | 649/1500 [00:44<01:04, 13.19it/s]:2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-sin(S2)/(_a0_*relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-sin(S2)/(_a0_*relu(S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(relu(S2*_a0_))**_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(relu(S2*_a0_))**_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(relu(S2*_a0_))**_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(sinh(sinh(_a0_)))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(sinh(sinh(_a0_)))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(sinh(sinh(_a0_)))**_a0_\n", - " 43%|████▎ | 651/1500 [00:44<01:04, 13.23it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return relu(cos(relu(S1))**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sin(relu(S1))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(sinh(2*_a0_))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(sinh(2*_a0_))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/_a0_**2)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/_a0_**2)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(S2/_a0_)/sqrt(-S1*_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(S2/_a0_)/sqrt(-S1*_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(S2/_a0_)/sqrt(-S1*_a0_))\n", - " 44%|████▎ | 653/1500 [00:44<01:04, 13.23it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return log(S1)**_a0_\n", - " 44%|████▎ | 655/1500 [00:44<01:04, 13.10it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/((S2 + _a0_)*relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/((S2 + _a0_)*relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/((S2 + _a0_)*relu(S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(_a0_)**_a0_))**2\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(_a0_)**_a0_))**2\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(_a0_)**_a0_))**2\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(S2/_a0_))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(S2/_a0_))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(S2/_a0_))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_ + _a0_**S2)/S1**(3/2)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_ + _a0_**S2)/S1**(3/2)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/(_a0_**2*relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/(_a0_**2*relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/(_a0_**2*relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(2*_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(2*_a0_)**_a0_\n", - " 44%|████▍ | 657/1500 [00:44<01:04, 12.99it/s]:2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(sinh(_a0_))**_a0_))\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(relu(exp(tan(S1 + exp(S2/_a0_)))))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(sinh(_a0_))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/(S2**2*relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/(S2**2*relu(S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(sinh(_a0_))**_a0_\n", - " 44%|████▍ | 659/1500 [00:44<01:05, 12.86it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/(S1*relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sqrt(sig(log(relu(S2)*log(S2)))/S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sqrt(sig(log(relu(S2)*log(S2)))/S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sqrt(sig(log(relu(S2)*log(S2)))/S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return exp(-S1)*log(S2/_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(log(relu(S1))**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(S1))**(_a0_**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(S1))**(_a0_**_a0_)\n", - " 44%|████▍ | 661/1500 [00:45<01:04, 13.09it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return relu(cos(S2)**_a0_/(S1 + _a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(cos(S2)**_a0_/(S1 + _a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(cos(S2)**_a0_/(S1 + _a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sqrt(sig(log(relu(S2)*log(S2)))/S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sqrt(sig(log(relu(S2)*log(S2)))/S1)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(sinh(_a0_))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)**_a0_/relu(S1))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(S2/_a0_)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(S2/_a0_)**_a0_))\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return sinh(S2**S2)**_a0_\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return sinh(S2**S2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (sqrt(S1) + _a0_)/(S1*sqrt(_a0_))\n", - " 44%|████▍ | 663/1500 [00:45<01:04, 13.07it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(S2/cos(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(S2/cos(S1))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S2/S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S2/S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return log(sqrt(_a0_*relu(S2)/relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return log(sqrt(_a0_*relu(S2)/relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(cos(S1)/_a0_)*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(cos(S1)/_a0_)*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(cos(S1)/_a0_)*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(relu(_a0_**S2)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(_a0_**S2)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(relu(_a0_**S2)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(_a0_**S2)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(sinh(relu(_a0_))**_a0_)\n", - " 44%|████▍ | 665/1500 [00:45<01:03, 13.09it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(sqrt(-log(S2*relu(S2))/S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(sqrt(-log(S2*relu(S2))/S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S1*relu(S2)/relu(S1))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(sinh(relu(2*_a0_))**_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(sinh(relu(2*_a0_))**_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(sinh(relu(2*_a0_))**_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return sinh(relu(S2 + _a0_))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return sinh(relu(S2 + _a0_))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return sinh(relu(S2 + _a0_))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return _a0_**(sqrt(S1))/S1**(3/2)\n", - " 44%|████▍ | 667/1500 [00:45<01:03, 13.21it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", - " return exp(-S1)*sqrt(log(_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return exp(-S1)*sqrt(log(_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return exp(-S1)*sqrt(log(_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(S2/_a0_))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(S2/_a0_))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(tan(_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(tan(_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - " 45%|████▍ | 669/1500 [00:45<01:03, 13.17it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-(_a0_ + relu(S2))/relu(S1))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(sinh(_a0_/S2))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(sinh(_a0_/S2))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(sinh(_a0_/S2))**_a0_))\n", - " 45%|████▍ | 671/1500 [00:45<01:03, 13.08it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(S2/(S2 + _a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(_a0_*relu(S2)/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(_a0_*relu(S2)/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(_a0_*relu(S2)/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_**(-S1)*relu(relu(S2/_a0_)))**sig(relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(sqrt(log(S2*relu(S2))**3/S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(sqrt(log(S2*relu(S2))**3/S1))\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return sinh(relu(S2**S2))**_a0_\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return sinh(relu(S2**S2))**_a0_\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return sinh(relu(S2**S2))**_a0_\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(relu(relu(sinh(S1))**(S2**S2)))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(relu(relu(sinh(S1))**(S2**S2)))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(relu(relu(sinh(S1))**(S2**S2)))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return log(S2)**(-_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return log(S2)**(-_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return log(S2)**(-_a0_)\n", - " 45%|████▍ | 673/1500 [00:46<01:02, 13.17it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return log(-_a0_*relu(S2)/relu(S1))**S2\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(relu(exp(abs(S1 + exp((S2 + _a0_)/_a0_)))))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(sinh(_a0_))**_a0_\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return sinh(S1**S2)**_a0_\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return sinh(S1**S2)**_a0_\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return sinh(S1**S2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(S2/cos(S2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(S2/cos(S2))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(sqrt(-log(S2*relu(S2))/S1))\n", - " 45%|████▌ | 675/1500 [00:46<01:03, 13.02it/s]:2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return sinh(relu(tanh(_a0_)))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return sinh(relu(tanh(_a0_)))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return sinh(relu(tanh(_a0_)))**_a0_\n", - " 45%|████▌ | 677/1500 [00:46<01:03, 13.04it/s]:2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-_a0_*relu(_a0_)/relu(S1))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-_a0_*relu(_a0_)/relu(S1))\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(relu(exp((S1 + exp((S2 + _a0_)/_a0_))**2)))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (-sinh(S1))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return log(sqrt(_a0_*relu(S2)/relu(S1)))\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return sinh(S1**S2)**_a0_\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return sinh(S1**S2)**_a0_\n", - " 45%|████▌ | 679/1500 [00:46<01:01, 13.32it/s]:2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-_a0_*relu(S1*_a0_)/relu(S1))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-_a0_*relu(S1*_a0_)/relu(S1))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-_a0_*relu(S1*_a0_)/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return exp(-S1)*sin((2*S1 + relu(S2))**_a0_)**(S2/_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return exp(-S1)*sin((2*S1 + relu(S2))**_a0_)**(S2/_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sin(S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S1*relu(S2)/relu(S1))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(2*_a0_)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(2*_a0_)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(exp(sqrt(_a0_)/S1)/S1)\n", - " 45%|████▌ | 681/1500 [00:46<01:01, 13.31it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(relu(sinh(_a0_**S1))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(sinh(_a0_**S1))**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(relu(sinh(_a0_**S1))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(sinh(_a0_**S1))**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(relu(sinh(_a0_**S1))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(sinh(_a0_**S1))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(sinh(_a0_))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-_a0_*relu(S2)/relu(S1/S2))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(sqrt(cos(log(S2*relu(S2)))/S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(sqrt(cos(log(S2*relu(S2)))/S1))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(_a0_)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(_a0_)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(relu(_a0_/S1))**_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(relu(_a0_/S1))**_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(relu(_a0_/S1))**_a0_)\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return sinh(S1**S1)**_a0_\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return sinh(S1**S1)**_a0_\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return sinh(S1**S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(_a0_**S1))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(_a0_**S1))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(_a0_**S1))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(_a0_**S1))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(_a0_**S1))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(_a0_**S1))**_a0_\n", - " 46%|████▌ | 683/1500 [00:46<01:01, 13.31it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return log(-_a0_*_a0_**(-S1)*relu(S2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-_a0_*_a0_**(-S1)*relu(S2))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return log(-_a0_*_a0_**(-S1)*relu(S2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-_a0_*_a0_**(-S1)*relu(S2))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return log(-_a0_*_a0_**(-S1)*relu(S2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-_a0_*_a0_**(-S1)*relu(S2))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(-sinh(S1))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(-sinh(S1))**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(S1))**(_a0_**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(S1))**(_a0_**_a0_)\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(exp(-_a0_/(S1*S2))/S1)\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(exp(-_a0_/(S1*S2))/S1)\n", - " 46%|████▌ | 685/1500 [00:46<01:01, 13.22it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return relu(relu(exp(cos(S1 + exp(log(_a0_)/_a0_)))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(relu(exp(cos(S1 + exp(log(_a0_)/_a0_)))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(relu(exp(cos(S1 + exp(log(_a0_)/_a0_)))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return log(-_a0_*relu(S2)/relu(tan(_a0_)))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return log(-_a0_*relu(S2)/relu(tan(_a0_)))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return log(-_a0_*relu(S2)/relu(tan(_a0_)))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(_a0_)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(_a0_)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(2*_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(2*_a0_)**_a0_\n", - " 46%|████▌ | 687/1500 [00:47<01:01, 13.25it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return (S2/_a0_ + sin((2*S1 + sin(S2))**_a0_))*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2/_a0_ + sin((2*S1 + sin(S2))**_a0_))*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(log(S2)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(log(S2)/S1)\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(sinh(_a0_))**_a0_))\n", - " 46%|████▌ | 689/1500 [00:47<01:00, 13.40it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", - " return log(-_a0_*relu(S2)/relu(_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return log(-_a0_*relu(S2)/relu(_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(cos(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(cos(S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(S2*_a0_)*exp(-cos(S2))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(sinh(tan(_a0_)))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(sinh(tan(_a0_)))**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-_a0_*relu(_a0_)/relu(S1))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return sinh(relu(_a0_))**_a0_\n", - " 46%|████▌ | 691/1500 [00:47<01:00, 13.32it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S1*relu(S2)/relu(S1))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return sinh(relu(_a0_))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(S2*_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(S2*_a0_)**_a0_\n", - " 46%|████▌ | 693/1500 [00:47<01:00, 13.38it/s]:2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return S1**(sqrt(_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return S1**(sqrt(_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return S1**(sqrt(_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S2)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S2)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(S1**_a0_*_a0_)*exp(-S1)\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(sinh(relu(_a0_)))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(sinh(relu(_a0_)))**_a0_))\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return sinh(S1**S1)**_a0_\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return sinh(S1**S1)**_a0_\n", - " 46%|████▋ | 695/1500 [00:47<00:58, 13.69it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-sqrt(S1)*relu(S2)/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-sqrt(S1)*relu(S2)/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-sqrt(S1)*relu(S2)/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(S2/_a0_)/sqrt(S1*cos(_a0_)))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(S2/_a0_)/sqrt(S1*cos(_a0_)))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(S2/_a0_)/sqrt(S1*cos(_a0_)))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_ + sqrt(_a0_**S2))/S1**(3/2)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (_a0_ + sqrt(_a0_**S2))/S1**(3/2)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_ + sqrt(_a0_**S2))/S1**(3/2)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (_a0_ + sqrt(_a0_**S2))/S1**(3/2)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S2**S1*_a0_/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(S2/sin(S2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(S2/sin(S2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(S2/sin(S2))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(S2*relu(sig(sqrt(_a0_)))**S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(S2*relu(sig(sqrt(_a0_)))**S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(S2*relu(sig(sqrt(_a0_)))**S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(tan(relu(S1))**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(tan(relu(S1))**_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(sinh(_a0_))**_a0_\n", - " 46%|████▋ | 697/1500 [00:47<00:57, 14.02it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-_a0_*relu(S2)/(S1 + _a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-_a0_*relu(S2)/(S1 + _a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-_a0_*relu(S2)/(S1 + _a0_))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(sqrt(tan(log(S2**2))/S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(sqrt(tan(log(S2**2))/S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(S2/log(S2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(S2/log(S2))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sin(sinh(S1))**_a0_\n", - " 47%|████▋ | 699/1500 [00:47<01:00, 13.35it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(S2*_a0_)/(S2 + _a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(S1*_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(S1*_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return log(sqrt(_a0_*relu(S2)/relu(S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(relu(tan(S2)))**_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(relu(tan(S2)))**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (-sinh(S1))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (-sinh(S1))**_a0_\n", - " 47%|████▋ | 701/1500 [00:48<01:03, 12.50it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return abs(sinh(S2 + _a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return abs(sinh(S2 + _a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return abs(sinh(S2 + _a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)**_a0_/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(S2/_a0_)/sqrt(S2*(S2 + _a0_)))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(tan(S1))**_a0_))\n", - " 47%|████▋ | 703/1500 [00:48<01:04, 12.28it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(S2/tan(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(S2/tan(S1))\n", - " 47%|████▋ | 705/1500 [00:48<01:01, 12.84it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", - " return log(-_a0_*relu(S2)/relu(sin(S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return log(-_a0_*relu(S2)/relu(sin(S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return log(-_a0_*relu(S2)/relu(sin(S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return abs(sinh(relu(_a0_))**_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return abs(sinh(relu(_a0_))**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (sqrt(S1) + _a0_)/(S1*sqrt(S2/_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (sqrt(S1) + _a0_)/(S1*sqrt(S2/_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (sqrt(S1) + _a0_)/(S1*sqrt(S2/_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu((S1*_a0_)**_a0_/(S1 + _a0_)))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(_a0_)**_a0_)\n", - " 47%|████▋ | 707/1500 [00:48<01:00, 13.21it/s]:2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(S1*_a0_)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(S1*_a0_)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(S2 + _a0_))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(S2 + _a0_))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S2/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S2/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S2/relu(S1))\n", - " 47%|████▋ | 709/1500 [00:48<01:00, 13.16it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(S2*relu(sqrt(_a0_))**S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(S2*relu(sqrt(_a0_))**S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(sqrt(sig(log(S2*_a0_/S1))/S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(S2/_a0_)/sqrt(-S2**2))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(S2/_a0_)/sqrt(-S2**2))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(S2/_a0_)/sqrt(-S2**2))\n", - " 47%|████▋ | 711/1500 [00:48<00:57, 13.83it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)**_a0_/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(cos(sinh(S1))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return sinh(relu(sin(S1)))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return sinh(relu(sin(S1)))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return sinh(relu(sin(S1)))**_a0_\n", - " 48%|████▊ | 713/1500 [00:49<00:58, 13.45it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(cos(S1))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(cos(S1))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(S1)**(_a0_**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(S1)**(_a0_**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(2*_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(2*_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(2*_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(exp(cos(S1 + exp(_a0_*(S2 + _a0_**S2))))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(exp(cos(S1 + exp(_a0_*(S2 + _a0_**S2))))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(exp(cos(S1 + exp(_a0_*(S2 + _a0_**S2))))))\n", - " 48%|████▊ | 715/1500 [00:49<00:58, 13.37it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return exp(-S1)*sin((2*S1 + relu(S2))**_a0_)**(S2/_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sin(relu(S1))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(sinh(relu(_a0_))**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-_a0_/S1)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-_a0_/S1)/S1)\n", - " 48%|████▊ | 717/1500 [00:49<00:56, 13.97it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return relu(sqrt(sig(log(tan(S1)))/relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(sqrt(sig(log(tan(S1)))/relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(sqrt(sig(log(tan(S1)))/relu(S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(_a0_)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(_a0_)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sinh(relu(sqrt(_a0_)))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sinh(relu(sqrt(_a0_)))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sinh(relu(sqrt(_a0_)))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(log(S1))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(log(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(log(S1))\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return sinh(relu(S2**S1))**_a0_\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return sinh(relu(S2**S1))**_a0_\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return sinh(relu(S2**S1))**_a0_\n", - " 48%|████▊ | 719/1500 [00:49<01:02, 12.56it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (1/2)*sqrt(S2*_a0_)/_a0_\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(sig(log(S2**2))/(S2*_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(_a0_)**_a0_)\n", - " 48%|████▊ | 721/1500 [00:49<01:02, 12.40it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(S1 + _a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(S1 + _a0_)**_a0_)\n", - " 48%|████▊ | 723/1500 [00:49<00:58, 13.38it/s]:2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(relu(S1/_a0_))**_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(relu(S1/_a0_))**_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(relu(S1/_a0_))**_a0_)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(sinh(S1))**(S1**S1)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(sinh(S1))**(S1**S1)\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(exp(S2/S1**2)/S1)\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(exp(S2/S1**2)/S1)\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(exp(S2/S1**2)/S1)\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return relu(relu(relu(sinh(S1**S2))**_a0_))\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return relu(relu(relu(sinh(S1**S2))**_a0_))\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return relu(relu(relu(sinh(S1**S2))**_a0_))\n", - " 48%|████▊ | 725/1500 [00:49<00:56, 13.83it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", - " return (sqrt(S1) + _a0_)/(sqrt(S1)*relu(fac(_a0_)))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return (sqrt(S1) + _a0_)/(sqrt(S1)*relu(fac(_a0_)))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return (sqrt(S1) + _a0_)/(sqrt(S1)*relu(fac(_a0_)))\n", - " 48%|████▊ | 727/1500 [00:50<00:55, 14.01it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-_a0_*tan(S2)/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-_a0_*tan(S2)/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(cos(S1))**_a0_\n", - " 49%|████▊ | 729/1500 [00:50<01:02, 12.40it/s]:2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-_a0_*relu(_a0_)/relu(S1))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(sinh(relu(_a0_)))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(sinh(relu(_a0_)))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(sinh(relu(_a0_)))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sqrt(log(log(S2**2))/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(log(log(S2**2))/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sqrt(log(log(S2**2))/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(log(log(S2**2))/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (-sinh(S1))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(_a0_**S2)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(_a0_**S2)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S1 + _a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S1 + _a0_)**_a0_\n", - " 49%|████▊ | 731/1500 [00:50<01:04, 11.85it/s]:2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(_a0_**_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(_a0_**_a0_)**_a0_\n", - " 49%|████▉ | 733/1500 [00:50<01:01, 12.46it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return (-sinh(S1))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (-sinh(S1))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return (sqrt(S1) + _a0_)/(sqrt(S1)*relu(_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return (sqrt(S1) + _a0_)/(sqrt(S1)*relu(_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S2/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S2/relu(S1))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return sinh(S1)**(S2**S1)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return sinh(S1)**(S2**S1)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return sinh(S1)**(S2**S1)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(sinh(sin(S1)))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(sinh(sin(S1)))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(sinh(relu(_a0_))**_a0_)\n", - " 49%|████▉ | 735/1500 [00:50<00:59, 12.93it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S2/S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S2/S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (sqrt(S1) + _a0_)**(sqrt(S1)*relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return log(relu(S1))**_a0_\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(relu(relu(sinh(S1))**(S1**S1)))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(relu(relu(sinh(S1))**(S1**S1)))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(relu(relu(sinh(S1))**(S1**S1)))\n", - " 49%|████▉ | 737/1500 [00:50<00:58, 13.02it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", - " return log(-_a0_*relu(S2)/relu(_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(_a0_)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(_a0_)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(log(relu(S1))**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(sin(_a0_)/_a0_)*exp(-S1)\n", - " 49%|████▉ | 739/1500 [00:51<01:01, 12.37it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (sqrt(S1) + _a0_)/(sqrt(_a0_)*relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (sqrt(S1) + _a0_)/(sqrt(_a0_)*relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu(S2*relu(_a0_**_a0_)**S1))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu(S2*relu(_a0_**_a0_)**S1))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu(S2*relu(_a0_**_a0_)**S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(S1/_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(S1/_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return _a0_**(sqrt(S1))/(sqrt(S1)*relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return _a0_**(sqrt(S1))/(sqrt(S1)*relu(S1))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(S1/_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(S1/_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(S1/_a0_)**_a0_\n", - " 49%|████▉ | 741/1500 [00:51<01:27, 8.70it/s]:2: RuntimeWarning: overflow encountered in power\n", - " return sinh(S1)**(S2**S1)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return sinh(S1)**(S2**S1)\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-_a0_*relu(_a0_)/relu(S1))\n", - " 50%|████▉ | 743/1500 [00:51<01:15, 10.00it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S2*relu(S2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S2*relu(S2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S2*relu(S2))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (relu(relu(S2/_a0_))/sin(S1))**sig(relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (relu(relu(S2/_a0_))/sin(S1))**sig(relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-S1/_a0_)*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-S1/_a0_)*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-S1/_a0_)*exp(-S1)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return sinh(relu(-S2))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return sinh(relu(-S2))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return sinh(relu(-S2))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(S1 + _a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(S1 + _a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(_a0_/S2)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(_a0_/S2)**_a0_\n", - " 50%|████▉ | 745/1500 [00:51<01:08, 11.09it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(S2*_a0_/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(S2*_a0_/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(_a0_/S2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(_a0_/S2)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S2*relu(S2)/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(sin(S1))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(sinh(relu(tan(_a0_)))**_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(sinh(relu(tan(_a0_)))**_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(sinh(relu(tan(_a0_)))**_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return (sqrt(S1) + _a0_)/(sqrt(S1)*relu(sin(S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return (sqrt(S1) + _a0_)/(sqrt(S1)*relu(sin(S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return (sqrt(S1) + _a0_)/(sqrt(S1)*relu(sin(S1)))\n", - " 50%|████▉ | 747/1500 [00:51<01:05, 11.56it/s]:2: RuntimeWarning: divide by zero encountered in power\n", - " return sinh(relu(tan(S2)))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return sinh(relu(tan(S2)))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return sinh(relu(tan(S2)))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S1*relu(S2)/relu(S1))\n", - " 50%|████▉ | 749/1500 [00:52<01:00, 12.31it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-_a0_*cos(S2)/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-_a0_*cos(S2)/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S2*relu(S2)/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(S2 + _a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(S2 + _a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(relu(sinh(S1))**(sqrt(_a0_))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(relu(sinh(S1))**(sqrt(_a0_))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(relu(sinh(S1))**(sqrt(_a0_))))\n", - " 50%|█████ | 751/1500 [00:52<01:01, 12.11it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", - " return exp(-S1)*sqrt(tan(_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(exp(cos(S1 + exp(_a0_*_a0_**S2)))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(exp(cos(S1 + exp(_a0_*_a0_**S2)))))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(S1 + _a0_)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(S1 + _a0_)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(S2/_a0_))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(S2/_a0_))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-(_a0_ + relu(S2))/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(tan(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(tan(S1))\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return relu(sinh(S2**S1))**_a0_\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return relu(sinh(S2**S1))**_a0_\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return relu(sinh(S2**S1))**_a0_\n", - " 50%|█████ | 753/1500 [00:52<00:57, 12.90it/s]:2: RuntimeWarning: overflow encountered in sinh\n", - " return sinh(S1**S2)**_a0_\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return sinh(S1**S2)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return (sqrt(S1) + _a0_)/(relu(S1)*sqrt(relu(_a0_)))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return (sqrt(S1) + _a0_)/(relu(S1)*sqrt(relu(_a0_)))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return (sqrt(S1) + _a0_)/(relu(S1)*sqrt(relu(_a0_)))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (-sinh(S1))**_a0_\n", - " 50%|█████ | 755/1500 [00:52<00:55, 13.37it/s]:2: RuntimeWarning: overflow encountered in sinh\n", - " return sinh(S1**S1)**_a0_\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return sinh(S1**S1)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(log(_a0_)/S1)\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(log(_a0_)/S1)\n", - " 50%|█████ | 757/1500 [00:52<00:55, 13.49it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S1*relu(S2)/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sqrt(sig(log(tan(S1)))/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sqrt(sig(log(tan(S1)))/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sqrt(sig(log(tan(S1)))/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(log(_a0_)**_a0_/(S1 + _a0_))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(log(_a0_)**_a0_/(S1 + _a0_))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(log(_a0_)**_a0_/(S1 + _a0_))\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(relu(exp(cos(S1 + exp(_a0_*(S2 + S2**S2))))))\n", - ":2: RuntimeWarning: invalid value encountered in cos\n", - " return relu(relu(exp(cos(S1 + exp(_a0_*(S2 + S2**S2))))))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(sin(S1)))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(sin(S1)))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(sin(S1)))**_a0_\n", - " 51%|█████ | 759/1500 [00:52<00:54, 13.62it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(S2*_a0_)*exp(-S2 - _a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(S1 + _a0_))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(S1 + _a0_))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(S1 + _a0_))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return (sqrt(S1) + _a0_)/(sqrt(S1)*relu(sin(S2)))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return (sqrt(S1) + _a0_)/(sqrt(S1)*relu(sin(S2)))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return (sqrt(S1) + _a0_)/(sqrt(S1)*relu(sin(S2)))\n", - " 51%|█████ | 761/1500 [00:52<00:55, 13.41it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(_a0_**3*relu(S2)**3/relu(S1)**3)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(_a0_**3*relu(S2)**3/relu(S1)**3)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(_a0_*cos(S2))*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(_a0_*cos(S2))*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(_a0_*cos(S2))*exp(-S1)\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-_a0_*relu(S2 + _a0_)/relu(S1))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-_a0_*relu(S2 + _a0_)/relu(S1))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-_a0_*relu(S2 + _a0_)/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*relu(sig(_a0_))**(_a0_**S1)))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*relu(sig(_a0_))**(_a0_**S1)))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*relu(sig(_a0_))**(_a0_**S1)))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (sqrt(S1) + _a0_)/(relu(S1)*sqrt(cos(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (sqrt(S1) + _a0_)/(relu(S1)*sqrt(cos(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (sqrt(S1) + _a0_)/(relu(S1)*sqrt(cos(S1)))\n", - " 51%|█████ | 763/1500 [00:53<00:54, 13.55it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu((-sinh(S2))**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu((-sinh(S2))**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu((-sinh(S2))**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(sin(sinh(S1))**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S2**3*_a0_/relu(S1))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar divide\n", - " return relu(exp(_a0_/relu(_a0_))/S1)\n", - ":2: RuntimeWarning: divide by zero encountered in scalar divide\n", - " return relu(exp(_a0_/relu(_a0_))/S1)\n", - " 51%|█████ | 765/1500 [00:53<00:52, 14.13it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S2*relu(S2)/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(S2/_a0_)/sqrt(tan(S2)))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(S2/_a0_)/sqrt(tan(S2)))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(S2/_a0_)/sqrt(tan(S2)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(S2*_a0_/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(cos(sinh(S1))**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sin(_a0_)**(-_a0_)\n", - " 51%|█████ | 767/1500 [00:53<00:51, 14.12it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-_a0_**2/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-_a0_**2/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-_a0_**2/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(exp(_a0_**relu(S1))/S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(exp(_a0_**relu(S1))/S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-_a0_*relu(S2)/tan(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-_a0_*relu(S2)/tan(S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return exp(-S1)*sqrt(tan(S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return exp(-S1)*sqrt(tan(S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(sig(log(S2**2))/(S2 + _a0_))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return (sqrt(S1) + _a0_**_a0_)/(sqrt(S1)*relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return (sqrt(S1) + _a0_**_a0_)/(sqrt(S1)*relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return (sqrt(S1) + _a0_**_a0_)/(sqrt(S1)*relu(S1))\n", - " 51%|█████▏ | 769/1500 [00:53<00:51, 14.11it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S2*relu(S2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S2*relu(S2))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(tan(S1))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(sin(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(sin(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(sin(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sqrt(sig(log(log(S1)))/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sqrt(sig(log(log(S1)))/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sqrt(sig(log(log(S1)))/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sin(sinh(S1))**_a0_\n", - " 51%|█████▏ | 771/1500 [00:53<00:54, 13.44it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-(_a0_ + relu(S2))/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(_a0_*relu(S2)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(_a0_*relu(S2)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(relu(sinh(S1))**(sqrt(_a0_))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(relu(sinh(S1))**(sqrt(_a0_))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return (sqrt(S1) + _a0_)/(sqrt(S1)*relu(_a0_/S1))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return (sqrt(S1) + _a0_)/(sqrt(S1)*relu(_a0_/S1))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return (sqrt(S1) + _a0_)/(sqrt(S1)*relu(_a0_/S1))\n", - " 52%|█████▏ | 773/1500 [00:53<00:53, 13.64it/s]:2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(2*_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(2*_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(S2/cos(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(S2/cos(S1))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-_a0_*relu(S2/_a0_)/relu(S1))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-_a0_*relu(S2/_a0_)/relu(S1))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-_a0_*relu(S2/_a0_)/relu(S1))\n", - " 52%|█████▏ | 775/1500 [00:53<00:52, 13.76it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S2*relu(S2)/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sqrt(sig(log(S2*sin(S1)))/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sqrt(sig(log(S2*sin(S1)))/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sqrt(sig(log(S2*sin(S1)))/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2*_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2*_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return S1**(_a0_**S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return S1**(_a0_**S1)\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return (sqrt(S1) + _a0_)/(sqrt(S1)*relu(_a0_))\n", - " 52%|█████▏ | 777/1500 [00:54<00:50, 14.24it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return sin(relu(S1))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return (sqrt(S1) + _a0_)/(sqrt(S1)*relu(tan(S2)))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return (sqrt(S1) + _a0_)/(sqrt(S1)*relu(tan(S2)))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return (sqrt(S1) + _a0_)/(sqrt(S1)*relu(tan(S2)))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(sinh(_a0_))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(S2/_a0_)/sqrt(-S1*S2))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(S2/_a0_)/sqrt(-S1*S2))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(S2/_a0_)/sqrt(-S1*S2))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sin(S1)**_a0_\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(relu(exp(cos(S1 + exp(_a0_*(S1**S2 + _a0_))))))\n", - ":2: RuntimeWarning: invalid value encountered in cos\n", - " return relu(relu(exp(cos(S1 + exp(_a0_*(S1**S2 + _a0_))))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(S1/_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(S1/_a0_)**_a0_\n", - " 52%|█████▏ | 779/1500 [00:54<00:54, 13.16it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return sin(S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (sqrt(S1) + _a0_)/(relu(S1)*sqrt(log(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (sqrt(S1) + _a0_)/(relu(S1)*sqrt(log(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (sqrt(S1) + _a0_)/(relu(S1)*sqrt(log(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(sinh(log(_a0_)))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(sinh(log(_a0_)))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(exp(_a0_**relu(S1))/S1)\n", - " 52%|█████▏ | 781/1500 [00:54<00:52, 13.64it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return log(-_a0_*_a0_**(-S1)*relu(S2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-_a0_*_a0_**(-S1)*relu(S2))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return log(-_a0_*_a0_**(-S1)*relu(S2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-_a0_*_a0_**(-S1)*relu(S2))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-_a0_)*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-_a0_)*exp(-S1)\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(sinh(_a0_))**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(exp(_a0_**relu(S1))/S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return log(-(_a0_*relu(S2))**relu(S1))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(S2)*sig(sig(S1))**(S2**S1*_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(cos(S1))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(sinh(relu(_a0_)))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(sinh(relu(_a0_)))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(log(S2)))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(log(S2)))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(log(S2)))**_a0_\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(exp(cosh(S2)/relu(S1))/S1)\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(exp(cosh(S2)/relu(S1))/S1)\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(exp(cosh(S2)/relu(S1))/S1)\n", - " 52%|█████▏ | 783/1500 [00:54<00:51, 14.03it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-_a0_*exp(S2)/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sinh(relu(S1))**(sqrt(_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sinh(relu(S1))**(sqrt(_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sinh(relu(S1))**(sqrt(_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(_a0_)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(_a0_)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(S1*_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(S1*_a0_)**_a0_\n", - " 52%|█████▏ | 785/1500 [00:54<00:49, 14.49it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)*log(S2)/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)*log(S2)/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)*log(S2)/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(S2/_a0_)*exp(-exp(S2))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(S1/_a0_))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(S1/_a0_))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(S1/_a0_))**_a0_\n", - " 52%|█████▏ | 787/1500 [00:54<00:50, 14.17it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(S1/(S2*_a0_))*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(_a0_**_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(_a0_**_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return log(-_a0_*relu(S2)/relu(relu(_a0_)))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return log(-_a0_*relu(S2)/relu(relu(_a0_)))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return log(-_a0_*relu(S2)/relu(relu(_a0_)))\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return sinh(relu(S1**S2))**_a0_\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return sinh(relu(S1**S2))**_a0_\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return sinh(relu(S1**S2))**_a0_\n", - " 53%|█████▎ | 789/1500 [00:54<00:51, 13.85it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(tan(_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(tan(_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(fac(S1)/_a0_)*exp(-S1)\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(relu(exp(abs(S1 + exp(_a0_*(S2 + _a0_))))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sqrt(sig(log(tan(S1)))/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sqrt(sig(log(tan(S1)))/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(S2 + _a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(S2 + _a0_)**_a0_\n", - " 53%|█████▎ | 791/1500 [00:55<00:53, 13.14it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return sqrt(sig(log(S2*cos(S2)))/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sqrt(sig(log(S2*cos(S2)))/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sqrt(sig(log(S2*cos(S2)))/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sinh(log(_a0_))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sinh(log(_a0_))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sinh(log(_a0_))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sin(S1)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return sinh(relu(S2*_a0_))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return sinh(relu(S2*_a0_))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return sinh(relu(S2*_a0_))**_a0_\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return S1**(S2**S1)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return S1**(S2**S1)\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(-_a0_*relu(_a0_)/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu(exp(cos(S1 + exp(_a0_*(_a0_ + _a0_**_a0_))))))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu(exp(cos(S1 + exp(_a0_*(_a0_ + _a0_**_a0_))))))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu(exp(cos(S1 + exp(_a0_*(_a0_ + _a0_**_a0_))))))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return tanh(_a0_)**(-_a0_)\n", - " 53%|█████▎ | 793/1500 [00:55<00:53, 13.18it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return log(S1)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(_a0_)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(_a0_)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-(S2 + _a0_)*relu(S2)/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-(S2 + _a0_)*relu(S2)/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-(S2 + _a0_)*relu(S2)/relu(S1))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(tan(S1))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(-S1)**_a0_\n", - " 53%|█████▎ | 795/1500 [00:55<00:51, 13.74it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return _a0_**(sqrt(S1))/(sqrt(S1)*relu(S1))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(S1*_a0_)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(S1*_a0_)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return _a0_*log(-_a0_*relu(S2)/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(S1 + _a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(S1 + _a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(sinh(_a0_))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(sinh(_a0_))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(sinh(_a0_))**_a0_\n", - " 53%|█████▎ | 797/1500 [00:55<00:51, 13.75it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S1*relu(S2)/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return _a0_**(-S2)*(sqrt(S1) + _a0_)/relu(S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return _a0_**(-S2)*(sqrt(S1) + _a0_)/relu(S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return _a0_**(-S2)*(sqrt(S1) + _a0_)/relu(S1)\n", - " 53%|█████▎ | 799/1500 [00:55<00:47, 14.87it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S2**_a0_*_a0_/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(exp(cos(S1 + sqrt(_a0_*(S2 + _a0_))))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(exp(cos(S1 + sqrt(_a0_*(S2 + _a0_))))))\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return sinh(S2**S2)**_a0_\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return sinh(S2**S2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sqrt(sig(log(-S2**2))/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sqrt(sig(log(-S2**2))/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sqrt(sig(log(-S2**2))/relu(S1))\n", - " 53%|█████▎ | 801/1500 [00:55<00:48, 14.48it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return tan(S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(relu(sinh(S1))**(_a0_**S2)))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(relu(sinh(S1))**(_a0_**S2)))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(relu(sinh(S1))**(_a0_**S2)))\n", - " 54%|█████▎ | 803/1500 [00:55<00:47, 14.74it/s]:2: RuntimeWarning: divide by zero encountered in scalar divide\n", - " return relu(exp(_a0_/relu(_a0_))/S1)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu(_a0_**_a0_*relu(sig(_a0_))**S1))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu(_a0_**_a0_*relu(sig(_a0_))**S1))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu(_a0_**_a0_*relu(sig(_a0_))**S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return log(S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (-sinh(S1))**_a0_\n", - " 54%|█████▎ | 805/1500 [00:56<00:45, 15.14it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (sqrt(S1) + _a0_)/(sqrt(_a0_)*relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S1**2*relu(S2)/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S1**2*relu(S2)/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S1**2*relu(S2)/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return log(S1)**_a0_\n", - " 54%|█████▍ | 807/1500 [00:56<00:47, 14.72it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (sqrt(S1) + _a0_)/(sqrt(S1/_a0_)*relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (sqrt(S1) + _a0_)/(sqrt(S1/_a0_)*relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (sqrt(S1) + _a0_)/(sqrt(S1/_a0_)*relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S2/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S2/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sqrt(sig(log(cos(S2)))/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sqrt(sig(log(cos(S2)))/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sqrt(sig(log(cos(S2)))/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(sinh(S2/_a0_))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(sinh(S2/_a0_))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(sinh(S2/_a0_))**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return log(sinh(S1))**_a0_\n", - " 54%|█████▍ | 809/1500 [00:56<00:49, 14.08it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return log(-(_a0_*relu(S2))**relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return cos(sinh(S1))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S2*relu(S2)/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return exp(-S1)*sqrt(sin(S2))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return exp(-S1)*sqrt(sin(S2))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return (sqrt(S1) + _a0_)/(sqrt(S1)*relu(_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(_a0_/S2)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(_a0_/S2)**_a0_\n", - " 54%|█████▍ | 811/1500 [00:56<00:47, 14.39it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-_a0_**2/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-_a0_**2/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(exp(_a0_**relu(S1))/S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S2*relu(S2)/relu(S1))\n", - " 54%|█████▍ | 813/1500 [00:56<00:45, 15.07it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return relu(cos(S1)**_a0_/(S1 + _a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(cos(S1)**_a0_/(S1 + _a0_))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(-sinh(S1))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(-sinh(S1))**_a0_))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return S1**(S1**S2)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return S1**(S1**S2)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-_a0_**2/relu(relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-_a0_**2/relu(relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-_a0_**2/relu(relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(S2**_a0_/(S1 + _a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return cos(S1)**_a0_\n", - " 54%|█████▍ | 815/1500 [00:56<00:46, 14.63it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(S2/sin(S2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(S2/sin(S2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)*cos(S1)/relu(relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)*cos(S1)/relu(relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)*cos(S1)/relu(relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sin(S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(_a0_)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(_a0_)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(sinh(_a0_))**_a0_\n", - " 54%|█████▍ | 817/1500 [00:56<00:44, 15.26it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", - " return log(-_a0_*relu(S2)/relu(S2*_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return log(-_a0_*relu(S2)/relu(S2*_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return log(-_a0_*relu(S2)/relu(S2*_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(S1 + _a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(S1 + _a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2*_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2*_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return log(-_a0_*relu(S2)/relu(_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return log(-_a0_*relu(S2)/relu(_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return (sqrt(S1) + _a0_)/(sqrt(S1)*relu(tan(_a0_)))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return (sqrt(S1) + _a0_)/(sqrt(S1)*relu(tan(_a0_)))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return (sqrt(S1) + _a0_)/(sqrt(S1)*relu(tan(_a0_)))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(cos(sinh(S1))**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(exp(_a0_/relu(S1))/log(_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(exp(_a0_/relu(S1))/log(_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(exp(_a0_/relu(S1))/log(_a0_))\n", - " 55%|█████▍ | 819/1500 [00:56<00:45, 15.01it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return (S2/_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2/_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (_a0_ + sqrt(sin(S2)))/(sqrt(S1)*relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (_a0_ + sqrt(sin(S2)))/(sqrt(S1)*relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (_a0_ + sqrt(sin(S2)))/(sqrt(S1)*relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-(_a0_ + relu(S2))/relu(relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-(_a0_ + relu(S2))/relu(relu(S1)))\n", - " 55%|█████▍ | 821/1500 [00:57<00:46, 14.63it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(S2/log(S2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(S2/log(S2))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return (sqrt(S1) + _a0_)/(sqrt(S1)*relu(_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return (sqrt(S1) + _a0_)/(sqrt(S1)*relu(_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S2*relu(S2)/relu(relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S2*relu(S2)/relu(relu(S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(_a0_)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(_a0_)**_a0_))\n", - " 55%|█████▍ | 823/1500 [00:57<00:47, 14.21it/s]:2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(sinh(tan(S2)))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(sinh(tan(S2)))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(sinh(tan(S2)))**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(exp(_a0_/relu(S1))/sqrt(_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(exp(_a0_/relu(S1))/sqrt(_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(exp(_a0_/relu(S1))/sqrt(_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(_a0_**(-_a0_)*exp(_a0_/relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(_a0_**(-_a0_)*exp(_a0_/relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(_a0_**(-_a0_)*exp(_a0_/relu(S1)))\n", - " 55%|█████▌ | 825/1500 [00:57<00:47, 14.24it/s]:2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(sinh(cos(S1)))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(sinh(cos(S1)))**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return cos(S1)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(sinh(_a0_**3))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(sinh(_a0_**3))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S1/relu(relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S1/relu(relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S1/relu(relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return (2*_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return (2*_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (sqrt(S1) + _a0_)**(sqrt(S1)*relu(cosh(S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(exp(_a0_/relu(S2 + _a0_))/S1)\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(exp(_a0_/relu(S2 + _a0_))/S1)\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(exp(_a0_/relu(S2 + _a0_))/S1)\n", - " 55%|█████▌ | 827/1500 [00:57<00:47, 14.05it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return (relu(relu(S2*_a0_))/cos(S1))**sig(relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (relu(relu(S2*_a0_))/cos(S1))**sig(relu(S1))\n", - " 55%|█████▌ | 829/1500 [00:57<00:46, 14.33it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-_a0_**2/relu(relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-_a0_**2/relu(relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_**3)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_**3)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(sig(log(S2**2))/cos(S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(sig(log(S2**2))/cos(S1))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(_a0_/S1)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(_a0_/S1)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(_a0_**S2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(_a0_**S2)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(S2/_a0_))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(S2/_a0_))**_a0_\n", - " 55%|█████▌ | 831/1500 [00:57<00:47, 14.20it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-_a0_*relu(S2)/relu(S1**3)))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sqrt(_a0_**_a0_/_a0_)*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-_a0_*relu(S1**3)/relu(relu(S1))))\n", - " 56%|█████▌ | 833/1500 [00:57<00:47, 14.09it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-_a0_**2/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-_a0_**2/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-_a0_**2/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(_a0_/S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(_a0_/S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(_a0_/S1)**_a0_\n", - " 56%|█████▌ | 837/1500 [00:58<00:45, 14.70it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_/S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_/S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(_a0_**_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(_a0_**_a0_)**_a0_\n", - " 56%|█████▌ | 839/1500 [00:58<00:44, 14.78it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-_a0_*relu(S2)/relu(relu(S1))))/S1\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(S2*_a0_))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(S2*_a0_))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-relu(S2)**2/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-relu(S2)**2/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-relu(S2)**2/relu(relu(S1))))\n", - " 56%|█████▌ | 841/1500 [00:58<00:43, 15.08it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(exp(cos(S1 + exp((S2 + _a0_)**_a0_)))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(exp(cos(S1 + exp((S2 + _a0_)**_a0_)))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-relu(S2)*exp(S2)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-relu(S2)*exp(S2)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-relu(S2)*exp(S2)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(sqrt(S2/_a0_)*exp(-S1))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_**_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_**_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(S1*_a0_)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(S1*_a0_)**_a0_))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return S1**(S1**S2)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return S1**(S1**S2)\n", - " 56%|█████▌ | 843/1500 [00:58<00:45, 14.35it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(tan(S2)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(tan(sinh(S1))**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(relu(S2)/log(S2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(relu(S2)/log(S2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(relu(S2)/log(S2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-relu(S2)*abs(S1)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-relu(S2)*abs(S1)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-relu(S2)*abs(S1)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*relu(sig(_a0_**S1))**S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*relu(sig(_a0_**S1))**S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*relu(sig(_a0_**S1))**S1))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(S2/_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(S2/_a0_)**_a0_\n", - " 56%|█████▋ | 845/1500 [00:58<00:46, 13.98it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(log(_a0_*relu(S2)/relu(relu(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(log(_a0_*relu(S2)/relu(relu(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in divide\n", - " return (relu(relu(S2*_a0_))/relu(_a0_))**sig(relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(S1)**(_a0_**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(S1)**(_a0_**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu(relu(sinh(_a0_**_a0_))**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu(relu(sinh(_a0_**_a0_))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return relu(log(-_a0_*relu(sinh(_a0_))/relu(relu(S1))))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return relu(log(-_a0_*relu(sinh(_a0_))/relu(relu(S1))))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return relu(log(-_a0_*relu(sinh(_a0_))/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return exp(-S1)*sqrt(sin(S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return exp(-S1)*sqrt(sin(S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return exp(-S1)*sqrt(sin(S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(S2 + _a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(S2 + _a0_)**_a0_\n", - " 56%|█████▋ | 847/1500 [00:58<00:47, 13.89it/s]:2: RuntimeWarning: divide by zero encountered in log\n", - " return relu(log(-_a0_*relu(S1*_a0_)/relu(relu(S1))))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return relu(log(-_a0_*relu(S1*_a0_)/relu(relu(S1))))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return relu(log(-_a0_*relu(S1*_a0_)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(S1*_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(S1*_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2/_a0_)**(-_a0_)\n", - " 57%|█████▋ | 849/1500 [00:59<00:48, 13.33it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S1*relu(S2)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S1*relu(S2)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(S2/_a0_)/sqrt(cos(_a0_)))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(S2/_a0_)/sqrt(cos(_a0_)))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(S2/_a0_)/sqrt(cos(_a0_)))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (sqrt(S2) + _a0_**S1)/(sqrt(S1)*relu(cosh(fac(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (sqrt(S2) + _a0_**S1)/(sqrt(S1)*relu(cosh(fac(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (sqrt(S2) + _a0_**S1)/(sqrt(S1)*relu(cosh(fac(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(_a0_**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(_a0_**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sin(S2)**(-_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sin(S2)**(-_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sin(S2)**(-_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-_a0_*tan(S2)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-_a0_*tan(S2)/relu(relu(S1))))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar divide\n", - " return exp(_a0_/relu(_a0_))/S1\n", - ":2: RuntimeWarning: divide by zero encountered in scalar divide\n", - " return exp(_a0_/relu(_a0_))/S1\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return tan(sinh(S1))**_a0_\n", - " 57%|█████▋ | 851/1500 [00:59<00:49, 13.08it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(tan(_a0_*relu(S2)/relu(relu(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(tan(_a0_*relu(S2)/relu(relu(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (-relu(relu(S2*_a0_))/S1)**sig(relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (-relu(relu(S2*_a0_))/S1)**sig(relu(S1))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(sinh(_a0_**3))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(sinh(_a0_**3))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(sinh(_a0_**3))**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return log(S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2*relu(S2)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2*relu(S2)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(log(S1))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(log(S1))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(log(S1))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (sqrt(S2) + _a0_)/(sqrt(S2 + _a0_)*relu(cosh(fac(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (sqrt(S2) + _a0_)/(sqrt(S2 + _a0_)*relu(cosh(fac(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (sqrt(S2) + _a0_)/(sqrt(S2 + _a0_)*relu(cosh(fac(S1))))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(tan(S1))**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(_a0_**S2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(_a0_**S2)**_a0_\n", - " 57%|█████▋ | 853/1500 [00:59<00:48, 13.47it/s]:2: RuntimeWarning: divide by zero encountered in log\n", - " return relu(log(-_a0_*relu(tan(S2))/relu(relu(S1))))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return relu(log(-_a0_*relu(tan(S2))/relu(relu(S1))))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return relu(log(-_a0_*relu(tan(S2))/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(S2/_a0_)/sqrt(S2*tan(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(S2/_a0_)/sqrt(S2*tan(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(S2/_a0_)/sqrt(S2*tan(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(log(-_a0_*relu(S2)/relu(_a0_**_a0_)))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(log(-_a0_*relu(S2)/relu(_a0_**_a0_)))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(log(-_a0_*relu(S2)/relu(_a0_**_a0_)))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_**S2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_**S2)**_a0_\n", - " 57%|█████▋ | 855/1500 [00:59<00:48, 13.23it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return _a0_ + relu(log(-_a0_*relu(S2)/relu(relu(S1))))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return _a0_ + relu(log(-_a0_*relu(S2)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (sqrt(S2) + _a0_)/(sqrt(_a0_)*relu(cosh(fac(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (sqrt(S2) + _a0_)/(sqrt(_a0_)*relu(cosh(fac(S1))))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(_a0_/S1)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(_a0_/S1)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(_a0_**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(_a0_**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return S1**log(_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(S2)*sig(sig(S1))**(_a0_*_a0_**S2)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(S2)*sig(sig(S1))**(_a0_*_a0_**S2)\n", - " 57%|█████▋ | 857/1500 [00:59<00:47, 13.56it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return relu(log(-_a0_*relu(S2)/relu(_a0_**S2)))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-_a0_*relu(S2)/relu(_a0_**S2)))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(log(-_a0_*relu(S2)/relu(_a0_**S2)))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-_a0_*relu(S2)/relu(_a0_**S2)))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(log(-_a0_*relu(S2)/relu(_a0_**S2)))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-_a0_*relu(S2)/relu(_a0_**S2)))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return log(S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-_a0_**2/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-_a0_**2/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu((S1/_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu((S1/_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu((S1/_a0_)**_a0_)\n", - " 57%|█████▋ | 859/1500 [00:59<00:46, 13.66it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return log(S1)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return (sqrt(S2) + _a0_)/(sqrt(S1)*relu(tan(fac(S1))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return (sqrt(S2) + _a0_)/(sqrt(S1)*relu(tan(fac(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(_a0_**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(_a0_**_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(_a0_/S1)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(_a0_/S1)**_a0_\n", - " 57%|█████▋ | 861/1500 [00:59<00:45, 14.02it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return relu(log(-_a0_*relu(_a0_**S1)/relu(relu(S1))))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return relu(log(-_a0_*relu(_a0_**S1)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(log(-_a0_*relu(_a0_**S1)/relu(relu(S1))))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return relu(log(-_a0_*relu(_a0_**S1)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(log(-_a0_*relu(_a0_**S1)/relu(relu(S1))))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return relu(log(-_a0_*relu(_a0_**S1)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(sin(S2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(sin(S2))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(S2*relu(sig(sqrt(_a0_)))**S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(S2*relu(sig(sqrt(_a0_)))**S1))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu(relu(sinh(_a0_**_a0_))**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu(relu(sinh(_a0_**_a0_))**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-_a0_*relu(exp(_a0_))/relu(relu(S1))))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return relu(log(-_a0_*relu(exp(_a0_))/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S1 + _a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S1 + _a0_)**_a0_\n", - " 58%|█████▊ | 863/1500 [01:00<00:44, 14.19it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(cos(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(cos(S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (-sinh(S1))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (-sinh(S1))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(relu(S2*relu(log(_a0_))**S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(relu(S2*relu(log(_a0_))**S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(sqrt(cos(S1 + exp(_a0_*(S2 + _a0_))))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(sqrt(cos(S1 + exp(_a0_*(S2 + _a0_))))))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(sinh(S1/_a0_))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(sinh(S1/_a0_))**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(_a0_)**_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(S1 + _a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(S1 + _a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return log(S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return (2*_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return (2*_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar divide\n", - " return exp(_a0_/relu(_a0_))/S1\n", - " 58%|█████▊ | 865/1500 [01:00<00:43, 14.47it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S1*relu(S2)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(S2*relu(sig(sqrt(_a0_)))**S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(S2*relu(sig(sqrt(_a0_)))**S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (sqrt(_a0_) + _a0_)/(sqrt(S1)*relu(cosh(fac(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (sqrt(_a0_) + _a0_)/(sqrt(S1)*relu(cosh(fac(S1))))\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return relu(sinh(S2**S2))**_a0_\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return relu(sinh(S2**S2))**_a0_\n", - " 58%|█████▊ | 867/1500 [01:00<00:45, 14.01it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(tan(S2)/S1)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(_a0_/S2)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(_a0_/S2)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(cos(S1))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(_a0_**S2)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(_a0_**S2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(_a0_**S2)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(_a0_**S2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(_a0_**S2)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(_a0_**S2)**_a0_\n", - " 58%|█████▊ | 869/1500 [01:00<00:44, 14.18it/s]:2: RuntimeWarning: divide by zero encountered in log\n", - " return relu(log(-_a0_*relu(S2*_a0_)/relu(relu(S1))))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return relu(log(-_a0_*relu(S2*_a0_)/relu(relu(S1))))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return relu(log(-_a0_*relu(S2*_a0_)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return tan(sinh(S1))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sqrt(sig(log(log(S2)))/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sqrt(sig(log(log(S2)))/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sqrt(sig(log(log(S2)))/relu(S1))\n", - " 58%|█████▊ | 871/1500 [01:00<00:42, 14.74it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-_a0_*relu(S1**S2)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_**S2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_**S2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return cos(sinh(S1))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(_a0_**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(_a0_**_a0_)\n", - " 58%|█████▊ | 873/1500 [01:00<00:43, 14.42it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-_a0_*exp(S2)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(S1*_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(S1*_a0_)**_a0_\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(sinh(S1))**(S2**S1)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(sinh(S1))**(S2**S1)\n", - " 58%|█████▊ | 875/1500 [01:00<00:43, 14.40it/s]:2: RuntimeWarning: divide by zero encountered in log\n", - " return relu(log(-_a0_*relu(_a0_)/relu(relu(S1))))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return relu(log(-_a0_*relu(_a0_)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-_a0_*relu(S2**2)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(sig(log(S2**2))/sin(S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(sig(log(S2**2))/sin(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(relu(exp(cos(S1 + exp(log(_a0_)/_a0_)))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(relu(exp(cos(S1 + exp(log(_a0_)/_a0_)))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (_a0_ + sqrt(S1 + _a0_))/(sqrt(S1)*relu(cosh(fac(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (_a0_ + sqrt(S1 + _a0_))/(sqrt(S1)*relu(cosh(fac(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (_a0_ + sqrt(S1 + _a0_))/(sqrt(S1)*relu(cosh(fac(S1))))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(sinh(S1)**(S1**S2))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(sinh(S1)**(S1**S2))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(sinh(S1)**(S1**S2))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S1*_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S1*_a0_)**_a0_\n", - " 58%|█████▊ | 877/1500 [01:01<00:43, 14.21it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-_a0_**2/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-_a0_**2/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(tan(_a0_))**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(tan(_a0_))**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(tan(_a0_))**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return tan(sinh(S1))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return relu(log(-_a0_*relu(tan(S1))/relu(relu(S1))))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return relu(log(-_a0_*relu(tan(S1))/relu(relu(S1))))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return relu(log(-_a0_*relu(tan(S1))/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return tan(S1)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sin(S1))**_a0_\n", - " 59%|█████▊ | 879/1500 [01:01<00:44, 13.88it/s]:2: RuntimeWarning: overflow encountered in power\n", - " return S1**(S1**S2)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return S1**(S1**S2)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(tan(S2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(tan(S2))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-_a0_**2)*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-_a0_**2)*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-_a0_**2)*exp(-S1)\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(_a0_)**_a0_\n", - " 59%|█████▊ | 881/1500 [01:01<00:45, 13.55it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(_a0_*exp(S2))*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return -_a0_**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return -_a0_**_a0_\n", - " 59%|█████▉ | 883/1500 [01:01<00:45, 13.47it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(relu(S2)/sin(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(relu(S2)/sin(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(relu(S2)/sin(S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return log(S1)**_a0_\n", - " 59%|█████▉ | 885/1500 [01:01<00:45, 13.48it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-_a0_**2/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-_a0_**2/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return cos(S2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return cos(S2)**_a0_\n", - " 59%|█████▉ | 887/1500 [01:01<00:45, 13.49it/s]:2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(log(-_a0_**_a0_*relu(S2)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(log(-_a0_**_a0_*relu(S2)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(log(-_a0_**_a0_*relu(S2)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(tan(S2))**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(tan(S2))**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(tan(S2))**_a0_)\n", - " 59%|█████▉ | 889/1500 [01:01<00:43, 14.10it/s]:2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(log(S1))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(log(S1))**_a0_))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return sinh(S1)**(S2**S2)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return sinh(S1)**(S2**S2)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(relu(S2)/(S2 + _a0_))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return sinh(S1)**(S2**S1)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return sinh(S1)**(S2**S1)\n", - " 59%|█████▉ | 891/1500 [01:02<00:45, 13.49it/s]:2: RuntimeWarning: divide by zero encountered in log\n", - " return log(relu(S1/_a0_)/S1)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(sinh(cos(S1)))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(sinh(cos(S1)))**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(S2*_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(S2*_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(tan(_a0_))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(tan(_a0_))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(tan(_a0_))**_a0_\n", - " 60%|█████▉ | 893/1500 [01:02<00:45, 13.28it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return relu(_a0_**S1)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(_a0_**S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(_a0_**S1)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(_a0_**S1)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-_a0_*relu(S2)/relu(relu(_a0_))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-_a0_*relu(S2)/relu(relu(_a0_))))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(sinh(_a0_))**_a0_\n", - " 60%|█████▉ | 895/1500 [01:02<00:44, 13.50it/s]:2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(S1/_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(S1/_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(S1/_a0_)**_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(S2 + _a0_))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(S2 + _a0_))**_a0_\n", - " 60%|█████▉ | 897/1500 [01:02<00:43, 13.73it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(S2*_a0_)/_a0_**2\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(sinh(_a0_))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(_a0_/S1)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(_a0_/S1)**_a0_))\n", - " 60%|█████▉ | 899/1500 [01:02<00:43, 13.83it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return log(S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(exp(cos(S1 + exp(_a0_**(2*S1)/_a0_)))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(exp(cos(S1 + exp(_a0_**(2*S1)/_a0_)))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(exp(cos(S1 + exp(_a0_**(2*S1)/_a0_)))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (sqrt(_a0_) + _a0_)/(sqrt(S1)*relu(cosh(fac(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return -_a0_**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return -_a0_**_a0_\n", - " 60%|██████ | 901/1500 [01:02<00:44, 13.58it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-_a0_*relu(S2)/relu(S2 + _a0_)))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-_a0_*relu(S2)/relu(S2 + _a0_)))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-_a0_*relu(S2)/relu(S2 + _a0_)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-2*S2*relu(S2)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-2*S2*relu(S2)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-2*S2*relu(S2)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(S1/_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(S1/_a0_)**_a0_\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return sinh(S2**S1)**_a0_\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return sinh(S2**S1)**_a0_\n", - " 60%|██████ | 903/1500 [01:03<00:43, 13.65it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-_a0_*relu(S2)/relu(relu(_a0_/S1))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-_a0_*relu(S2)/relu(relu(_a0_/S1))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-_a0_*relu(S2)/relu(relu(_a0_/S1))))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu(exp(cos(S1 + exp(_a0_**_a0_/_a0_)))))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu(exp(cos(S1 + exp(_a0_**_a0_/_a0_)))))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu(exp(cos(S1 + exp(_a0_**_a0_/_a0_)))))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return relu(log(-_a0_*relu(S2 + _a0_)/relu(relu(S1))))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return relu(log(-_a0_*relu(S2 + _a0_)/relu(relu(S1))))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return relu(log(-_a0_*relu(S2 + _a0_)/relu(relu(S1))))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return (S2/_a0_ + sin((3*S1 + S2)**(S2**S1)))*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in sin\n", - " return (S2/_a0_ + sin((3*S1 + S2)**(S2**S1)))*exp(-S1)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return (S2/_a0_ + sin((3*S1 + S2)**(S2**S1)))*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in sin\n", - " return (S2/_a0_ + sin((3*S1 + S2)**(S2**S1)))*exp(-S1)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return (S2/_a0_ + sin((3*S1 + S2)**(S2**S1)))*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in sin\n", - " return (S2/_a0_ + sin((3*S1 + S2)**(S2**S1)))*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(S2/_a0_)/sqrt(-_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(S2/_a0_)/sqrt(-_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(S2/_a0_)/sqrt(-_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(_a0_**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(_a0_**_a0_)\n", - " 60%|██████ | 905/1500 [01:03<00:42, 13.94it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-relu(S2)*cos(_a0_)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-relu(S2)*cos(_a0_)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-relu(S2)*cos(_a0_)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (-relu(relu(S2/_a0_))/S1)**sig(relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (-relu(relu(S2/_a0_))/S1)**sig(relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(tanh(_a0_*relu(S2)/relu(relu(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(tanh(_a0_*relu(S2)/relu(relu(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(S2/cos(S2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(S2/cos(S2))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(S2*_a0_)/sinh(S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(S1 + _a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(S1 + _a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return _a0_**(sqrt(S2))/(sqrt(S1)*relu(cosh(fac(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return _a0_**(sqrt(S2))/(sqrt(S1)*relu(cosh(fac(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_/S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_/S1)**_a0_\n", - " 60%|██████ | 907/1500 [01:03<00:41, 14.16it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-_a0_*relu(S2)/relu(_a0_)))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-_a0_*relu(S2)/relu(_a0_)))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-_a0_*relu(S2)/relu(_a0_)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sqrt(sig(log(S2*tan(S2)))/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sqrt(sig(log(S2*tan(S2)))/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sqrt(sig(log(S2*tan(S2)))/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return (2*_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return (2*_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2**3*_a0_/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_/S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_/S1)**_a0_\n", - " 61%|██████ | 909/1500 [01:03<00:42, 13.96it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(S2/_a0_)/sqrt(S1*tan(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(S2/_a0_)/sqrt(S1*tan(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(S2/_a0_)/sqrt(S1*tan(S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(tan(S1))**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (_a0_ + sqrt(S1*_a0_))/(sqrt(S1)*relu(cosh(fac(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (_a0_ + sqrt(S1*_a0_))/(sqrt(S1)*relu(cosh(fac(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (_a0_ + sqrt(S1*_a0_))/(sqrt(S1)*relu(cosh(fac(S1))))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(_a0_)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(_a0_)**_a0_))\n", - " 61%|██████ | 911/1500 [01:03<00:44, 13.22it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return sin(S1)**_a0_\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(sinh(S1))**(S2**S1)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(sinh(S1))**(S2**S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-relu(S2)*tanh(S2)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-relu(S2)*tanh(S2)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-relu(S2)*tanh(S2)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(exp(cos(S1 + sqrt(S2**2/_a0_)))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(exp(cos(S1 + sqrt(S2**2/_a0_)))))\n", - " 61%|██████ | 913/1500 [01:03<00:43, 13.51it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return relu(relu(S2*relu(sig(log(_a0_)))**S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(relu(S2*relu(sig(log(_a0_)))**S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(relu(S2*relu(sig(log(_a0_)))**S1))\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return relu(sinh(S1**S2))**_a0_\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return relu(sinh(S1**S2))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S1**_a0_*relu(S2)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S1**_a0_*relu(S2)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S1**_a0_*relu(S2)/relu(relu(S1))))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(log(_a0_)/S1)\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(log(_a0_)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(exp(cos(_a0_**S1 + exp(S2**2/_a0_)))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(exp(cos(_a0_**S1 + exp(S2**2/_a0_)))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(exp(cos(_a0_**S1 + exp(S2**2/_a0_)))))\n", - " 61%|██████ | 915/1500 [01:03<00:44, 13.24it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-relu(S2)*sin(S1)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-relu(S2)*sin(S1)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-relu(S2)*sin(S1)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu((S1 + _a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu((S1 + _a0_)**_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-_a0_*relu(S2)/relu(S2*_a0_)))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-_a0_*relu(S2)/relu(S2*_a0_)))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-_a0_*relu(S2)/relu(S2*_a0_)))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (sqrt(_a0_) + _a0_)/(sqrt(S1)*relu(cosh(fac(S1))))\n", - " 61%|██████ | 917/1500 [01:04<00:43, 13.26it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return relu(log(-_a0_**S1*relu(S2)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(log(-_a0_**S1*relu(S2)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(log(-_a0_**S1*relu(S2)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(_a0_/S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(_a0_/S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu((_a0_/S1)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu((_a0_/S1)**_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(S1/_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(S1/_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2**2*relu(S2)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2**2*relu(S2)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2**2*relu(S2)/relu(relu(S1))))\n", - ":2: RuntimeWarning: overflow encountered in cosh\n", - " return (sqrt(S2) + _a0_)/(sqrt(S1)*relu(cosh(fac(fac(S2)))))\n", - ":2: RuntimeWarning: overflow encountered in cosh\n", - " return (sqrt(S2) + _a0_)/(sqrt(S1)*relu(cosh(fac(fac(S2)))))\n", - ":2: RuntimeWarning: overflow encountered in cosh\n", - " return (sqrt(S2) + _a0_)/(sqrt(S1)*relu(cosh(fac(fac(S2)))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return cos(sinh(S1))**_a0_\n", - " 61%|██████▏ | 919/1500 [01:04<00:46, 12.38it/s]:2: RuntimeWarning: overflow encountered in exp\n", - " return relu(relu(exp(relu(S1 + exp(S2**2/_a0_)))))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu((_a0_**3)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu((_a0_**3)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu((_a0_**3)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(_a0_/S2)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(_a0_/S2)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(_a0_/S2)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(cos(S2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(cos(S2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(relu(relu(S2))/(S1 + _a0_))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(relu((sinh(S1)**3)**cosh(S1)))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(relu((sinh(S1)**3)**cosh(S1)))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(relu((sinh(S1)**3)**cosh(S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(_a0_)**_a0_\n", - " 61%|██████▏ | 921/1500 [01:04<00:45, 12.86it/s]:2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu((_a0_**3)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu((_a0_**3)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(_a0_**_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(_a0_**_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-_a0_*log(S2)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-_a0_*log(S2)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(relu(relu(sig(_a0_))**S1*log(_a0_)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(relu(relu(sig(_a0_))**S1*log(_a0_)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(relu(relu(sig(_a0_))**S1*log(_a0_)))\n", - " 62%|██████▏ | 923/1500 [01:04<00:43, 13.36it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-_a0_*relu(S2)/relu(_a0_)))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-_a0_*relu(S2)/relu(_a0_)))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(relu(S2 + _a0_)/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(S2*_a0_/S1)*exp(-S1)\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return sqrt(sig(log(S2**2))/relu(S2*_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(relu(S2*relu(log(_a0_))**S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_**S2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_**S2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu((_a0_**3/S2**3)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu((_a0_**3/S2**3)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu((_a0_**3/S2**3)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu((_a0_/S2)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu((_a0_/S2)**_a0_)\n", - " 62%|██████▏ | 925/1500 [01:04<00:44, 13.04it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-relu(S2)*log(S2)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-relu(S2)*log(S2)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-relu(S2)*log(S2)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S1 + _a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S1 + _a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return sinh(fac(_a0_))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return sinh(fac(_a0_))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu((_a0_/S2)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu((_a0_/S2)**_a0_)\n", - " 62%|██████▏ | 927/1500 [01:04<00:42, 13.36it/s]:2: RuntimeWarning: overflow encountered in exp\n", - " return relu(relu(exp(cos(S1 + exp(S2**2/S1**3)))))\n", - ":2: RuntimeWarning: invalid value encountered in cos\n", - " return relu(relu(exp(cos(S1 + exp(S2**2/S1**3)))))\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(relu(exp(cos(S1 + exp(S2**2/S1**3)))))\n", - ":2: RuntimeWarning: invalid value encountered in cos\n", - " return relu(relu(exp(cos(S1 + exp(S2**2/S1**3)))))\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(relu(exp(cos(S1 + exp(S2**2/S1**3)))))\n", - ":2: RuntimeWarning: invalid value encountered in cos\n", - " return relu(relu(exp(cos(S1 + exp(S2**2/S1**3)))))\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return relu(relu((sinh(S1**S1)**3)**_a0_))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(relu((sinh(S1**S1)**3)**_a0_))\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return relu(relu((sinh(S1**S1)**3)**_a0_))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(relu((sinh(S1**S1)**3)**_a0_))\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return relu(relu((sinh(S1**S1)**3)**_a0_))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(relu((sinh(S1**S1)**3)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-_a0_*relu(S2)/relu(relu(S2*_a0_))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-_a0_*relu(S2)/relu(relu(S2*_a0_))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-_a0_*relu(S2)/relu(relu(S2*_a0_))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(S2/_a0_)/sqrt(-S2))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(S2/_a0_)/sqrt(-S2))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(S2/_a0_)/sqrt(-S2))\n", - " 62%|██████▏ | 929/1500 [01:05<00:45, 12.63it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(cos(_a0_*relu(S2)/relu(relu(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(cos(_a0_*relu(S2)/relu(relu(S1)))))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(S2)*sig(sig(S2**(cosh(S2)**2)))**(S1*_a0_)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(S2)*sig(sig(S2**(cosh(S2)**2)))**(S1*_a0_)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(S2)*sig(sig(S2**(cosh(S2)**2)))**(S1*_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return relu(log(-_a0_*relu(sin(S1))/relu(relu(S1))))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return relu(log(-_a0_*relu(sin(S1))/relu(relu(S1))))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return relu(log(-_a0_*relu(sin(S1))/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(tanh(log(S2**2))/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(tanh(log(S2**2))/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return _a0_**((1/2)*_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return _a0_**((1/2)*_a0_)\n", - " 62%|██████▏ | 931/1500 [01:05<00:43, 12.95it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return relu(log(-(_a0_*relu(S2))**relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(log(-(_a0_*relu(S2))**relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return cos(sqrt(S2*_a0_)*exp(-S1))\n", - " 62%|██████▏ | 933/1500 [01:05<00:41, 13.63it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-_a0_*relu(S2)/relu(relu(_a0_))))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return (sinh(S1)**2)**(S2**S1)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return (sinh(S1)**2)**(S2**S1)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return (sinh(S1)**2)**(S2**S1)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(relu((sinh(S1)**3)**sinh(S1)))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(relu((sinh(S1)**3)**sinh(S1)))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(relu((sinh(S1)**3)**sinh(S1)))\n", - " 62%|██████▏ | 935/1500 [01:05<01:01, 9.25it/s]:2: RuntimeWarning: divide by zero encountered in log\n", - " return relu(log(fac(_a0_*relu(S2)/relu(relu(S1)))))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return relu(log(fac(_a0_*relu(S2)/relu(relu(S1)))))\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(relu(exp(cos(S1 + exp(S1**(-_a0_)*S2**2)))))\n", - ":2: RuntimeWarning: invalid value encountered in cos\n", - " return relu(relu(exp(cos(S1 + exp(S1**(-_a0_)*S2**2)))))\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(relu(exp(cos(S1 + exp(S1**(-_a0_)*S2**2)))))\n", - ":2: RuntimeWarning: invalid value encountered in cos\n", - " return relu(relu(exp(cos(S1 + exp(S1**(-_a0_)*S2**2)))))\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(relu(exp(cos(S1 + exp(S1**(-_a0_)*S2**2)))))\n", - ":2: RuntimeWarning: invalid value encountered in cos\n", - " return relu(relu(exp(cos(S1 + exp(S1**(-_a0_)*S2**2)))))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu((_a0_**3)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu((_a0_**3)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(S2*_a0_)/(S1 + _a0_)\n", - " 62%|██████▏ | 937/1500 [01:05<00:56, 9.94it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(S2/_a0_)/sqrt(-S2*_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(S2/_a0_)/sqrt(-S2*_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(S2/_a0_)/sqrt(-S2*_a0_))\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return (sinh(S2**S2)**2)**_a0_\n", - ":2: RuntimeWarning: overflow encountered in square\n", - " return (sinh(S2**S2)**2)**_a0_\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return (sinh(S2**S2)**2)**_a0_\n", - ":2: RuntimeWarning: overflow encountered in square\n", - " return (sinh(S2**S2)**2)**_a0_\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return (sinh(S2**S2)**2)**_a0_\n", - ":2: RuntimeWarning: overflow encountered in square\n", - " return (sinh(S2**S2)**2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return log(S2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return log(S2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(sin(relu(S2))/relu(S1*_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(sin(relu(S2))/relu(S1*_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(S2/_a0_)/sqrt(S2*log(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(S2/_a0_)/sqrt(S2*log(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(S2/_a0_)/sqrt(S2*log(S1)))\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(relu(exp(abs(S1 + exp(S2**2/_a0_)))))\n", - " 63%|██████▎ | 939/1500 [01:06<00:54, 10.36it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(cos(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(cos(S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(sqrt(sin(log(S2**2))/relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(sqrt(sin(log(S2**2))/relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return (2*_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return (2*_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(_a0_**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(_a0_**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(((S1 + _a0_)**3)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(((S1 + _a0_)**3)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(((S1 + _a0_)**3)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-_a0_*relu(S2)*relu(relu(S1))))\n", - " 63%|██████▎ | 941/1500 [01:06<00:50, 11.08it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-relu(S2)*sig(_a0_)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-relu(S2)*sig(_a0_)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-relu(S2)*sig(_a0_)/relu(relu(S1))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return log(relu(relu(S2))/relu(S1 + _a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(tan(S1)**_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in scalar divide\n", - " return exp(-_a0_/relu(sin(_a0_)))/S1\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (sqrt(S2) + _a0_)/(sqrt(-S2)*relu(cosh(fac(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (sqrt(S2) + _a0_)/(sqrt(-S2)*relu(cosh(fac(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (sqrt(S2) + _a0_)/(sqrt(-S2)*relu(cosh(fac(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(_a0_/S2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(_a0_/S2)**_a0_\n", - " 63%|██████▎ | 943/1500 [01:06<00:49, 11.16it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(sqrt(sig(log(S2**2))/(S2 + _a0_)))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(tan(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(tan(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(relu(log(cos(S1 + exp(S2**2/_a0_)))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(relu(log(cos(S1 + exp(S2**2/_a0_)))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(tan(S1)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return (log(_a0_)**2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return (log(_a0_)**2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return (log(_a0_)**2)**_a0_\n", - " 63%|██████▎ | 945/1500 [01:06<00:47, 11.72it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-relu(S2)*tan(S2)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-relu(S2)*tan(S2)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-relu(S2)*tan(S2)/relu(relu(S1))))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(relu(_a0_)/relu(S1 + _a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(relu(_a0_)/relu(S1 + _a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(relu(_a0_)/relu(S1 + _a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S1*relu(S2)/relu(relu(S1))))\n", - " 63%|██████▎ | 947/1500 [01:06<00:46, 12.00it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-_a0_*relu(S2)/relu(S2/_a0_)))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-_a0_*relu(S2)/relu(S2/_a0_)))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-_a0_*relu(S2)/relu(S2/_a0_)))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (-sinh(S2))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (-sinh(S2))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (-sinh(S2))**_a0_\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(relu(exp(cos(S1 + exp(S1**_a0_/_a0_)))))\n", - ":2: RuntimeWarning: invalid value encountered in cos\n", - " return relu(relu(exp(cos(S1 + exp(S1**_a0_/_a0_)))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/relu(S1 + _a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-relu(S2)/relu(S1 + _a0_))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (_a0_ + sqrt(tan(S1)))/(sqrt(S1)*relu(cosh(fac(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (_a0_ + sqrt(tan(S1)))/(sqrt(S1)*relu(cosh(fac(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (_a0_ + sqrt(tan(S1)))/(sqrt(S1)*relu(cosh(fac(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - " 63%|██████▎ | 949/1500 [01:06<00:45, 12.20it/s]:2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu(S2*relu(_a0_**_a0_)**S1))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu(S2*relu(_a0_**_a0_)**S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(log(S1))**_a0_\n", - " 63%|██████▎ | 951/1500 [01:06<00:43, 12.65it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (sqrt(S2) + _a0_)/(sqrt(_a0_)*relu(cosh(fac(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(S2*_a0_)/fac(S1)\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-relu(S2)/(_a0_*relu(relu(sin(_a0_))))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-relu(S2)/(_a0_*relu(relu(sin(_a0_))))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-relu(S2)/(_a0_*relu(relu(sin(_a0_))))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return log(relu(relu(S1))/relu(S1 + _a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return (sqrt(S2) + _a0_)/(sqrt(S1)*relu(log(fac(S1))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return (sqrt(S2) + _a0_)/(sqrt(S1)*relu(log(fac(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2 + _a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2 + _a0_)**_a0_\n", - " 64%|██████▎ | 953/1500 [01:07<00:41, 13.30it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return sqrt(sig(log(sin(S1)))/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sqrt(sig(log(sin(S1)))/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sqrt(sig(log(sin(S1)))/relu(S1))\n", - ":2: RuntimeWarning: overflow encountered in cosh\n", - " return (sqrt(S2) + _a0_)/(sqrt(S1)*relu(cosh(fac(S1 + S2))))\n", - ":2: RuntimeWarning: overflow encountered in cosh\n", - " return (sqrt(S2) + _a0_)/(sqrt(S1)*relu(cosh(fac(S1 + S2))))\n", - ":2: RuntimeWarning: overflow encountered in cosh\n", - " return (sqrt(S2) + _a0_)/(sqrt(S1)*relu(cosh(fac(S1 + S2))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-(_a0_ + relu(S2))/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-(_a0_ + relu(S2))/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (-S1**2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (-S1**2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (-S1**2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(_a0_**3)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(_a0_**3)**_a0_)\n", - " 64%|██████▎ | 955/1500 [01:07<00:40, 13.31it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(sqrt(log(S2**2))/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(sqrt(log(S2**2))/relu(S1))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(relu((sinh(S1)**2)**(S2**S2)))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(relu((sinh(S1)**2)**(S2**S2)))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(relu((sinh(S1)**2)**(S2**S2)))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-S2/(_a0_*relu(_a0_))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-S2/(_a0_*relu(_a0_))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-S2/(_a0_*relu(_a0_))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(cos(S1)**_a0_)\n", - " 64%|██████▍ | 957/1500 [01:07<00:41, 13.12it/s]:2: RuntimeWarning: divide by zero encountered in log\n", - " return relu(log(relu(relu(S2*_a0_))/relu(S1 + _a0_)))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return relu(log(relu(relu(S2*_a0_))/relu(S1 + _a0_)))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return relu(log(relu(relu(S2*_a0_))/relu(S1 + _a0_)))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(S2/_a0_)/sqrt(-_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(S2/_a0_)/sqrt(-_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(sin(log(S2**2))/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(sin(log(S2**2))/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return tan(S1**2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(relu((sinh(S1)**2)**log(_a0_)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(relu((sinh(S1)**2)**log(_a0_)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(relu((sinh(S1)**2)**log(_a0_)))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-S2/(_a0_*relu(S2 + _a0_))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-S2/(_a0_*relu(S2 + _a0_))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-S2/(_a0_*relu(S2 + _a0_))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(relu(relu(S2))/relu(2*_a0_)))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(relu(relu(S2))/relu(2*_a0_)))\n", - " 64%|██████▍ | 959/1500 [01:07<00:41, 12.88it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-relu(S2)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-relu(S2)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-relu(S2)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S1/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S1/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S1/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(_a0_**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(_a0_**_a0_)\n", - " 64%|██████▍ | 961/1500 [01:07<00:42, 12.58it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(relu(relu(S2))/relu(S1 + log(S1))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(relu(relu(S2))/relu(S1 + log(S1))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(relu(relu(S2))/relu(S1 + log(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-abs(_a0_)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-abs(_a0_)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-abs(_a0_)/relu(relu(S1))))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return (S1**2)**(S2**S1)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return (S1**2)**(S2**S1)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return (S1**2)**(S2**S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return cos(S1)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return log(S2/log(_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return log(S2/log(_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2/(_a0_*relu(relu(S2)))))\n", - ":2: RuntimeWarning: invalid value encountered in divide\n", - " return (relu(relu(S2/_a0_))/relu(S1 + _a0_))**sig(relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return log(S1**2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return log(S1**2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu((S1 + _a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu((S1 + _a0_)**_a0_)\n", - " 64%|██████▍ | 963/1500 [01:07<00:43, 12.29it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-(S2 + _a0_)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-(S2 + _a0_)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-sig(log(S2**2))/S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-sig(log(S2**2))/S1)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(_a0_**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(_a0_**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(exp(cos(S1 + exp(_a0_**(-S2)*relu(S2)**2)))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(exp(cos(S1 + exp(_a0_**(-S2)*relu(S2)**2)))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(exp(cos(S1 + exp(_a0_**(-S2)*relu(S2)**2)))))\n", - " 64%|██████▍ | 965/1500 [01:08<00:43, 12.39it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return relu(log(-(S2/_a0_)**relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(log(-(S2/_a0_)**relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_**_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_**_a0_)**_a0_\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(relu(exp(tan(S1 + exp(relu(S2)**2/_a0_)))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S1/(_a0_*relu(relu(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return ((sqrt(S2) + _a0_)/(sqrt(S1)*relu(cosh(fac(S1)))))**S2\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(_a0_**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(_a0_**_a0_)\n", - " 64%|██████▍ | 967/1500 [01:08<00:41, 12.84it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-S2/(relu(_a0_)*relu(relu(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2/(relu(_a0_)*relu(relu(S1)))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-S2/(relu(_a0_)*relu(relu(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2/(relu(_a0_)*relu(relu(S1)))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-S2/(relu(_a0_)*relu(relu(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2/(relu(_a0_)*relu(relu(S1)))))\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return sinh(S2**S1)**_a0_\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return sinh(S2**S1)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return exp(-_a0_/relu(log(S1)))/S1\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return exp(-_a0_/relu(log(S1)))/S1\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return exp(-_a0_/relu(log(S1)))/S1\n", - " 65%|██████▍ | 969/1500 [01:08<00:43, 12.33it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(S2/sin(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(S2/sin(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(log(S2/(_a0_*relu(relu(S1))))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(log(S2/(_a0_*relu(relu(S1))))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(S2/_a0_)/sqrt(S2*tan(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(S2/_a0_)/sqrt(S2*tan(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (sqrt(S2) + _a0_)/(relu(cosh(fac(S1)))*sqrt(tanh(_a0_)))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (sqrt(S2) + _a0_)/(relu(cosh(fac(S1)))*sqrt(tanh(_a0_)))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (sqrt(S2) + _a0_)/(relu(cosh(fac(S1)))*sqrt(tanh(_a0_)))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu(S2*relu(sig(_a0_**_a0_))**S1))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu(S2*relu(sig(_a0_**_a0_))**S1))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu(S2*relu(sig(_a0_**_a0_))**S1))\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return sinh(S2**2/_a0_**2)**_a0_\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return sinh(S2**2/_a0_**2)**_a0_\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return sinh(S2**2/_a0_**2)**_a0_\n", - " 65%|██████▍ | 971/1500 [01:08<00:44, 11.83it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(relu(S2)/relu(log(_a0_))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(relu(S2)/relu(log(_a0_))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(relu(S2)/relu(log(_a0_))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2/(_a0_*relu(S2))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*log(sig(_a0_))**S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*log(sig(_a0_))**S1))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(tanh(_a0_))**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(tanh(_a0_))**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(2*_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(2*_a0_)**_a0_)\n", - " 65%|██████▍ | 973/1500 [01:08<00:42, 12.34it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_ + _a0_**S1)/(sqrt(S1)*relu(cosh(fac(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_ + _a0_**S1)/(sqrt(S1)*relu(cosh(fac(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_ + _a0_**S1)/(sqrt(S1)*relu(cosh(fac(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-_a0_)*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-_a0_)*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return log(S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return log(S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(S2/_a0_)/sqrt(S1*tan(S2)))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(S2/_a0_)/sqrt(S1*tan(S2)))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(S2/_a0_)/sqrt(S1*tan(S2)))\n", - " 65%|██████▌ | 975/1500 [01:08<00:39, 13.17it/s]:2: RuntimeWarning: overflow encountered in sinh\n", - " return sinh(sinh(S1)**2)**_a0_\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return sinh(sinh(S1)**2)**_a0_\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return sinh(sinh(S1)**2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(log(-(S2/_a0_)**relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_**S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_**S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(S2*_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(S2*_a0_)**_a0_)\n", - " 65%|██████▌ | 977/1500 [01:08<00:40, 12.83it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-1/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-1/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(_a0_**S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(_a0_**S1)**_a0_\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return S1**(S2**S2)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return S1**(S2**S2)\n", - " 65%|██████▌ | 979/1500 [01:09<00:44, 11.65it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2/(S1*relu(relu(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2/(S1*relu(relu(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sqrt(sig(log(S2*(S2 + _a0_)))/relu(S1))\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(relu(exp(cos(S1 + exp(_a0_*relu(S2**S2)**2)))))\n", - ":2: RuntimeWarning: invalid value encountered in cos\n", - " return relu(relu(exp(cos(S1 + exp(_a0_*relu(S2**S2)**2)))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu((_a0_**(2*S2))**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu((_a0_**(2*S2))**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu((_a0_**(2*S2))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(relu(log(_a0_))/relu(S1))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(relu(log(_a0_))/relu(S1))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(relu(log(_a0_))/relu(S1))\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return (sqrt(S2) + _a0_)/(sqrt(S1)*sinh(cosh(fac(S1))))\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return (sqrt(S2) + _a0_)/(sqrt(S1)*sinh(cosh(fac(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return log(S1**2)**_a0_\n", - " 66%|██████▌ | 983/1500 [01:09<00:41, 12.41it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2/(relu(relu(S1))*tan(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2/(relu(relu(S1))*tan(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2/(relu(relu(S1))*tan(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2/_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2/_a0_)**_a0_\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return sinh(S1**S1)**_a0_\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return sinh(S1**S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-sig(_a0_)/relu(S1))/S1\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-sig(_a0_)/relu(S1))/S1\n", - " 66%|██████▌ | 985/1500 [01:09<00:40, 12.60it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return relu(log(-(S2/_a0_)**relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(_a0_**3)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(_a0_**3)**_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-S2/(_a0_*relu(_a0_))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-S2/(_a0_*relu(_a0_))))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(relu(log(S2))/relu(S1))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(relu(log(S2))/relu(S1))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(relu(log(S2))/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(S1)**(_a0_**S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(S1)**(_a0_**S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(S1)**(_a0_**S1))\n", - " 66%|██████▌ | 987/1500 [01:09<00:46, 11.11it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*relu(_a0_**S2)**S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*relu(_a0_**S2)**S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*relu(_a0_**S2)**S1))\n", - ":2: RuntimeWarning: overflow encountered in cosh\n", - " return (sqrt(S2) + _a0_)/(sqrt(S1)*relu(cosh(S1**S2)))\n", - ":2: RuntimeWarning: overflow encountered in cosh\n", - " return (sqrt(S2) + _a0_)/(sqrt(S1)*relu(cosh(S1**S2)))\n", - ":2: RuntimeWarning: overflow encountered in cosh\n", - " return (sqrt(S2) + _a0_)/(sqrt(S1)*relu(cosh(S1**S2)))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return sqrt(sig(log(S2*relu(S2)))/relu(cos(S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return sqrt(sig(log(S2*relu(S2)))/relu(cos(S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return sqrt(sig(log(S2*relu(S2)))/relu(cos(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(sin(S2))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(sin(S2))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-sig(_a0_)/relu(S1))/S1\n", - " 66%|██████▌ | 989/1500 [01:10<00:44, 11.41it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S1/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S1/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-abs(S1)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-abs(S1)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-abs(S1)/relu(relu(S1))))\n", - " 66%|██████▌ | 991/1500 [01:10<00:43, 11.69it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-S2/(_a0_*relu(S2*_a0_))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-S2/(_a0_*relu(S2*_a0_))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-S2/(_a0_*relu(S2*_a0_))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2*_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2*_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sin(S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return _a0_**(-_a0_)*exp(-sig(_a0_)/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return _a0_**(-_a0_)*exp(-sig(_a0_)/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return _a0_**(-_a0_)*exp(-sig(_a0_)/relu(S1))\n", - " 66%|██████▌ | 993/1500 [01:10<00:42, 12.06it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", - " return (relu(relu(S2/_a0_))/relu(log(S2)))**sig(relu(S1))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return (relu(relu(S2/_a0_))/relu(log(S2)))**sig(relu(S1))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return (relu(relu(S2/_a0_))/relu(log(S2)))**sig(relu(S1))\n", - " 66%|██████▋ | 995/1500 [01:10<00:40, 12.54it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_**S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_**S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-log(S2*relu(S2))/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-log(S2*relu(S2))/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(log(S1)**_a0_)\n", - " 67%|██████▋ | 999/1500 [01:10<00:42, 11.81it/s]:2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2/(relu(relu(S1))*cos(_a0_))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2/(relu(relu(S1))*cos(_a0_))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2/(relu(relu(S1))*cos(_a0_))))\n", - ":2: RuntimeWarning: invalid value encountered in divide\n", - " return (relu(relu(S2/_a0_))/relu(S2*_a0_))**sig(relu(S1))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return sqrt(S2)*_a0_/(sqrt(S1)*relu(cos(fac(S1))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return sqrt(S2)*_a0_/(sqrt(S1)*relu(cos(fac(S1))))\n", - " 67%|██████▋ | 1001/1500 [01:11<00:42, 11.84it/s]:2: RuntimeWarning: overflow encountered in cosh\n", - " return sqrt(S2)*_a0_/(sqrt(S1)*relu(cosh(fac(sinh(S2)))))\n", - ":2: RuntimeWarning: overflow encountered in cosh\n", - " return sqrt(S2)*_a0_/(sqrt(S1)*relu(cosh(fac(sinh(S2)))))\n", - ":2: RuntimeWarning: overflow encountered in cosh\n", - " return sqrt(S2)*_a0_/(sqrt(S1)*relu(cosh(fac(sinh(S2)))))\n", - " 67%|██████▋ | 1003/1500 [01:11<00:41, 12.08it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(tan(S2)/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(tan(S2)/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sqrt(sig(log(relu(S2)*cos(S2)))/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sqrt(sig(log(relu(S2)*cos(S2)))/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sqrt(sig(log(relu(S2)*cos(S2)))/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(log(S2)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(log(S2)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(log(S1))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(log(S1))**_a0_\n", - " 67%|██████▋ | 1005/1500 [01:11<00:40, 12.25it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", - " return log(relu(S2)/relu(cos(S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return log(relu(S2)/relu(cos(S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return log(relu(S2)/relu(cos(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sin(S1)**_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in scalar divide\n", - " return exp(-sig(_a0_)/relu(_a0_))/S1\n", - ":2: RuntimeWarning: divide by zero encountered in scalar divide\n", - " return exp(-sig(_a0_)/relu(_a0_))/S1\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(sin(S2/(_a0_*relu(relu(S1))))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(sin(S2/(_a0_*relu(relu(S1))))))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return (_a0_**_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return (_a0_**_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return (_a0_**_a0_)**_a0_\n", - " 67%|██████▋ | 1007/1500 [01:11<00:39, 12.48it/s]:2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(_a0_)**_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in scalar divide\n", - " return exp(-sig(_a0_)/relu(relu(_a0_)))/S1\n", - ":2: RuntimeWarning: divide by zero encountered in scalar divide\n", - " return exp(-sig(_a0_)/relu(relu(_a0_)))/S1\n", - ":2: RuntimeWarning: divide by zero encountered in scalar divide\n", - " return exp(-sig(_a0_)/relu(relu(_a0_)))/S1\n", - " 67%|██████▋ | 1009/1500 [01:11<00:37, 13.25it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-S2/(_a0_*relu(relu(S1 + _a0_)))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-S2/(_a0_*relu(relu(S1 + _a0_)))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-S2/(_a0_*relu(relu(S1 + _a0_)))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2*S2**(-S1)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2*S2**(-S1)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2*S2**(-S1)/relu(relu(S1))))\n", - ":2: RuntimeWarning: overflow encountered in cosh\n", - " return sqrt(S2)*_a0_/(sqrt(S1)*relu(cosh(fac(S1**2))))\n", - ":2: RuntimeWarning: overflow encountered in cosh\n", - " return sqrt(S2)*_a0_/(sqrt(S1)*relu(cosh(fac(S1**2))))\n", - ":2: RuntimeWarning: overflow encountered in cosh\n", - " return sqrt(S2)*_a0_/(sqrt(S1)*relu(cosh(fac(S1**2))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(S2/_a0_)*exp(-sinh(S2))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(relu(S2/_a0_)/sqrt(-S1*S2)))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(relu(S2/_a0_)/sqrt(-S1*S2)))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(relu(S2/_a0_)/sqrt(-S1*S2)))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2*_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2*_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(sin(S1))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(sin(S1))**_a0_\n", - " 67%|██████▋ | 1011/1500 [01:11<00:38, 12.68it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-S2/(_a0_*relu(relu(sin(_a0_))))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-S2/(_a0_*relu(relu(sin(_a0_))))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-S2/(_a0_*relu(relu(sin(_a0_))))))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(S2**_a0_/(S1 - S2))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(S2**_a0_/(S1 - S2))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(S2**_a0_/(S1 - S2))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return sqrt(sig(log(S2*relu(tan(S2))))/relu(S1))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return sqrt(sig(log(S2*relu(tan(S2))))/relu(S1))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return sqrt(sig(log(S2*relu(tan(S2))))/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return tan(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return tan(_a0_)**_a0_\n", - " 68%|██████▊ | 1013/1500 [01:11<00:37, 13.09it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(exp(_a0_)/_a0_)*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(relu(S2/_a0_)/sqrt(S1*cos(S2))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(relu(S2/_a0_)/sqrt(S1*cos(S2))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(relu(S2/_a0_)/sqrt(S1*cos(S2))))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return S1**((S1 + S2)**3)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return S1**((S1 + S2)**3)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return S1**((S1 + S2)**3)\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return sinh(S2**S1)**_a0_\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return sinh(S2**S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu((2*_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu((2*_a0_)**_a0_)\n", - " 68%|██████▊ | 1015/1500 [01:12<00:36, 13.17it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return S1**log(_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return (2*_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return (2*_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return exp(-sig(_a0_)/relu(S1 + _a0_))/S1\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2/(_a0_*cos(relu(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2/(_a0_*cos(relu(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*relu(_a0_**S2)**S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*relu(_a0_**S2)**S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_**S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_**S1)**_a0_\n", - " 68%|██████▊ | 1017/1500 [01:12<00:37, 12.71it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(tan(S2)/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(sig(log(S2*relu(S2)))/tan(S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(sig(log(S2*relu(S2)))/tan(S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_**S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_**S1)**_a0_\n", - " 68%|██████▊ | 1019/1500 [01:12<00:39, 12.14it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-S2/(_a0_*relu(relu(S1/_a0_)))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-S2/(_a0_*relu(relu(S1/_a0_)))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-S2/(_a0_*relu(relu(S1/_a0_)))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(relu(S2/_a0_)/sqrt(cos(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(relu(S2/_a0_)/sqrt(cos(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(relu(S2/_a0_)/sqrt(cos(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(sig(log(S2*relu(S2)))/log(S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(sig(log(S2*relu(S2)))/log(S1))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu((sinh(S1**2)**2)**(_a0_**_a0_)))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu((sinh(S1**2)**2)**(_a0_**_a0_)))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu((sinh(S1**2)**2)**(_a0_**_a0_)))\n", - " 68%|██████▊ | 1021/1500 [01:12<00:37, 12.83it/s]:2: RuntimeWarning: overflow encountered in sinh\n", - " return relu(relu((sinh(S2**(2*S1))**2)**_a0_))\n", - ":2: RuntimeWarning: overflow encountered in square\n", - " return relu(relu((sinh(S2**(2*S1))**2)**_a0_))\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return relu(relu((sinh(S2**(2*S1))**2)**_a0_))\n", - ":2: RuntimeWarning: overflow encountered in square\n", - " return relu(relu((sinh(S2**(2*S1))**2)**_a0_))\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return relu(relu((sinh(S2**(2*S1))**2)**_a0_))\n", - ":2: RuntimeWarning: overflow encountered in square\n", - " return relu(relu((sinh(S2**(2*S1))**2)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar divide\n", - " return exp(-sig(_a0_)/relu(_a0_))/S1\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2/(_a0_*relu(relu(log(_a0_))))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2/(_a0_*relu(relu(log(_a0_))))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2/(_a0_*relu(relu(log(_a0_))))))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return (2*_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return (2*_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu((sinh(_a0_**(2*S2))**2)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu((sinh(_a0_**(2*S2))**2)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu((sinh(_a0_**(2*S2))**2)**_a0_))\n", - " 68%|██████▊ | 1023/1500 [01:12<00:36, 12.96it/s]:2: RuntimeWarning: divide by zero encountered in log\n", - " return relu(log(relu(S2/_a0_)/sqrt(S1*S2)))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu((_a0_**S2)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu((_a0_**S2)**_a0_)\n", - " 68%|██████▊ | 1025/1500 [01:12<00:38, 12.36it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2**_a0_/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2**_a0_/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(log(S2))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(log(S2))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(log(S2))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return (relu(relu(S2/_a0_))/relu(log(S2)))**sig(relu(S1))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return (relu(relu(S2/_a0_))/relu(log(S2)))**sig(relu(S1))\n", - " 68%|██████▊ | 1027/1500 [01:13<00:40, 11.60it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-S2/(_a0_*relu(_a0_))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-S2/(_a0_*relu(_a0_))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(tan(log(S2*relu(S2)))/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(tan(log(S2*relu(S2)))/relu(S1))\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return relu(sinh(S1**S1)**_a0_)\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return relu(sinh(S1**S1)**_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in scalar divide\n", - " return exp(-sig(_a0_)/relu(_a0_))/S1\n", - " 69%|██████▊ | 1029/1500 [01:13<00:39, 11.94it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(tan(S2/(_a0_*relu(relu(S1))))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(tan(S2/(_a0_*relu(relu(S1))))))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return sqrt(sig(log(S2*relu(-S2)))/relu(S1))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return sqrt(sig(log(S2*relu(-S2)))/relu(S1))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return sqrt(sig(log(S2*relu(-S2)))/relu(S1))\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return relu(relu((sinh(S2**S1)**2)**_a0_))\n", - ":2: RuntimeWarning: overflow encountered in square\n", - " return relu(relu((sinh(S2**S1)**2)**_a0_))\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return relu(relu((sinh(S2**S1)**2)**_a0_))\n", - ":2: RuntimeWarning: overflow encountered in square\n", - " return relu(relu((sinh(S2**S1)**2)**_a0_))\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return relu(relu((sinh(S2**S1)**2)**_a0_))\n", - ":2: RuntimeWarning: overflow encountered in square\n", - " return relu(relu((sinh(S2**S1)**2)**_a0_))\n", - " 69%|██████▊ | 1031/1500 [01:13<00:40, 11.59it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(relu(S2/_a0_)/sqrt(log(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(relu(S2/_a0_)/sqrt(log(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(relu(S2/_a0_)/sqrt(log(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2/_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2/_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2/(_a0_*tan(relu(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2/(_a0_*tan(relu(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (-sinh(S2))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (-sinh(S2))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(_a0_)**_a0_)\n", - " 69%|██████▉ | 1033/1500 [01:13<00:38, 12.03it/s]:2: RuntimeWarning: overflow encountered in exp\n", - " return relu(relu(exp(tan(S1 + exp(_a0_*relu(S2)**2)))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(cos(S2))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(cos(S2))**_a0_\n", - " 69%|██████▉ | 1035/1500 [01:13<00:43, 10.62it/s]:2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(_a0_)**_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return log(relu(S2)/relu(relu(cos(S2))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return log(relu(S2)/relu(relu(cos(S2))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return log(relu(S2)/relu(relu(cos(S2))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(relu(log(-S2/(_a0_*relu(S2*_a0_)))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(relu(log(-S2/(_a0_*relu(S2*_a0_)))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(relu(log(-S2/(_a0_*relu(S2*_a0_)))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S1*_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S1*_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - " 69%|██████▉ | 1037/1500 [01:14<00:43, 10.72it/s]:2: RuntimeWarning: overflow encountered in exp\n", - " return relu(relu(exp(cos(S1 + exp(_a0_*exp(exp(S2)))))))\n", - ":2: RuntimeWarning: invalid value encountered in cos\n", - " return relu(relu(exp(cos(S1 + exp(_a0_*exp(exp(S2)))))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return exp(-sig(_a0_)/relu(sin(S2)))/S1\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return exp(-sig(_a0_)/relu(sin(S2)))/S1\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return exp(-sig(_a0_)/relu(sin(S2)))/S1\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(relu(log(-sqrt(S2)/relu(relu(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(relu(log(-sqrt(S2)/relu(relu(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(relu(log(-sqrt(S2)/relu(relu(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S1/_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S1/_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_**S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_**S1)**_a0_\n", - " 69%|██████▉ | 1039/1500 [01:14<00:41, 11.18it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(tan(S2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(tan(S2))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return (2*_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return (2*_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(relu(log(-S2/(_a0_*relu(S1*_a0_)))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(relu(log(-S2/(_a0_*relu(S1*_a0_)))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(relu(log(-S2/(_a0_*relu(S1*_a0_)))))\n", - " 69%|██████▉ | 1041/1500 [01:14<00:43, 10.67it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(relu(log(-S2/(_a0_*relu(relu(_a0_))))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(relu(log(-S2/(_a0_*relu(relu(_a0_))))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(S1/_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(S1/_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return tanh(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return tanh(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(relu(log(-S1/(_a0_*relu(relu(S1))))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return cos(S2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return cos(S2)**_a0_\n", - " 70%|██████▉ | 1043/1500 [01:14<00:40, 11.33it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", - " return log(relu(S2)/relu(-S1))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return log(relu(S2)/relu(-S1))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(relu(log(-S2/(_a0_*relu(_a0_)))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(relu(log(-S2/(_a0_*relu(_a0_)))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(relu(log(-S2/(_a0_*relu(_a0_)))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_/S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_/S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(relu(log(-S2/(_a0_*relu(S2)))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(S2/log(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(S2/log(S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return exp(-sqrt(_a0_)/relu(S1))/S1\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return exp(-sqrt(_a0_)/relu(S1))/S1\n", - " 70%|██████▉ | 1045/1500 [01:14<00:37, 12.29it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return relu(relu(log(-S2/relu(relu(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(relu(log(-S2/relu(relu(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(relu(log(-S2/relu(relu(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(relu(S2/_a0_)/sqrt(S2*cos(_a0_))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(relu(S2/_a0_)/sqrt(S2*cos(_a0_))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(relu(S2/_a0_)/sqrt(S2*cos(_a0_))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(tanh(log(S2*relu(S2)))/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(tanh(log(S2*relu(S2)))/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(tan(sinh(S1**2))**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(tan(sinh(S1**2))**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(relu(log(-sin(S2)/relu(relu(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(relu(log(-sin(S2)/relu(relu(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(relu(log(-sin(S2)/relu(relu(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(relu(S2/_a0_)/sqrt(cos(_a0_))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(relu(S2/_a0_)/sqrt(cos(_a0_))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(relu(S2/_a0_)/sqrt(cos(_a0_))))\n", - " 70%|██████▉ | 1047/1500 [01:14<00:36, 12.35it/s]:2: RuntimeWarning: overflow encountered in power\n", - " return relu(relu((sinh(S1**2)**2)**(S1**S1)))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(relu((sinh(S1**2)**2)**(S1**S1)))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(relu((sinh(S1**2)**2)**(S1**S1)))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return exp(-S1)*sqrt(sin(S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return exp(-S1)*sqrt(sin(S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return exp(-_a0_**S2/relu(S1))/S1\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return exp(-_a0_**S2/relu(S1))/S1\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return exp(-_a0_**S2/relu(S1))/S1\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return exp(-_a0_**S2/relu(S1))/S1\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return exp(-_a0_**S2/relu(S1))/S1\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return exp(-_a0_**S2/relu(S1))/S1\n", - " 70%|██████▉ | 1049/1500 [01:14<00:34, 13.16it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(_a0_/S2)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(_a0_/S2)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(relu(log(-S2/(S1*relu(relu(S1))))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(relu(log(-S2/(S1*relu(relu(S1))))))\n", - " 70%|███████ | 1051/1500 [01:15<00:35, 12.77it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(S2/_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(S2/_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu((-S1**4)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu((-S1**4)**_a0_))\n", - " 70%|███████ | 1053/1500 [01:15<00:34, 13.07it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return (relu(relu(S2/_a0_))/relu(_a0_**S2))**sig(S1)\n", - ":2: RuntimeWarning: invalid value encountered in divide\n", - " return (relu(relu(S2/_a0_))/relu(_a0_**S2))**sig(S1)\n", - " 70%|███████ | 1055/1500 [01:15<00:37, 11.73it/s]:2: RuntimeWarning: overflow encountered in exp\n", - " return relu(relu(exp(tan(S1 + exp(_a0_*exp(relu(S2)))))))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return S1**(_a0_**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return S1**(_a0_**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(S1)**(_a0_**S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(S1)**(_a0_**S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(S1)**(_a0_**S1)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu(_a0_**_a0_*relu(sig(_a0_))**S1))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu(_a0_**_a0_*relu(sig(_a0_))**S1))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return _a0_**((1/2)*_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return _a0_**((1/2)*_a0_)\n", - " 70%|███████ | 1057/1500 [01:15<00:37, 11.78it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return relu(relu(log(-S2*exp(-S1)/relu(relu(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(relu(log(-S2*exp(-S1)/relu(relu(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(relu(log(-S2*exp(-S1)/relu(relu(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return S2 + sqrt(S2*_a0_)*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(_a0_)**_a0_)\n", - " 71%|███████ | 1059/1500 [01:15<00:36, 11.94it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(relu(log(-S2/(_a0_*relu(relu(_a0_/S1))))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(relu(log(-S2/(_a0_*relu(relu(_a0_/S1))))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(relu(log(-S2/(_a0_*relu(relu(_a0_/S1))))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(sin(log(S2*relu(S2)))/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(sin(log(S2*relu(S2)))/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(relu(exp(cos(exp(_a0_*exp(relu(S2))) + log(_a0_)))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(relu(exp(cos(exp(_a0_*exp(relu(S2))) + log(_a0_)))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(relu(exp(cos(exp(_a0_*exp(relu(S2))) + log(_a0_)))))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(relu((sinh(S1)**2)**(S1**3)))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(relu((sinh(S1)**2)**(S1**3)))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(relu((sinh(S1)**2)**(S1**3)))\n", - " 71%|███████ | 1061/1500 [01:15<00:35, 12.22it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(tan(S2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(tan(S2))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return tan(S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(relu(log(-S1**_a0_/(_a0_*relu(relu(S1))))))\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return relu(sinh(sinh(S2)**2)**_a0_)\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return relu(sinh(sinh(S2)**2)**_a0_)\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return relu(sinh(sinh(S2)**2)**_a0_)\n", - " 71%|███████ | 1063/1500 [01:16<00:35, 12.40it/s]:2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu((sinh(fac(_a0_))**2)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu((sinh(fac(_a0_))**2)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu((sinh(fac(_a0_))**2)**_a0_))\n", - " 71%|███████ | 1065/1500 [01:16<00:35, 12.12it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(sin(S2)/relu(relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(sin(S2)/relu(relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(sig(log(S2*relu(S2)))/(S2*_a0_))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return sinh(S1)**(S1**S1)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return sinh(S1)**(S1**S1)\n", - " 71%|███████ | 1067/1500 [01:16<00:39, 10.85it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", - " return S1**(-S2)*sqrt(S2*_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(S2*relu(sqrt(_a0_))**S1))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return S1**(S1**S1)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return S1**(S1**S1)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(sinh(S1**2)**cosh(S1))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(sinh(S1**2)**cosh(S1))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(sinh(S1**2)**cosh(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(tan(_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(tan(_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(S1*_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(S1*_a0_)**_a0_)\n", - " 71%|███████▏ | 1069/1500 [01:16<00:37, 11.63it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(sin(sinh(S1))**_a0_))\n", - " 71%|███████▏ | 1071/1500 [01:16<00:35, 12.19it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return relu(relu(log(-S2**_a0_/relu(relu(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(relu(log(-S2**_a0_/relu(relu(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(sinh(_a0_))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(sinh(_a0_))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return sqrt(sig(log(S2*relu(S2)))/relu(-S1))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return sqrt(sig(log(S2*relu(S2)))/relu(-S1))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return sqrt(sig(log(S2*relu(S2)))/relu(-S1))\n", - " 72%|███████▏ | 1073/1500 [01:16<00:34, 12.53it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", - " return log(relu(S2)/relu(log(S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return log(relu(S2)/relu(log(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return S1**(_a0_**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return S1**(_a0_**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(relu(log(-S1**3/relu(relu(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(relu(log(-S1**3/relu(relu(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(relu(log(-S1**3/relu(relu(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (1/2)*sqrt(S2*_a0_)/S1\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu((relu(_a0_)**2)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu((relu(_a0_)**2)**_a0_))\n", - " 72%|███████▏ | 1075/1500 [01:17<00:32, 12.99it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return (S2 + _a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2 + _a0_)**_a0_\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(relu(exp(cos(S1 + exp(_a0_*exp(S2**2))))))\n", - ":2: RuntimeWarning: invalid value encountered in cos\n", - " return relu(relu(exp(cos(S1 + exp(_a0_*exp(S2**2))))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(log(relu(S1))**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(log(relu(S1))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(relu(log(-S2/(_a0_*relu(S2*_a0_)))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(relu(log(-S2/(_a0_*relu(S2*_a0_)))))\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return sinh(S2**S2)**_a0_\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return sinh(S2**S2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return -_a0_**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return -_a0_**_a0_\n", - " 72%|███████▏ | 1077/1500 [01:17<00:33, 12.61it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return relu(S2)*log(sig(relu(S1)))**(S1*_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(S2)*log(sig(relu(S1)))**(S1*_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_/S2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_/S2)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return relu(relu(log(relu(S2/(_a0_*relu(relu(S1)))))))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return relu(relu(log(relu(S2/(_a0_*relu(relu(S1)))))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(sqrt(_a0_)*relu(sig(_a0_))**S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(sqrt(_a0_)*relu(sig(_a0_))**S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(sqrt(_a0_)*relu(sig(_a0_))**S1))\n", - " 72%|███████▏ | 1079/1500 [01:17<00:33, 12.43it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return relu(relu(S2*relu(log(_a0_))**S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return log(S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return (_a0_**3)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return (_a0_**3)**_a0_\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(sinh(S1**2)**(S2**3))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(sinh(S1**2)**(S2**3))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(sinh(S1**2)**(S2**3))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(relu(log(-S2/(_a0_*relu(relu(S1 + _a0_))))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(relu(log(-S2/(_a0_*relu(relu(S1 + _a0_))))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(relu(log(-S2/(_a0_*relu(relu(S1 + _a0_))))))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(tan(_a0_))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(tan(_a0_))**_a0_\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(relu(exp(cos(S1 + exp(S2*exp(relu(S2)))))))\n", - ":2: RuntimeWarning: invalid value encountered in cos\n", - " return relu(relu(exp(cos(S1 + exp(S2*exp(relu(S2)))))))\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(relu(exp(cos(S1 + exp(S2*exp(relu(S2)))))))\n", - ":2: RuntimeWarning: invalid value encountered in cos\n", - " return relu(relu(exp(cos(S1 + exp(S2*exp(relu(S2)))))))\n", - " 72%|███████▏ | 1081/1500 [01:17<00:33, 12.62it/s]:2: RuntimeWarning: overflow encountered in sinh\n", - " return sinh(S1**S1)**_a0_\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return sinh(S1**S1)**_a0_\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return relu(sinh(cosh(S1)**2)**_a0_)\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return relu(sinh(cosh(S1)**2)**_a0_)\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return relu(sinh(cosh(S1)**2)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu(log(-S2*_a0_**(-_a0_)/relu(relu(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu(log(-S2*_a0_**(-_a0_)/relu(relu(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu(log(-S2*_a0_**(-_a0_)/relu(relu(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(S2*cos(S1))*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(S2*cos(S1))*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(S2*cos(S1))*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(_a0_/S1)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(_a0_/S1)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return exp(-sqrt(_a0_)/relu(S1))/S1\n", - " 72%|███████▏ | 1083/1500 [01:17<00:32, 12.69it/s]:2: RuntimeWarning: divide by zero encountered in log\n", - " return log(relu(-S2)/relu(relu(S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(relu(-S2)/relu(relu(S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(relu(-S2)/relu(relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(2*_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(2*_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(relu(log(-1/(S2*relu(relu(S1))))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(relu(log(-1/(S2*relu(relu(S1))))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(relu(log(-1/(S2*relu(relu(S1))))))\n", - " 72%|███████▏ | 1085/1500 [01:17<00:31, 13.01it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(log(-S2/(_a0_*relu(relu(_a0_**S1))))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(relu(log(-S2/(_a0_*relu(relu(_a0_**S1))))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(log(-S2/(_a0_*relu(relu(_a0_**S1))))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(relu(log(-S2/(_a0_*relu(relu(_a0_**S1))))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(log(-S2/(_a0_*relu(relu(_a0_**S1))))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(relu(log(-S2/(_a0_*relu(relu(_a0_**S1))))))\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(relu(exp(cos(S1 + exp(S2**2*exp(relu(S2)))))))\n", - ":2: RuntimeWarning: invalid value encountered in cos\n", - " return relu(relu(exp(cos(S1 + exp(S2**2*exp(relu(S2)))))))\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(relu(exp(cos(S1 + exp(S2**2*exp(relu(S2)))))))\n", - ":2: RuntimeWarning: invalid value encountered in cos\n", - " return relu(relu(exp(cos(S1 + exp(S2**2*exp(relu(S2)))))))\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(relu(exp(cos(S1 + exp(S2**2*exp(relu(S2)))))))\n", - ":2: RuntimeWarning: invalid value encountered in cos\n", - " return relu(relu(exp(cos(S1 + exp(S2**2*exp(relu(S2)))))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(cos(relu(S1))**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(cos(relu(S1))**_a0_))\n", - " 72%|███████▏ | 1087/1500 [01:18<00:46, 8.91it/s]:2: RuntimeWarning: overflow encountered in exp\n", - " return relu(relu(exp(cos(S1 + exp(_a0_*exp(2*S2))))))\n", - ":2: RuntimeWarning: invalid value encountered in cos\n", - " return relu(relu(exp(cos(S1 + exp(_a0_*exp(2*S2))))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_/S2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_/S2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(log(-(S2/_a0_)**relu(relu(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(log(-(S2/_a0_)**relu(relu(S1)))))\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return (sin((3*S1 + S2)**_a0_) + sinh(S1))*exp(-S1/_a0_)\n", - " 73%|███████▎ | 1089/1500 [01:18<00:42, 9.65it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", - " return (relu(relu(S2/relu(_a0_)))/(S1 + _a0_))**sig(S1)\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(_a0_)**_a0_/(S1 + _a0_))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-sig(log(S2*relu(S2)))/S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-sig(log(S2*relu(S2)))/S1)\n", - " 73%|███████▎ | 1091/1500 [01:18<00:37, 10.88it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return relu(relu(log(-1/relu(relu(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(relu(log(-1/relu(relu(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(log(S2)/relu(relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(log(S2)/relu(relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu((-sinh(_a0_**2))**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu((-sinh(_a0_**2))**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu((-sinh(_a0_**2))**_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu((relu(_a0_/S1)**2)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu((relu(_a0_/S1)**2)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu((relu(_a0_/S1)**2)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in divide\n", - " return sqrt(S2)*_a0_/(relu(abs(_a0_))*sqrt(tanh(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(S2**2/_a0_)*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(relu(S2/_a0_)/sqrt(S1*log(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(relu(S2/_a0_)/sqrt(S1*log(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(relu(S2/_a0_)/sqrt(S1*log(S1))))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return sinh(relu(_a0_))**sin(_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return sinh(relu(_a0_))**sin(_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return sinh(relu(_a0_))**sin(_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(tan(S1))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(tan(S1))**_a0_\n", - " 73%|███████▎ | 1093/1500 [01:18<00:35, 11.53it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(relu(log(-S2/(_a0_*relu(_a0_/S1)))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(relu(log(-S2/(_a0_*relu(_a0_/S1)))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(relu(log(-S2/(_a0_*relu(_a0_/S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(S2*_a0_)/S2**2\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (sin((3*S1 + S2)**_a0_) + 1/sqrt(_a0_))*exp(-S1/_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(tan(S1))**sin(_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(tan(S1))**sin(_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(tan(S1))**sin(_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return exp(-sqrt(_a0_)/relu(S1))/S1\n", - " 73%|███████▎ | 1095/1500 [01:18<00:33, 12.08it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return relu(S2)*log(sig(relu(S1)))**(S1*_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-sig(S2)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-sig(S2)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-sig(S2)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(relu(S2/_a0_)/sqrt(S1*log(S2))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(relu(S2/_a0_)/sqrt(S1*log(S2))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(relu(S2/_a0_)/sqrt(S1*log(S2))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(sig(log(S2*relu(S2)))/tan(S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(_a0_/S1)**sin(_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(_a0_/S1)**sin(_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(_a0_/S1)**sin(_a0_)\n", - " 73%|███████▎ | 1097/1500 [01:19<00:33, 11.92it/s]:2: RuntimeWarning: divide by zero encountered in log\n", - " return log(log(S2/S1))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(log(S2/S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_/S2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_/S2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(sqrt(sig(log(S2*relu(S2)))/tan(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(sqrt(sig(log(S2*relu(S2)))/tan(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_**S2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_**S2)**_a0_\n", - " 73%|███████▎ | 1099/1500 [01:19<00:32, 12.28it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", - " return log(relu(S2)/relu(-S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(S2)*_a0_/(relu(abs(fac(S1)))*sqrt(tan(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(S2)*_a0_/(relu(abs(fac(S1)))*sqrt(tan(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*relu(_a0_**S1)**S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*relu(_a0_**S1)**S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*relu(_a0_**S1)**S1))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return _a0_**sin(_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return _a0_**sin(_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return exp(-sig(_a0_)/relu(S2 + _a0_))/S1\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return exp(-sig(_a0_)/relu(S2 + _a0_))/S1\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return exp(-sig(_a0_)/relu(S2 + _a0_))/S1\n", - " 73%|███████▎ | 1101/1500 [01:19<00:32, 12.40it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return exp(-S1/_a0_)*sin((3*S1 + S2)**_a0_)**(S2/_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return exp(-S1/_a0_)*sin((3*S1 + S2)**_a0_)**(S2/_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(tanh(_a0_))**_a0_/(S1 + _a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(-S1)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(-S1)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-S2/(_a0_*relu(_a0_))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-S2/(_a0_*relu(_a0_))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(relu(S2/_a0_)/sqrt(-S2*_a0_)))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(relu(S2/_a0_)/sqrt(-S2*_a0_)))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(relu(S2/_a0_)/sqrt(-S2*_a0_)))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return sinh(fac(_a0_))**sin(_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return sinh(fac(_a0_))**sin(_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return sinh(fac(_a0_))**sin(_a0_)\n", - " 74%|███████▎ | 1103/1500 [01:19<00:31, 12.52it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-S2/S1)*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-S2/S1)*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-S2/S1)*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*relu(_a0_**S2)**S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*relu(_a0_**S2)**S1))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return (relu(relu(S1/relu(_a0_)))/relu(S1))**sig(S1)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu(exp(cos(S1 + exp(_a0_*exp(_a0_**_a0_))))))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu(exp(cos(S1 + exp(_a0_*exp(_a0_**_a0_))))))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu(exp(cos(S1 + exp(_a0_*exp(_a0_**_a0_))))))\n", - " 74%|███████▎ | 1105/1500 [01:19<00:30, 13.06it/s]:2: RuntimeWarning: divide by zero encountered in log\n", - " return log(relu(cos(S2))/relu(relu(S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(relu(cos(S2))/relu(relu(S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(relu(cos(S2))/relu(relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-exp(S1)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-exp(S1)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-exp(S1)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**sin(_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**sin(_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(log(-S2*_a0_**(-S1)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(log(-S2*_a0_**(-S1)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(log(-S2*_a0_**(-S1)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2*_a0_)**sin(_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2*_a0_)**sin(_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2*_a0_)**sin(_a0_)\n", - " 74%|███████▍ | 1107/1500 [01:19<00:29, 13.19it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2/(_a0_*relu(S2**S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(tan(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(tan(S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sin(S2)**_a0_/(S1 + _a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sin(S2)**_a0_/(S1 + _a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(_a0_/S1)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(_a0_/S1)**_a0_)\n", - " 74%|███████▍ | 1109/1500 [01:19<00:28, 13.55it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-sinh(S2)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-sinh(S2)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-sinh(S2)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(exp(cos(S1 + sqrt(_a0_*exp(relu(S2)))))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(exp(cos(S1 + sqrt(_a0_*exp(relu(S2)))))))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return S1**(S1**S1)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return S1**(S1**S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(relu(log(S2/_a0_)/sqrt(S1*S2)))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(_a0_/S2)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(_a0_/S2)**_a0_)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(relu((relu(S1)**2)**(S1**S2)))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(relu((relu(S1)**2)**(S1**S2)))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(relu((relu(S1)**2)**(S1**S2)))\n", - " 74%|███████▍ | 1111/1500 [01:20<00:29, 12.99it/s]:2: RuntimeWarning: divide by zero encountered in log\n", - " return log(relu(-S2)/relu(relu(S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(relu(-S2)/relu(relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2/(S1*relu(relu(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(_a0_**S2)**sin(_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(_a0_**S2)**sin(_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(_a0_**S2)**sin(_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2 + _a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2 + _a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(sqrt(sig(log(S2*relu(S2)))/log(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(sqrt(sig(log(S2*relu(S2)))/log(S1)))\n", - " 74%|███████▍ | 1113/1500 [01:20<00:28, 13.50it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", - " return (relu(relu(S2/relu(S1/_a0_)))/relu(S1))**sig(S1)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return (_a0_**_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return (_a0_**_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(relu(relu(S2/_a0_)/sqrt(S1*S2)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(relu(exp(cos(exp(_a0_*exp(relu(S2))) + log(_a0_)))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(relu(exp(cos(exp(_a0_*exp(relu(S2))) + log(_a0_)))))\n", - " 74%|███████▍ | 1115/1500 [01:20<00:28, 13.33it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-1/(S1*relu(relu(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-1/(S1*relu(relu(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-1/(S1*relu(relu(S1)))))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return relu(sqrt(sig(log(relu(S2)*log(_a0_)))/relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(tan(S2/(_a0_*relu(relu(S1))))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_**S2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_**S2)**_a0_\n", - " 74%|███████▍ | 1117/1500 [01:20<00:28, 13.50it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", - " return log(relu(S2)/relu(relu(S2 + _a0_)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sinh(S1)**log(_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sinh(S1)**log(_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2/_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2/_a0_)**_a0_\n", - " 75%|███████▍ | 1119/1500 [01:20<00:28, 13.49it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return sin(S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(S1)**log(_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(S1)**log(_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(S1)**log(_a0_)\n", - " 75%|███████▍ | 1121/1500 [01:20<00:28, 13.48it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(tan(S2)/relu(relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(tan(S2)/relu(relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(relu(S2/_a0_)/sqrt(S2*(S2 + _a0_))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*relu(sig(_a0_))**(_a0_**S2)))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*relu(sig(_a0_))**(_a0_**S2)))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*relu(sig(_a0_))**(_a0_**S2)))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-S2/(_a0_*relu(relu(2*_a0_)))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-S2/(_a0_*relu(relu(2*_a0_)))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-S2/(_a0_*relu(relu(2*_a0_)))))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(sin(_a0_))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(sin(_a0_))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(sin(_a0_))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(_a0_)**_a0_)\n", - " 75%|███████▍ | 1123/1500 [01:21<00:28, 13.08it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(relu(S2)**_a0_/(_a0_ + relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(_a0_**_a0_/(_a0_ + relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return cos(S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(_a0_)**_a0_)\n", - " 75%|███████▌ | 1125/1500 [01:21<00:28, 13.22it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S1/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S1/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (-relu(relu(S2/relu(2*_a0_)))/S1)**sig(S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (-relu(relu(S2/relu(2*_a0_)))/S1)**sig(S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(S2/tan(S2))*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(S2/tan(S2))*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(S2/tan(S2))*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(cos(S1))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(cos(S1))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(exp(cos(S1 + exp(_a0_*exp(_a0_**S2))))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(exp(cos(S1 + exp(_a0_*exp(_a0_**S2))))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(exp(cos(S1 + exp(_a0_*exp(_a0_**S2))))))\n", - " 75%|███████▌ | 1127/1500 [01:21<00:28, 13.09it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return exp(-sig(log(_a0_))/relu(S1))/S1\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return exp(-sig(log(_a0_))/relu(S1))/S1\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return exp(-sig(log(_a0_))/relu(S1))/S1\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2**2/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2**2/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2**2/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(S2/log(S2))*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(S2/log(S2))*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(S2/log(S2))*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu((S1*_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu((S1*_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return log(S2)**(-_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return log(S2)**(-_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sin(S1)**_a0_\n", - " 75%|███████▌ | 1129/1500 [01:21<00:28, 13.18it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2/(relu(relu(S1))*log(S2))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2/(relu(relu(S1))*log(S2))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2/(relu(relu(S1))*log(S2))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(sqrt(sig(log(relu(S2)*cos(S2)))/relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(sqrt(sig(log(relu(S2)*cos(S2)))/relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(sqrt(sig(log(relu(S2)*cos(S2)))/relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(exp(cos(S1 + exp(_a0_*exp(relu(_a0_**S2)))))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(exp(cos(S1 + exp(_a0_*exp(relu(_a0_**S2)))))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(exp(cos(S1 + exp(_a0_*exp(relu(_a0_**S2)))))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log((S2 + _a0_)/relu(relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-log(S1)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-log(S1)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-log(S1)/relu(relu(S1))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return (relu(relu(S2/relu(2*_a0_)))/S2)**sig(S1)\n", - " 75%|███████▌ | 1131/1500 [01:21<00:27, 13.37it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-S2/(_a0_*relu(sin(S1)))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-S2/(_a0_*relu(sin(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(sqrt(sig(log(S2*relu(S2)))/(S2 + _a0_)))\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(relu(exp(cos(S1 + exp(relu(S1)*exp(relu(S2)))))))\n", - ":2: RuntimeWarning: invalid value encountered in cos\n", - " return relu(relu(exp(cos(S1 + exp(relu(S1)*exp(relu(S2)))))))\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(relu(exp(cos(S1 + exp(relu(S1)*exp(relu(S2)))))))\n", - ":2: RuntimeWarning: invalid value encountered in cos\n", - " return relu(relu(exp(cos(S1 + exp(relu(S1)*exp(relu(S2)))))))\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(relu(exp(cos(S1 + exp(relu(S1)*exp(relu(S2)))))))\n", - ":2: RuntimeWarning: invalid value encountered in cos\n", - " return relu(relu(exp(cos(S1 + exp(relu(S1)*exp(relu(S2)))))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu((_a0_**(2*S1))**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu((_a0_**(2*S1))**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu((_a0_**(2*S1))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu((relu(fac(_a0_))**2)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu((relu(fac(_a0_))**2)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu((relu(fac(_a0_))**2)**_a0_))\n", - " 76%|███████▌ | 1133/1500 [01:21<00:28, 13.08it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return exp(-_a0_**S2/relu(S1))/S1\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return exp(-_a0_**S2/relu(S1))/S1\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return exp(-_a0_**S2/relu(S1))/S1\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return exp(-_a0_**S2/relu(S1))/S1\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(log(S1))**(-_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(log(S1))**(-_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(log(S1))**(-_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return exp(-_a0_**(-_a0_)*sig(_a0_))/S1\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return exp(-_a0_**(-_a0_)*sig(_a0_))/S1\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu((relu(S2 + _a0_)**2)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu((relu(S2 + _a0_)**2)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu((relu(S2 + _a0_)**2)**_a0_))\n", - " 76%|███████▌ | 1135/1500 [01:21<00:28, 13.01it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return log(S2)**(-_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return log(S2)**(-_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(relu(S2/_a0_)/sqrt(S1*log(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(relu(S2/_a0_)/sqrt(S1*log(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(sqrt(tanh(log(S2*relu(S2)))/relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(sqrt(tanh(log(S2*relu(S2)))/relu(S1)))\n", - " 76%|███████▌ | 1137/1500 [01:22<00:29, 12.45it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(S2)*_a0_/(sqrt(-S1)*relu(abs(fac(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(S2)*_a0_/(sqrt(-S1)*relu(abs(fac(S1))))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu((relu(_a0_/S2)**2)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu((relu(_a0_/S2)**2)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu((relu(_a0_/S2)**2)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2/(S1*relu(relu(S1)))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return (relu(relu(S1/relu(2*_a0_)))/relu(S1))**sig(S1)\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return sqrt(S2)*_a0_/(relu(log(fac(S1)))*sqrt(tanh(S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return sqrt(S2)*_a0_/(relu(log(fac(S1)))*sqrt(tanh(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_/S2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_/S2)**_a0_\n", - " 76%|███████▌ | 1139/1500 [01:22<00:29, 12.06it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S1/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S1/relu(relu(S1))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return (relu(relu(S2/relu(2*_a0_)))/relu(sinh(S2)))**sig(S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return S1**(-_a0_**S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return tan(S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2*exp(-S2)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2*exp(-S2)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2*exp(-S2)/relu(relu(S1))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return (relu(relu(S2/relu(2*_a0_)))/relu(S2))**sig(S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(relu(relu(S2/_a0_)/sqrt(cos(_a0_)))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(relu(relu(S2/_a0_)/sqrt(cos(_a0_)))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(relu(relu(S2/_a0_)/sqrt(cos(_a0_)))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(sqrt(sig(log(S2**2))/relu(-_a0_)))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(sqrt(sig(log(S2**2))/relu(-_a0_)))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(sqrt(sig(log(S2**2))/relu(-_a0_)))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu((2*_a0_)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu((2*_a0_)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu((2*_a0_)**_a0_))\n", - " 76%|███████▌ | 1141/1500 [01:22<00:30, 11.89it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(tan(relu(S1))**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(tan(relu(S1))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-S2/(_a0_*relu(log(S1)))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-S2/(_a0_*relu(log(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(relu(relu(S2/_a0_)/sqrt(S1*cos(S2)))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(relu(relu(S2/_a0_)/sqrt(S1*cos(S2)))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(relu(relu(S2/_a0_)/sqrt(S1*cos(S2)))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(sqrt(sqrt(log(S2**2))/relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(sqrt(sqrt(log(S2**2))/relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu((S1 + _a0_)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu((S1 + _a0_)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu((S1 + _a0_)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu((relu(_a0_/S2)**2)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu((relu(_a0_/S2)**2)**_a0_))\n", - " 76%|███████▌ | 1143/1500 [01:22<00:28, 12.39it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(S2/cos(S2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(S2/cos(S2))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(relu(log(S1))/relu(relu(S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(relu(log(S1))/relu(relu(S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(relu(log(S1))/relu(relu(S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-S2/(_a0_*relu(_a0_/S1))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-S2/(_a0_*relu(_a0_/S1))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-S2/(_a0_*relu(_a0_/S1))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return tan(S1)**_a0_\n", - " 76%|███████▋ | 1145/1500 [01:22<00:28, 12.51it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return relu(log(-S2/(_a0_*relu(_a0_**S2))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-S2/(_a0_*relu(_a0_**S2))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(log(-S2/(_a0_*relu(_a0_**S2))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-S2/(_a0_*relu(_a0_**S2))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(log(-S2/(_a0_*relu(_a0_**S2))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-S2/(_a0_*relu(_a0_**S2))))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(log(S1))**_a0_/(_a0_ + relu(S1)))\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(relu(exp(cos(S1 + exp(S2*exp(relu(S2)))))))\n", - ":2: RuntimeWarning: invalid value encountered in cos\n", - " return relu(relu(exp(cos(S1 + exp(S2*exp(relu(S2)))))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return exp(-sig(_a0_)/relu(S1))/relu(_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return exp(-sig(_a0_)/relu(S1))/relu(_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return exp(-sig(_a0_)/relu(S1))/relu(_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2*exp(-S1)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2*exp(-S1)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2*exp(-S1)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(S2)*_a0_/(relu(abs(fac(S1)))*sqrt(sin(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(S2)*_a0_/(relu(abs(fac(S1)))*sqrt(sin(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return S1**log(_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(-S1)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(-S1)**_a0_\n", - " 76%|███████▋ | 1147/1500 [01:22<00:27, 12.95it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(sinh(_a0_**S1)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(sinh(_a0_**S1)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(sinh(_a0_**S1)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_**S2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_**S2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(log(-S2/(_a0_*relu(_a0_**S1))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-S2/(_a0_*relu(_a0_**S1))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(log(-S2/(_a0_*relu(_a0_**S1))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-S2/(_a0_*relu(_a0_**S1))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(log(-S2/(_a0_*relu(_a0_**S1))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-S2/(_a0_*relu(_a0_**S1))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt((S1 + _a0_)/_a0_)*exp(-S1)\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(relu(exp(cos(S1 + exp(_a0_*exp(S1**S2))))))\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(relu(exp(cos(S1 + exp(_a0_*exp(S1**S2))))))\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(relu(exp(cos(S1 + exp(_a0_*exp(S1**S2))))))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return (_a0_**3)**(-_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(_a0_)**_a0_\n", - " 77%|███████▋ | 1149/1500 [01:23<00:26, 13.06it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return tan(S1)**(-_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return tan(S1)**(-_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu(sinh(_a0_**_a0_)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu(sinh(_a0_**_a0_)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu(sinh(_a0_**_a0_)**_a0_))\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(relu(exp(cos(S1 + exp(_a0_*exp(relu(S1**S2)))))))\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(relu(exp(cos(S1 + exp(_a0_*exp(relu(S1**S2)))))))\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(relu(exp(cos(S1 + exp(_a0_*exp(relu(S1**S2)))))))\n", - " 77%|███████▋ | 1151/1500 [01:23<00:28, 12.25it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return (S2 + _a0_)**(-_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return exp(-_a0_**S2/relu(S1))/S1\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return exp(-_a0_**S2/relu(S1))/S1\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return exp(-_a0_**S2/relu(S1))/S1\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return exp(-_a0_**S2/relu(S1))/S1\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-abs(_a0_)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-abs(_a0_)/relu(relu(S1))))\n", - " 77%|███████▋ | 1153/1500 [01:23<00:29, 11.84it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-S2/(_a0_*relu(relu(_a0_)))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-S2/(_a0_*relu(relu(_a0_)))))\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(relu(exp(cos(S1 + exp(exp(relu(relu(S2)))*abs(S1))))))\n", - ":2: RuntimeWarning: invalid value encountered in cos\n", - " return relu(relu(exp(cos(S1 + exp(exp(relu(relu(S2)))*abs(S1))))))\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(relu(exp(cos(S1 + exp(exp(relu(relu(S2)))*abs(S1))))))\n", - ":2: RuntimeWarning: invalid value encountered in cos\n", - " return relu(relu(exp(cos(S1 + exp(exp(relu(relu(S2)))*abs(S1))))))\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(relu(exp(cos(S1 + exp(exp(relu(relu(S2)))*abs(S1))))))\n", - ":2: RuntimeWarning: invalid value encountered in cos\n", - " return relu(relu(exp(cos(S1 + exp(exp(relu(relu(S2)))*abs(S1))))))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return S1**(S1**S1)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return S1**(S1**S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_**S2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_**S2)**_a0_\n", - " 77%|███████▋ | 1155/1500 [01:23<00:28, 12.01it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(S2)*_a0_/(sqrt(-S1)*relu(abs(fac(S1))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return (relu(relu(S2/relu(_a0_)))/relu(-S2))**sig(S1)\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return (relu(relu(S2/relu(_a0_)))/relu(-S2))**sig(S1)\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return (relu(relu(S2/relu(_a0_)))/relu(-S2))**sig(S1)\n", - " 77%|███████▋ | 1157/1500 [01:23<00:27, 12.39it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-1/relu(relu(S1))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(sqrt(sig(log(S2**2))/relu(cos(S1))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(sqrt(sig(log(S2**2))/relu(cos(S1))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(sqrt(sig(log(S2**2))/relu(cos(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(_a0_/S2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(_a0_/S2)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return log(relu(S2)/relu(relu(S1 + _a0_)))\n", - " 77%|███████▋ | 1159/1500 [01:23<00:28, 12.00it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-1/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return _a0_*relu(log(-S2/(_a0_*relu(relu(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(relu(relu(S2/_a0_)/sqrt(log(S2)))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(relu(relu(S2/_a0_)/sqrt(log(S2)))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(relu(relu(S2/_a0_)/sqrt(log(S2)))))\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(relu(exp(cos(S1 + exp(S2*exp(relu(relu(S2))))))))\n", - ":2: RuntimeWarning: invalid value encountered in cos\n", - " return relu(relu(exp(cos(S1 + exp(S2*exp(relu(relu(S2))))))))\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(relu(exp(cos(S1 + exp(S2*exp(relu(relu(S2))))))))\n", - ":2: RuntimeWarning: invalid value encountered in cos\n", - " return relu(relu(exp(cos(S1 + exp(S2*exp(relu(relu(S2))))))))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu(_a0_**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu(_a0_**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return exp(-sig(_a0_)/relu(S1*_a0_))/relu(S1)\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return exp(-sig(_a0_)/relu(S1*_a0_))/relu(S1)\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return exp(-sig(_a0_)/relu(S1*_a0_))/relu(S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(_a0_**S1)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(_a0_**S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(_a0_**S1)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(_a0_**S1)**_a0_\n", - " 77%|███████▋ | 1161/1500 [01:24<00:28, 11.94it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(S2**3/(_a0_**3*relu(relu(S1))**3)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(S2**3/(_a0_**3*relu(relu(S1))**3)))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(sinh(S1*_a0_)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(sinh(S1*_a0_)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(sinh(S1*_a0_)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S2/relu(relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S2/relu(relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2/(_a0_*cosh(relu(S1)))))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return (relu(relu(S2/relu(_a0_)))/relu(S1))**(S2**S2)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return (relu(relu(S2/relu(_a0_)))/relu(S1))**(S2**S2)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return (relu(relu(S2/relu(_a0_)))/relu(S1))**(S2**S2)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(sqrt(sig(log(S2**2))/sin(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(sqrt(sig(log(S2**2))/sin(S1)))\n", - " 78%|███████▊ | 1163/1500 [01:24<00:27, 12.08it/s]:2: RuntimeWarning: overflow encountered in exp\n", - " return relu(relu(exp(cos(S1 + exp(_a0_*exp(relu(relu(2*S2))))))))\n", - ":2: RuntimeWarning: invalid value encountered in cos\n", - " return relu(relu(exp(cos(S1 + exp(_a0_*exp(relu(relu(2*S2))))))))\n", - " 78%|███████▊ | 1165/1500 [01:24<00:26, 12.56it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(sinh(S2/(_a0_*relu(relu(S1))))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(sinh(S2/(_a0_*relu(relu(S1))))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(S2*_a0_)**(-_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu(_a0_**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu(_a0_**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - " 78%|███████▊ | 1167/1500 [01:24<00:25, 12.94it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return cos(S2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return cos(S2)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(_a0_))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(_a0_))**_a0_\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(relu(exp(cos(S1 + exp(_a0_*exp(relu(sinh(S2))))))))\n", - ":2: RuntimeWarning: invalid value encountered in cos\n", - " return relu(relu(exp(cos(S1 + exp(_a0_*exp(relu(sinh(S2))))))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(_a0_**S1)**(-_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(_a0_**S1)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(_a0_**S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(_a0_**S1)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(_a0_**S1)**_a0_\n", - " 78%|███████▊ | 1171/1500 [01:24<00:24, 13.37it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-S2/(_a0_*relu(relu(tan(S1))))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-S2/(_a0_*relu(relu(tan(S1))))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-S2/(_a0_*relu(relu(tan(S1))))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return (relu(relu(S2/relu(_a0_)))/relu(S2))**sig(S1)\n", - " 78%|███████▊ | 1173/1500 [01:24<00:24, 13.15it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", - " return (relu(relu(S2/relu(_a0_)))/relu(exp(S1)))**sig(S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(sqrt(sig(log(S2*(S2 + _a0_)))/relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_/S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_/S1)**_a0_\n", - " 78%|███████▊ | 1175/1500 [01:25<00:24, 13.31it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-fac(S1)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-fac(S1)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-fac(S1)/relu(relu(S1))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return (relu(relu(S2/relu(_a0_)))/relu(S2 + _a0_))**sig(S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-S1/_a0_)*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-S1/_a0_)*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return tan(S1)**_a0_\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return relu(relu(sinh(S2**S2)**_a0_))\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return relu(relu(sinh(S2**S2)**_a0_))\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return relu(relu(sinh(S2**S2)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return S1**(sqrt(_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return S1**(sqrt(_a0_))\n", - " 78%|███████▊ | 1177/1500 [01:25<00:24, 13.08it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(S2/sin(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(S2/sin(S1))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu(_a0_**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu(_a0_**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-(S2 + _a0_)/relu(relu(S1))))\n", - " 79%|███████▊ | 1179/1500 [01:25<00:24, 13.10it/s]:2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(_a0_**3)**_a0_/(_a0_ + relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2/(_a0_*tan(relu(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_/S2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_/S2)**_a0_\n", - " 79%|███████▊ | 1181/1500 [01:25<00:23, 13.34it/s]:2: RuntimeWarning: overflow encountered in exp\n", - " return relu(relu(exp(cos(S1 + exp(S2**S1*exp(relu(relu(S2))))))))\n", - ":2: RuntimeWarning: invalid value encountered in cos\n", - " return relu(relu(exp(cos(S1 + exp(S2**S1*exp(relu(relu(S2))))))))\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(relu(exp(cos(S1 + exp(S2**S1*exp(relu(relu(S2))))))))\n", - ":2: RuntimeWarning: invalid value encountered in cos\n", - " return relu(relu(exp(cos(S1 + exp(S2**S1*exp(relu(relu(S2))))))))\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(relu(exp(cos(S1 + exp(S2**S1*exp(relu(relu(S2))))))))\n", - ":2: RuntimeWarning: invalid value encountered in cos\n", - " return relu(relu(exp(cos(S1 + exp(S2**S1*exp(relu(relu(S2))))))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sinh(log(_a0_))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sinh(log(_a0_))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return (2*_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return (2*_a0_)**_a0_\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return sinh(S1**S1)**_a0_\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return sinh(S1**S1)**_a0_\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(relu((sinh(S1)**2)**(S1**S1)))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(relu((sinh(S1)**2)**(S1**S1)))\n", - " 79%|███████▉ | 1183/1500 [01:25<00:23, 13.41it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", - " return _a0_*sqrt(log(_a0_))/(sqrt(tanh(S1))*abs(relu(fac(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return _a0_*sqrt(log(_a0_))/(sqrt(tanh(S1))*abs(relu(fac(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return _a0_*sqrt(log(_a0_))/(sqrt(tanh(S1))*abs(relu(fac(S1))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return (relu(relu(S2/relu(_a0_)))/relu(S2*_a0_))**sig(S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(S1)**(_a0_**S2)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(S1)**(_a0_**S2)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(S1)**(_a0_**S2)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return exp(-log(_a0_)/S1)/relu(S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return exp(-log(_a0_)/S1)/relu(S1)\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(sinh(_a0_))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2/(_a0_*sin(relu(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2/(_a0_*sin(relu(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2/_a0_ + sin((2*S1 + sin(S1) + tan(S2))**_a0_))*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2/_a0_ + sin((2*S1 + sin(S1) + tan(S2))**_a0_))*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2/_a0_ + sin((2*S1 + sin(S1) + tan(S2))**_a0_))*exp(-S1)\n", - " 79%|███████▉ | 1185/1500 [01:25<00:24, 13.07it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", - " return log(relu(S2)/relu(relu(cos(S2))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return log(relu(S2)/relu(relu(cos(S2))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-tan(S2)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-tan(S2)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-tan(S2)/relu(relu(S1))))\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(relu(exp(cos(S1 + exp(_a0_*exp(cosh(relu(S2))))))))\n", - ":2: RuntimeWarning: invalid value encountered in cos\n", - " return relu(relu(exp(cos(S1 + exp(_a0_*exp(cosh(relu(S2))))))))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(relu(sin(S2))/relu(relu(S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(relu(sin(S2))/relu(relu(S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(relu(sin(S2))/relu(relu(S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar divide\n", - " return exp(-sig(_a0_)/relu(_a0_))/relu(S1)\n", - ":2: RuntimeWarning: divide by zero encountered in scalar divide\n", - " return exp(-sig(_a0_)/relu(_a0_))/relu(S1)\n", - ":2: RuntimeWarning: divide by zero encountered in scalar divide\n", - " return exp(-sig(_a0_)/relu(_a0_))/relu(S1)\n", - " 79%|███████▉ | 1187/1500 [01:26<00:24, 12.92it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(cos(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(cos(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-(S2 + _a0_)/(_a0_*relu(relu(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-(S2 + _a0_)/(_a0_*relu(relu(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-(S2 + _a0_)/(_a0_*relu(relu(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(relu(S2)/sin(relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(relu(S2)/sin(relu(S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return exp(-sig(_a0_)/S1)/relu(cos(S1))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return exp(-sig(_a0_)/S1)/relu(cos(S1))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return exp(-sig(_a0_)/S1)/relu(cos(S1))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(_a0_/S2)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(_a0_/S2)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(S1*_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(S1*_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu((_a0_**(2*_a0_))**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu((_a0_**(2*_a0_))**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu((_a0_**(2*_a0_))**_a0_))\n", - " 79%|███████▉ | 1189/1500 [01:26<00:23, 13.42it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2/(_a0_*log(relu(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2/(_a0_*log(relu(S1)))))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return exp(-_a0_**_a0_/S1)/relu(S1)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return exp(-_a0_**_a0_/S1)/relu(S1)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return exp(-_a0_**_a0_/S1)/relu(S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2/(_a0_*relu(cosh(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(sinh(cos(S1))**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(sinh(cos(S1))**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(sinh(cos(S1))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(sinh(_a0_))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu((sinh(_a0_**_a0_)**2)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu((sinh(_a0_**_a0_)**2)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu((sinh(_a0_**_a0_)**2)**_a0_))\n", - " 79%|███████▉ | 1191/1500 [01:26<00:24, 12.72it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2/(_a0_**2*relu(relu(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2/(_a0_**2*relu(relu(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2/(_a0_**2*relu(relu(S1)))))\n", - " 80%|███████▉ | 1193/1500 [01:26<00:23, 12.88it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return sqrt(sig(log(tan(S2)))/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sqrt(sig(log(tan(S2)))/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sqrt(sig(log(tan(S2)))/relu(S1))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2/_a0_ + sin((2*S1 + S2 + log(S1))**_a0_))*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2/_a0_ + sin((2*S1 + S2 + log(S1))**_a0_))*exp(-S1)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(tan(S1))**_a0_\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return relu(relu((sinh(S1**S1)**2)**_a0_))\n", - ":2: RuntimeWarning: overflow encountered in square\n", - " return relu(relu((sinh(S1**S1)**2)**_a0_))\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return relu(relu((sinh(S1**S1)**2)**_a0_))\n", - ":2: RuntimeWarning: overflow encountered in square\n", - " return relu(relu((sinh(S1**S1)**2)**_a0_))\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return relu(relu((sinh(S1**S1)**2)**_a0_))\n", - ":2: RuntimeWarning: overflow encountered in square\n", - " return relu(relu((sinh(S1**S1)**2)**_a0_))\n", - " 80%|███████▉ | 1195/1500 [01:26<00:25, 12.11it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-S2/(_a0_*relu(S1*_a0_))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-S2/(_a0_*relu(S1*_a0_))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-S2/(_a0_*relu(S1*_a0_))))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(log(S1))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-S2/(_a0_*relu(_a0_))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-S2/(_a0_*relu(_a0_))))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(relu(log(_a0_))/relu(relu(S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(relu(log(_a0_))/relu(relu(S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(relu(log(_a0_))/relu(relu(S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return (relu(relu(S2/relu(-S1)))/relu(S1))**sig(S1)\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return (relu(relu(S2/relu(-S1)))/relu(S1))**sig(S1)\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return (relu(relu(S2/relu(-S1)))/relu(S1))**sig(S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(relu(relu(S2/_a0_)/sqrt(-S2))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(relu(relu(S2/_a0_)/sqrt(-S2))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(relu(relu(S2/_a0_)/sqrt(-S2))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(sqrt(_a0_))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(sqrt(_a0_))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(sqrt(_a0_))**_a0_\n", - " 80%|███████▉ | 1199/1500 [01:26<00:22, 13.14it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(S2)*_a0_/(sqrt(tanh(log(S1)))*abs(relu(fac(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(S2)*_a0_/(sqrt(tanh(log(S1)))*abs(relu(fac(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(S2)*_a0_/(sqrt(tanh(log(S1)))*abs(relu(fac(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(cos(S2)**_a0_/(_a0_ + relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(cos(S2)**_a0_/(_a0_ + relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(cos(S2)**_a0_/(_a0_ + relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_**S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_**S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return (_a0_**_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return (_a0_**_a0_)**_a0_\n", - " 80%|████████ | 1201/1500 [01:27<00:22, 13.29it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", - " return sqrt(S2)*_a0_/(sqrt(tanh(S1))*abs(relu(_a0_)))\n", - ":2: RuntimeWarning: invalid value encountered in divide\n", - " return sqrt(S2)*_a0_/(sqrt(tanh(S1))*abs(relu(_a0_)))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return exp(-sig(_a0_)/S1)/relu(S2 + _a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return exp(-sig(_a0_)/S1)/relu(S2 + _a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return exp(-sig(_a0_)/S1)/relu(S2 + _a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return fac(_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return fac(_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - " 80%|████████ | 1203/1500 [01:27<00:23, 12.43it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_/S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_/S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu((_a0_**(2*S1))**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu((_a0_**(2*S1))**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S1**2/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S1**2/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S1**2/relu(relu(S1))))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(log(S1))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(log(S1))**_a0_\n", - " 80%|████████ | 1205/1500 [01:27<00:24, 11.95it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu((sinh(sqrt(_a0_))**2)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu((sinh(sqrt(_a0_))**2)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu((sinh(sqrt(_a0_))**2)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*relu(_a0_**S2)**relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*relu(_a0_**S2)**relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*relu(_a0_**S2)**relu(S1)))\n", - " 80%|████████ | 1207/1500 [01:27<00:24, 11.93it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2*exp(-relu(S1))/_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu((S1/_a0_)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu((S1/_a0_)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu((S1/_a0_)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(S2/_a0_)*exp(-cosh(S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(relu(relu(S2/_a0_)/sqrt(tan(_a0_)))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(relu(relu(S2/_a0_)/sqrt(tan(_a0_)))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(relu(relu(S2/_a0_)/sqrt(tan(_a0_)))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(_a0_/S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(_a0_/S1)**_a0_\n", - " 81%|████████ | 1209/1500 [01:27<00:23, 12.14it/s]:2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(S1 + _a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(S1 + _a0_)**_a0_\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(relu(exp(cos(S1 + exp(relu(relu(S2))**2*cosh(S2))))))\n", - ":2: RuntimeWarning: invalid value encountered in cos\n", - " return relu(relu(exp(cos(S1 + exp(relu(relu(S2))**2*cosh(S2))))))\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(relu(exp(cos(S1 + exp(relu(relu(S2))**2*cosh(S2))))))\n", - ":2: RuntimeWarning: invalid value encountered in cos\n", - " return relu(relu(exp(cos(S1 + exp(relu(relu(S2))**2*cosh(S2))))))\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(relu(exp(cos(S1 + exp(relu(relu(S2))**2*cosh(S2))))))\n", - ":2: RuntimeWarning: invalid value encountered in cos\n", - " return relu(relu(exp(cos(S1 + exp(relu(relu(S2))**2*cosh(S2))))))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(_a0_)**_a0_\n", - " 81%|████████ | 1211/1500 [01:28<00:24, 11.80it/s]:2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu((sinh(relu(_a0_))**2)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu((sinh(relu(_a0_))**2)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(relu(cos(S1))/relu(relu(S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(relu(cos(S1))/relu(relu(S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(relu(cos(S1))/relu(relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu(sinh(_a0_)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu(sinh(_a0_)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return _a0_**(-_a0_)*exp(-sig(_a0_)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return _a0_**(-_a0_)*exp(-sig(_a0_)/S1)\n", - " 81%|████████ | 1213/1500 [01:28<00:24, 11.78it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", - " return (relu(relu(S2/relu(cos(S2))))/relu(S1))**sig(S1)\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return (relu(relu(S2/relu(cos(S2))))/relu(S1))**sig(S1)\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return (relu(relu(S2/relu(cos(S2))))/relu(S1))**sig(S1)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu((_a0_**_a0_)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu((_a0_**_a0_)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu((_a0_**_a0_)**_a0_))\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return exp(-_a0_/S1**2)/relu(S1)\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return exp(-_a0_/S1**2)/relu(S1)\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return exp(-_a0_/S1**2)/relu(S1)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu((sinh(relu(tan(S1)))**2)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu((sinh(relu(tan(S1)))**2)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu((sinh(relu(tan(S1)))**2)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2**2*_a0_/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(relu(relu(S2/_a0_)/sqrt(-S1))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(relu(relu(S2/_a0_)/sqrt(-S1))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(relu(relu(S2/_a0_)/sqrt(-S1))))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu(_a0_**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu(_a0_**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(sinh(_a0_))**_a0_\n", - " 81%|████████ | 1215/1500 [01:28<00:24, 11.87it/s]:2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(_a0_/S1)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(_a0_/S1)**_a0_\n", - " 81%|████████ | 1217/1500 [01:28<00:23, 12.04it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-S2*_a0_/relu(relu(_a0_))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-S2*_a0_/relu(relu(_a0_))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2*_a0_*relu(relu(S1))))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(relu(log(_a0_))/relu(relu(S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(relu(log(_a0_))/relu(relu(S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return (relu(relu(S2/relu(_a0_)))/(S2*_a0_))**sig(S1)\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(_a0_)**_a0_\n", - " 81%|████████▏ | 1219/1500 [01:28<00:23, 12.10it/s]:2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(-S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(cos(S1)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(cos(S1)**_a0_))\n", - " 81%|████████▏ | 1221/1500 [01:28<00:23, 12.10it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*relu(sig(_a0_))**(_a0_**S2)))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*relu(sig(_a0_))**(_a0_**S2)))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu(sinh(S1)**(_a0_**_a0_)))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu(sinh(S1)**(_a0_**_a0_)))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu(sinh(S1)**(_a0_**_a0_)))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(log(S1)))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sinh(log(S1)))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return (2*_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return (2*_a0_)**_a0_\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(sinh(S1))**(S1**S2)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(sinh(S1))**(S1**S2)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu((sinh(relu(_a0_**_a0_))**2)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu((sinh(relu(_a0_**_a0_))**2)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu((sinh(relu(_a0_**_a0_))**2)**_a0_))\n", - " 82%|████████▏ | 1223/1500 [01:28<00:22, 12.22it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return tan(S1)**_a0_\n", - " 82%|████████▏ | 1225/1500 [01:29<00:22, 11.98it/s]:2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(sinh(tan(_a0_)))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(sinh(tan(_a0_)))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(sinh(tan(_a0_)))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S1/_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S1/_a0_)**_a0_\n", - " 82%|████████▏ | 1227/1500 [01:29<00:25, 10.69it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return -log(-S2*_a0_/relu(relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sqrt(sig(log(-_a0_))/sinh(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sqrt(sig(log(-_a0_))/sinh(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sqrt(sig(log(-_a0_))/sinh(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S1/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S1/relu(relu(S1))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return (relu(relu(S2/relu(_a0_)))/relu(S1*S2))**sig(S1)\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(_a0_)**_a0_/(_a0_ + relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu(sinh(sin(_a0_))**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu(sinh(sin(_a0_))**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu(sinh(sin(_a0_))**_a0_))\n", - " 82%|████████▏ | 1229/1500 [01:29<00:24, 11.07it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(S1*_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(S1*_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sinh(S1)**(sqrt(_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sinh(S1)**(sqrt(_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(S2 + _a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(S2 + _a0_)**_a0_\n", - " 82%|████████▏ | 1231/1500 [01:29<00:23, 11.30it/s]:2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu((sinh(relu(S2/_a0_))**2)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu((sinh(relu(S2/_a0_))**2)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu((sinh(relu(S2/_a0_))**2)**_a0_))\n", - " 82%|████████▏ | 1233/1500 [01:29<00:24, 11.08it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-S2*_a0_/relu(S1*_a0_)))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-S2*_a0_/relu(S1*_a0_)))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-S2*_a0_/relu(S1*_a0_)))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu((sinh(relu(S1/_a0_))**2)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu((sinh(relu(S1/_a0_))**2)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu((sinh(relu(S1/_a0_))**2)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return _a0_*relu(log(-S2*_a0_/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu((_a0_**S2)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu((_a0_**S2)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu((_a0_**S2)**_a0_))\n", - " 82%|████████▏ | 1235/1500 [01:30<00:22, 11.66it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return (S2/_a0_ + sin((2*S1 + S2 + sin(S2/S1))**_a0_))*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2/_a0_ + sin((2*S1 + S2 + sin(S2/S1))**_a0_))*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(S1**S1/_a0_)*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S1 + _a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S1 + _a0_)**_a0_\n", - " 82%|████████▏ | 1237/1500 [01:30<00:22, 11.56it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return exp(-S1)*sqrt(log(_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return exp(-S1)*sqrt(log(_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(relu(tan(S2))/relu(relu(S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(relu(tan(S2))/relu(relu(S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(relu(tan(S2))/relu(relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return tan(S1)**_a0_\n", - " 83%|████████▎ | 1239/1500 [01:30<00:22, 11.73it/s]:2: RuntimeWarning: overflow encountered in power\n", - " return relu(relu(sinh(S1)**(S1**S1)))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(relu(sinh(S1)**(S1**S1)))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(relu(sinh(S1)**(S1**S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-log(_a0_)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-log(_a0_)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-log(_a0_)/relu(relu(S1))))\n", - " 83%|████████▎ | 1241/1500 [01:30<00:22, 11.74it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2*sin(S2)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2*sin(S2)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2*sin(S2)/relu(relu(S1))))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(S2)*sig(relu(sig(sig(sig(S2)))))**(S2**S2*_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(_a0_/S2)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(_a0_/S2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2**_a0_/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu(exp(cos(S1 + exp(_a0_*relu(_a0_**_a0_)**2)))))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu(exp(cos(S1 + exp(_a0_*relu(_a0_**_a0_)**2)))))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu(exp(cos(S1 + exp(_a0_*relu(_a0_**_a0_)**2)))))\n", - " 83%|████████▎ | 1243/1500 [01:30<00:22, 11.61it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(log(S1)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(log(S1)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(tan(S1)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(tan(S1)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sig(sqrt(S2/_a0_)*exp(-S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(S2/_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(S2/_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(sin(sinh(relu(S1)))**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(sin(sinh(relu(S1)))**_a0_))\n", - " 83%|████████▎ | 1245/1500 [01:30<00:21, 11.62it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-S2*_a0_/relu(S2 + _a0_)))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-S2*_a0_/relu(S2 + _a0_)))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-S2*_a0_/relu(S2 + _a0_)))\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return relu(relu((sinh(relu(S1**S1))**2)**_a0_))\n", - ":2: RuntimeWarning: overflow encountered in square\n", - " return relu(relu((sinh(relu(S1**S1))**2)**_a0_))\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return relu(relu((sinh(relu(S1**S1))**2)**_a0_))\n", - ":2: RuntimeWarning: overflow encountered in square\n", - " return relu(relu((sinh(relu(S1**S1))**2)**_a0_))\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return relu(relu((sinh(relu(S1**S1))**2)**_a0_))\n", - ":2: RuntimeWarning: overflow encountered in square\n", - " return relu(relu((sinh(relu(S1**S1))**2)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu((_a0_/S2)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu((_a0_/S2)**_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu((sinh(relu(_a0_))**2)**_a0_))\n", - " 83%|████████▎ | 1247/1500 [01:31<00:30, 8.30it/s]:2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(log(S1))**_a0_\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(relu(exp(cos(S1 + exp(relu(relu(cosh(S1)))**2/_a0_)))))\n", - ":2: RuntimeWarning: invalid value encountered in cos\n", - " return relu(relu(exp(cos(S1 + exp(relu(relu(cosh(S1)))**2/_a0_)))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2/_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2/_a0_)**_a0_\n", - " 83%|████████▎ | 1249/1500 [01:31<00:27, 9.23it/s]:2: RuntimeWarning: divide by zero encountered in log\n", - " return log(relu(log(_a0_))/relu(relu(S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(relu(log(_a0_))/relu(relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (relu(relu(S2/relu(_a0_)))/cos(S1))**sig(S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (relu(relu(S2/relu(_a0_)))/cos(S1))**sig(S1)\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(sinh(fac(_a0_))**_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(sinh(fac(_a0_))**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(cos(sinh(relu(S1)))**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(cos(sinh(relu(S1)))**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (relu(relu(S2/relu(_a0_)))/log(S1))**sig(S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (relu(relu(S2/relu(_a0_)))/log(S1))**sig(S1)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(S2 + _a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(S2 + _a0_)**_a0_\n", - " 83%|████████▎ | 1251/1500 [01:31<00:25, 9.96it/s]:2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return exp(-sig(_a0_)/S1)/relu(_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return exp(-sig(_a0_)/S1)/relu(_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return exp(-_a0_**S2/S1)/relu(S1)\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return exp(-_a0_**S2/S1)/relu(S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return exp(-_a0_**S2/S1)/relu(S1)\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return exp(-_a0_**S2/S1)/relu(S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return exp(-_a0_**S2/S1)/relu(S1)\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return exp(-_a0_**S2/S1)/relu(S1)\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(relu(exp(cos(S1 + exp((relu(relu(S2))**2)**_a0_)))))\n", - ":2: RuntimeWarning: invalid value encountered in cos\n", - " return relu(relu(exp(cos(S1 + exp((relu(relu(S2))**2)**_a0_)))))\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(relu(exp(cos(S1 + exp((relu(relu(S2))**2)**_a0_)))))\n", - ":2: RuntimeWarning: invalid value encountered in cos\n", - " return relu(relu(exp(cos(S1 + exp((relu(relu(S2))**2)**_a0_)))))\n", - " 84%|████████▎ | 1253/1500 [01:31<00:23, 10.64it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S2/S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S2/S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*relu(sig(_a0_))**relu(_a0_**S2)))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*relu(sig(_a0_))**relu(_a0_**S2)))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*relu(sig(_a0_))**relu(_a0_**S2)))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return _a0_**((1/2)*_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return _a0_**((1/2)*_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(_a0_/S2)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(_a0_/S2)**_a0_\n", - " 84%|████████▎ | 1255/1500 [01:31<00:22, 10.71it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S1/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S1/relu(relu(S1))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return (relu(relu(S2/relu(_a0_**3)))/relu(S1))**sig(S1)\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return exp(-sig(_a0_)/S1)/relu(_a0_)\n", - " 84%|████████▍ | 1257/1500 [01:32<00:22, 10.98it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(sin(log(S2**2))/sinh(S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(sin(log(S2**2))/sinh(S1))\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return sinh(S2**S2)**_a0_\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return sinh(S2**S2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S1 + _a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S1 + _a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(sin(sinh(relu(S1)))**_a0_))\n", - " 84%|████████▍ | 1259/1500 [01:32<00:20, 11.56it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S1**2/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S1**2/relu(relu(S1))))\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(relu(exp(cos(S1 + exp(fac(S2)*relu(relu(S2))**2)))))\n", - ":2: RuntimeWarning: invalid value encountered in cos\n", - " return relu(relu(exp(cos(S1 + exp(fac(S2)*relu(relu(S2))**2)))))\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(relu(exp(cos(S1 + exp(fac(S2)*relu(relu(S2))**2)))))\n", - ":2: RuntimeWarning: invalid value encountered in cos\n", - " return relu(relu(exp(cos(S1 + exp(fac(S2)*relu(relu(S2))**2)))))\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(relu(exp(cos(S1 + exp(fac(S2)*relu(relu(S2))**2)))))\n", - ":2: RuntimeWarning: invalid value encountered in cos\n", - " return relu(relu(exp(cos(S1 + exp(fac(S2)*relu(relu(S2))**2)))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return (relu(relu(S2/relu(_a0_)))/relu(sin(S2)))**sig(S1)\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return (relu(relu(S2/relu(_a0_)))/relu(sin(S2)))**sig(S1)\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return (relu(relu(S2/relu(_a0_)))/relu(sin(S2)))**sig(S1)\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(sinh(_a0_)))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(sinh(_a0_)))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(sinh(_a0_)))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu((sinh(relu(_a0_/S2))**2)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu((sinh(relu(_a0_/S2))**2)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu((sinh(relu(_a0_/S2))**2)**_a0_))\n", - " 84%|████████▍ | 1261/1500 [01:32<00:20, 11.42it/s]:2: RuntimeWarning: overflow encountered in sinh\n", - " return relu(relu((sinh(S2**S1)**2)**_a0_))\n", - ":2: RuntimeWarning: overflow encountered in square\n", - " return relu(relu((sinh(S2**S1)**2)**_a0_))\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return relu(relu((sinh(S2**S1)**2)**_a0_))\n", - ":2: RuntimeWarning: overflow encountered in square\n", - " return relu(relu((sinh(S2**S1)**2)**_a0_))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return S1**(S1**S1)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return S1**(S1**S1)\n", - " 84%|████████▍ | 1263/1500 [01:32<00:19, 11.95it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S1/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S1/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(sig(log(S2**2))/sinh(S2 + _a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sin(S1)**_a0_)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return sqrt(S2)*_a0_**2/(sqrt(S1**(S1**S2))*abs(relu(fac(S1))))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return sqrt(S2)*_a0_**2/(sqrt(S1**(S1**S2))*abs(relu(fac(S1))))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return sqrt(S2)*_a0_**2/(sqrt(S1**(S1**S2))*abs(relu(fac(S1))))\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(relu(exp(cos(S1 + exp((relu(relu(S2))**2)**_a0_)))))\n", - ":2: RuntimeWarning: invalid value encountered in cos\n", - " return relu(relu(exp(cos(S1 + exp((relu(relu(S2))**2)**_a0_)))))\n", - " 84%|████████▍ | 1265/1500 [01:32<00:19, 12.15it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-cosh(S2)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-cosh(S2)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-cosh(S2)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(exp(cos(S1 + exp(_a0_**S2*relu(relu(S2))**2)))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(exp(cos(S1 + exp(_a0_**S2*relu(relu(S2))**2)))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(exp(cos(S1 + exp(_a0_**S2*relu(relu(S2))**2)))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(cos(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(cos(S1))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(sinh(S1)**(S1**S2))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(sinh(S1)**(S1**S2))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return fac(_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return fac(_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return sinh(relu(S2*_a0_))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return sinh(relu(S2*_a0_))**_a0_\n", - " 84%|████████▍ | 1267/1500 [01:32<00:19, 12.20it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-S2/(_a0_*relu(_a0_))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-S2/(_a0_*relu(_a0_))))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(S1)**(_a0_**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(S1)**(_a0_**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(S1)**(_a0_**_a0_))\n", - " 85%|████████▍ | 1269/1500 [01:33<00:18, 12.62it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S2)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S2)\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-S2/(_a0_*relu(-S1))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-S2/(_a0_*relu(-S1))))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(_a0_**3)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(_a0_**3)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(_a0_/S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(_a0_/S1)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return log(relu(S2)/relu(S2 + _a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return log((relu(relu(S2/relu(_a0_)))/relu(S1))**sig(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sqrt(sig(log(S2*log(S2)))/sinh(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sqrt(sig(log(S2*log(S2)))/sinh(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sqrt(sig(log(S2*log(S2)))/sinh(S1))\n", - " 85%|████████▍ | 1271/1500 [01:33<00:17, 12.78it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(relu(S2)/sin(relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-cos(_a0_)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-cos(_a0_)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-cos(_a0_)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(_a0_**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(_a0_**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_**S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_**S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2*_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2*_a0_)**_a0_\n", - " 85%|████████▍ | 1273/1500 [01:33<00:16, 13.43it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sinh(relu(sqrt(_a0_)))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sinh(relu(sqrt(_a0_)))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(tan(S2)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(tan(S2)/S1)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(tan(S1))**_a0_/(_a0_ + relu(S1)))\n", - " 85%|████████▌ | 1275/1500 [01:33<00:16, 13.31it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(S2)*_a0_**2/(sqrt(tan(S2))*abs(relu(fac(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(S2)*_a0_**2/(sqrt(tan(S2))*abs(relu(fac(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(S2)*_a0_**2/(sqrt(tan(S2))*abs(relu(fac(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu((S2/_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu((S2/_a0_)**_a0_)\n", - " 85%|████████▌ | 1277/1500 [01:33<00:17, 13.00it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-S2/(_a0_*relu(S2 + _a0_))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-S2/(_a0_*relu(S2 + _a0_))))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return -_a0_**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return -_a0_**_a0_\n", - " 85%|████████▌ | 1279/1500 [01:33<00:16, 13.35it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2**_a0_/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(relu(S2)/tan(relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(relu(S2)/tan(relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (-relu(S2/relu(_a0_))/relu(S1))**sig(S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (-relu(S2/relu(_a0_))/relu(S1))**sig(S1)\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(sinh(fac(_a0_))**_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(sinh(fac(_a0_))**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-S2/(_a0_*relu(S1 + _a0_))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-S2/(_a0_*relu(S1 + _a0_))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-S2/(_a0_*relu(S1 + _a0_))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(S1 + _a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(S1 + _a0_)**_a0_)\n", - " 85%|████████▌ | 1281/1500 [01:33<00:15, 13.96it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-1/relu(relu(S1))))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return sqrt(sig(log(log(_a0_)))/sinh(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(log(S2)/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(log(S2)/relu(S1))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return sinh(relu(S1))**(S1**S1)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return sinh(relu(S1))**(S1**S1)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return sinh(relu(S1))**(S1**S1)\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return exp(-sig(_a0_)/S1)/relu(_a0_)\n", - " 86%|████████▌ | 1283/1500 [01:34<00:15, 13.63it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S1/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S1/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return exp(-_a0_**_a0_/S1)/relu(S1)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return exp(-_a0_**_a0_/S1)/relu(S1)\n", - " 86%|████████▌ | 1285/1500 [01:34<00:15, 13.51it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(S1)**(_a0_**S2))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(S1)**(_a0_**S2))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2/(_a0_*log(relu(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu((sinh(_a0_**S1)**2)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu((sinh(_a0_**S1)**2)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu((sinh(_a0_**S1)**2)**_a0_))\n", - " 86%|████████▌ | 1287/1500 [01:34<00:16, 13.09it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-S2/(_a0_*relu(relu(_a0_)))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return sqrt(S2)*_a0_**2/(sqrt(S1**_a0_)*abs(relu(fac(log(_a0_)))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return sqrt(S2)*_a0_**2/(sqrt(S1**_a0_)*abs(relu(fac(log(_a0_)))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return sqrt(S2)*_a0_**2/(sqrt(S1**_a0_)*abs(relu(fac(log(_a0_)))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(relu(S2/_a0_)/sqrt((S1 + _a0_)*(S1**2 + S2))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sin(S1)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu((sinh(relu(_a0_**_a0_))**2)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu((sinh(relu(_a0_**_a0_))**2)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-S2/(_a0_*relu(_a0_))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-S2/(_a0_*relu(_a0_))))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu((sinh(relu(_a0_))**2)**_a0_))\n", - " 86%|████████▌ | 1289/1500 [01:34<00:16, 12.63it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S1/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S1/relu(relu(S1))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return sqrt(S2)*_a0_**2/(sqrt(S1**_a0_)*abs(relu(fac(cos(S2)))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return sqrt(S2)*_a0_**2/(sqrt(S1**_a0_)*abs(relu(fac(cos(S2)))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return sqrt(S2)*_a0_**2/(sqrt(S1**_a0_)*abs(relu(fac(cos(S2)))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(cos(log(S2**2))/sinh(S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(cos(log(S2**2))/sinh(S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return cos(relu(S1))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return cos(relu(S1))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S1**(-S1)*S2/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S1**(-S1)*S2/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S1**(-S1)*S2/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return (2*_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return (2*_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu((sinh(relu(relu(_a0_)))**2)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu((sinh(relu(relu(_a0_)))**2)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu((sinh(relu(relu(_a0_)))**2)**_a0_))\n", - " 86%|████████▌ | 1291/1500 [01:34<00:16, 12.78it/s]:2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(_a0_**_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(_a0_**_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S1/_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S1/_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(cos(S1)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(cos(S1)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(cos(S1)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-tan(_a0_)/(_a0_*relu(relu(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-tan(_a0_)/(_a0_*relu(relu(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-tan(_a0_)/(_a0_*relu(relu(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(S2/_a0_)*exp(-S2 - _a0_)\n", - " 86%|████████▌ | 1293/1500 [01:34<00:15, 13.35it/s]:2: RuntimeWarning: overflow encountered in power\n", - " return (S2/_a0_ + sin((2*S1 + S2 + sin(S1*S2))**(S1**S2)))*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in sin\n", - " return (S2/_a0_ + sin((2*S1 + S2 + sin(S1*S2))**(S1**S2)))*exp(-S1)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return (S2/_a0_ + sin((2*S1 + S2 + sin(S1*S2))**(S1**S2)))*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in sin\n", - " return (S2/_a0_ + sin((2*S1 + S2 + sin(S1*S2))**(S1**S2)))*exp(-S1)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return (S2/_a0_ + sin((2*S1 + S2 + sin(S1*S2))**(S1**S2)))*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in sin\n", - " return (S2/_a0_ + sin((2*S1 + S2 + sin(S1*S2))**(S1**S2)))*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return tan(relu(S1))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return cos(S1)**_a0_\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(relu(exp(fac(S1 + exp(relu(relu(S2))**2/_a0_)))))\n", - " 86%|████████▋ | 1295/1500 [01:35<00:15, 13.63it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return relu((S1/_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu((S1/_a0_)**_a0_)\n", - " 86%|████████▋ | 1297/1500 [01:35<00:17, 11.93it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(S2*_a0_)/S1**3\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2/_a0_ + sin((2*S1 + S2 + sin(S2/S1))**_a0_))*exp(-S1)\n", - " 87%|████████▋ | 1299/1500 [01:35<00:16, 12.46it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(sin(S2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(sin(S2))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2**_a0_/relu(relu(S1))))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - " 87%|████████▋ | 1301/1500 [01:35<00:15, 12.89it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return relu(tan(S2)**_a0_/(_a0_ + relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(tan(S2)**_a0_/(_a0_ + relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(S2*sin(S2))*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(S2*sin(S2))*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(S2*sin(S2))*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(_a0_)**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return exp(-_a0_**(-S2)*sig(_a0_))/relu(S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return exp(-_a0_**(-S2)*sig(_a0_))/relu(S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return exp(-_a0_**(-S2)*sig(_a0_))/relu(S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(exp(cos(S1 + exp(relu(_a0_**S1)**2/_a0_)))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(exp(cos(S1 + exp(relu(_a0_**S1)**2/_a0_)))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(exp(cos(S1 + exp(relu(_a0_**S1)**2/_a0_)))))\n", - " 87%|████████▋ | 1303/1500 [01:35<00:16, 12.24it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2/(S1*relu(relu(S1)))))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu((sinh(relu(_a0_))**2)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(log(-_a0_**S2/(_a0_*relu(relu(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-_a0_**S2/(_a0_*relu(relu(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(log(-_a0_**S2/(_a0_*relu(relu(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-_a0_**S2/(_a0_*relu(relu(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(log(-_a0_**S2/(_a0_*relu(relu(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-_a0_**S2/(_a0_*relu(relu(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(_a0_**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(_a0_**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - " 87%|████████▋ | 1305/1500 [01:35<00:15, 12.67it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2/(relu(relu(S1))*log(_a0_))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2/(relu(relu(S1))*log(_a0_))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2/(relu(relu(S1))*log(_a0_))))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(sin(_a0_))**_a0_/(_a0_ + relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return tan(S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return tan(S1)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu((sinh(relu(S2*_a0_))**2)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu((sinh(relu(S2*_a0_))**2)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu((sinh(relu(S2*_a0_))**2)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-sinh(S2)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-sinh(S2)/relu(relu(S1))))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return sinh(relu(tan(S2)))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return sinh(relu(tan(S2)))**_a0_\n", - " 87%|████████▋ | 1307/1500 [01:36<00:15, 12.15it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return (-sinh(S1))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2/(_a0_**2*relu(relu(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2/(_a0_**2*relu(relu(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (-sinh(S1))**_a0_\n", - " 87%|████████▋ | 1309/1500 [01:36<00:15, 12.70it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(S2/log(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(S2/log(S1))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(sqrt(S2)*_a0_**2/(sqrt(S1**_a0_)*abs(relu(tan(S1)))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(sqrt(S2)*_a0_**2/(sqrt(S1**_a0_)*abs(relu(tan(S1)))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return (relu(relu(S2/relu(_a0_)))/S2)**sig(S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(log(S1)**_a0_)**2\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(log(S1)**_a0_)**2\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S1/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S1/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return exp(-sig(_a0_)/log(_a0_))/relu(S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return exp(-sig(_a0_)/log(_a0_))/relu(S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return exp(-sig(_a0_)/log(_a0_))/relu(S1)\n", - " 87%|████████▋ | 1311/1500 [01:36<00:14, 13.09it/s]:2: RuntimeWarning: overflow encountered in exp\n", - " return relu(relu(exp(cos(S1 + exp((relu(relu(S2))**2)**_a0_)))))\n", - ":2: RuntimeWarning: invalid value encountered in cos\n", - " return relu(relu(exp(cos(S1 + exp((relu(relu(S2))**2)**_a0_)))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2/_a0_ + sin((S1 + (S1 + S2)*sin(S1*S2))**_a0_))*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2/_a0_ + sin((S1 + (S1 + S2)*sin(S1*S2))**_a0_))*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(tan(log(S2**2))/sinh(S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(tan(log(S2**2))/sinh(S1))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(sinh(S1)**(S1**S2))**2\n", - ":2: RuntimeWarning: overflow encountered in square\n", - " return relu(sinh(S1)**(S1**S2))**2\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(sinh(S1)**(S1**S2))**2\n", - ":2: RuntimeWarning: overflow encountered in square\n", - " return relu(sinh(S1)**(S1**S2))**2\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(sinh(S1)**(S1**S2))**2\n", - ":2: RuntimeWarning: overflow encountered in square\n", - " return relu(sinh(S1)**(S1**S2))**2\n", - " 88%|████████▊ | 1313/1500 [01:36<00:14, 12.98it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(S2/_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(S2/_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(sin(S2)/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(sin(S2)/relu(S1))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return sinh(relu(sin(S1)))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return sinh(relu(sin(S1)))**_a0_\n", - " 88%|████████▊ | 1315/1500 [01:36<00:14, 12.50it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2**_a0_/relu(relu(S1))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return exp(-sig(_a0_)/S1)/relu(_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(relu(exp(cos(S1 + exp(relu(relu(log(_a0_)))**2/_a0_)))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(relu(exp(cos(S1 + exp(relu(relu(log(_a0_)))**2/_a0_)))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(relu(exp(cos(S1 + exp(relu(relu(log(_a0_)))**2/_a0_)))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return cos(S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(relu(log(cos(S1 + exp(relu(relu(S2))**2/_a0_)))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(relu(log(cos(S1 + exp(relu(relu(S2))**2/_a0_)))))\n", - " 88%|████████▊ | 1317/1500 [01:36<00:14, 12.84it/s]:2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu((_a0_**_a0_)**_a0_)**2\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu((_a0_**_a0_)**_a0_)**2\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu((_a0_**_a0_)**_a0_)**2\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(sqrt(S2)*_a0_**2/(sqrt(-S2)*abs(relu(fac(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(sqrt(S2)*_a0_**2/(sqrt(-S2)*abs(relu(fac(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(sqrt(S2)*_a0_**2/(sqrt(-S2)*abs(relu(fac(S1)))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return (relu(relu(S2/relu(_a0_)))/relu(exp(S2)))**sig(S1)\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return sinh(relu(_a0_))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(sin(S1))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(sin(S1))**_a0_\n", - " 88%|████████▊ | 1319/1500 [01:36<00:13, 12.94it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(relu((sinh(S1)**2)**(_a0_**S1))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(relu((sinh(S1)**2)**(_a0_**S1))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(relu((sinh(S1)**2)**(_a0_**S1))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(S1)**(_a0_**S2))**2\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(S1)**(_a0_**S2))**2\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(S1)**(_a0_**S2))**2\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return exp(-S1)*sqrt(tan(S2))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return exp(-S1)*sqrt(tan(S2))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return exp(-S1)*sqrt(tan(S2))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return sinh(relu(_a0_))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(log(S1))**_a0_)**2\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(log(S1))**_a0_)**2\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(log(S1))**_a0_)**2\n", - " 88%|████████▊ | 1321/1500 [01:37<00:13, 13.22it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2*exp(-_a0_)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2*exp(-_a0_)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2*exp(-_a0_)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (-sinh(S1))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return exp(-sig(_a0_)/S1)/relu(S1/_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return exp(-sig(_a0_)/S1)/relu(S1/_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return exp(-sig(_a0_)/S1)/relu(S1/_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(tan(S1)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(tan(S1)/S1)\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(relu(exp(cos(S1 + exp(relu(relu(S2))**2/relu(_a0_))))))\n", - ":2: RuntimeWarning: invalid value encountered in cos\n", - " return relu(relu(exp(cos(S1 + exp(relu(relu(S2))**2/relu(_a0_))))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(relu(exp(cos(S1 + exp(relu(relu(S2))**2/relu(_a0_))))))\n", - ":2: RuntimeWarning: invalid value encountered in cos\n", - " return relu(relu(exp(cos(S1 + exp(relu(relu(S2))**2/relu(_a0_))))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(relu(exp(cos(S1 + exp(relu(relu(S2))**2/relu(_a0_))))))\n", - ":2: RuntimeWarning: invalid value encountered in cos\n", - " return relu(relu(exp(cos(S1 + exp(relu(relu(S2))**2/relu(_a0_))))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_**S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_**S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return (_a0_**_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return (_a0_**_a0_)**_a0_\n", - " 88%|████████▊ | 1323/1500 [01:37<00:14, 12.56it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(sqrt(S2)*_a0_**2/(sqrt(S1**_a0_)*abs(relu(fac(log(S2))))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(sqrt(S2)*_a0_**2/(sqrt(S1**_a0_)*abs(relu(fac(log(S2))))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(sqrt(S2)*_a0_**2/(sqrt(S1**_a0_)*abs(relu(fac(log(S2))))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return _a0_*(relu(relu(S2/relu(_a0_)))/relu(S1))**sig(S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(S2/log(S1))\n", - " 88%|████████▊ | 1325/1500 [01:37<00:13, 13.41it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-sig(_a0_)/S1)/relu(S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-sig(_a0_)/S1)/relu(S1)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(log(-_a0_**_a0_/(_a0_*relu(relu(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(log(-_a0_**_a0_/(_a0_*relu(relu(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(log(-_a0_**_a0_/(_a0_*relu(relu(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(S2)*log(sig(relu(_a0_)))**(S1*_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(S2)*log(sig(relu(_a0_)))**(S1*_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S1/_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S1/_a0_)**_a0_\n", - " 88%|████████▊ | 1327/1500 [01:37<00:13, 12.66it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", - " return log(S2/relu(S2 + _a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return (relu(relu(S2/relu(_a0_)))/relu(-S2))**sig(S1)\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return (relu(relu(S2/relu(_a0_)))/relu(-S2))**sig(S1)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return sinh(relu(relu(S1*_a0_)))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return sinh(relu(relu(S1*_a0_)))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return sinh(relu(relu(S1*_a0_)))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return sinh(relu(_a0_))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return sinh(relu(_a0_))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(_a0_**_a0_)**_a0_)**2\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(_a0_**_a0_)**_a0_)**2\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(_a0_**_a0_)**_a0_)**2\n", - " 89%|████████▊ | 1329/1500 [01:37<00:13, 12.91it/s]:2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return sinh(relu(_a0_))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return sinh(relu(_a0_))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return log(S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(cos(S1))**_a0_)**2\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(cos(S1))**_a0_)**2\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(cos(S1))**_a0_)**2\n", - " 89%|████████▊ | 1331/1500 [01:37<00:12, 13.63it/s]:2: RuntimeWarning: overflow encountered in exp\n", - " return relu(relu(exp(cos(S1 + exp(relu(S1**S1)**2/_a0_)))))\n", - ":2: RuntimeWarning: invalid value encountered in cos\n", - " return relu(relu(exp(cos(S1 + exp(relu(S1**S1)**2/_a0_)))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(log(-(S2/_a0_)**relu(relu(S1))))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(sinh(S1)**(S1**S1))**2\n", - ":2: RuntimeWarning: overflow encountered in square\n", - " return relu(sinh(S1)**(S1**S1))**2\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(sinh(S1)**(S1**S1))**2\n", - ":2: RuntimeWarning: overflow encountered in square\n", - " return relu(sinh(S1)**(S1**S1))**2\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(sinh(S1)**(S1**S1))**2\n", - ":2: RuntimeWarning: overflow encountered in square\n", - " return relu(sinh(S1)**(S1**S1))**2\n", - " 89%|████████▉ | 1333/1500 [01:38<00:12, 13.48it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S1/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S1/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(sqrt(S2)*relu(_a0_)**2/(sqrt(log(S1))*abs(relu(fac(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(sqrt(S2)*relu(_a0_)**2/(sqrt(log(S1))*abs(relu(fac(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(sqrt(S2)*relu(_a0_)**2/(sqrt(log(S1))*abs(relu(fac(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sqrt(sig(log(sin(S2)))/sinh(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sqrt(sig(log(sin(S2)))/sinh(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sqrt(sig(log(sin(S2)))/sinh(S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*relu(_a0_**S1)**S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(S2*relu(_a0_**S1)**S1))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return sinh(relu(relu(_a0_)))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return sinh(relu(relu(_a0_)))**_a0_\n", - " 89%|████████▉ | 1335/1500 [01:38<00:12, 12.94it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-S2/(_a0_*relu(relu(-S2)))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-S2/(_a0_*relu(relu(-S2)))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-S2/(_a0_*relu(relu(-S2)))))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return sinh(relu(log(S1)))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return sinh(relu(log(S1)))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(S2*relu(sqrt(_a0_))**S1))\n", - " 89%|████████▉ | 1337/1500 [01:38<00:12, 13.01it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(sqrt(S2)*relu(_a0_)**2/(sqrt(log(S2))*abs(relu(fac(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(sqrt(S2)*relu(_a0_)**2/(sqrt(log(S2))*abs(relu(fac(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(sqrt(S2)*relu(_a0_)**2/(sqrt(log(S2))*abs(relu(fac(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(relu(S2/_a0_)/sqrt(S1*(S1**2 + cos(_a0_)))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(relu(S2/_a0_)/sqrt(S1*(S1**2 + cos(_a0_)))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(relu(S2/_a0_)/sqrt(S1*(S1**2 + cos(_a0_)))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return (relu(relu(S2/relu(_a0_)))/relu(S2**S1))**sig(S1)\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return exp(-sig(_a0_)/S1)/relu(_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return cos(S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2/(_a0_*sin(relu(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sin(S2)**_a0_/(_a0_ + relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sin(S2)**_a0_/(_a0_ + relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_**_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_**_a0_)**_a0_\n", - " 89%|████████▉ | 1339/1500 [01:38<00:12, 12.97it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-1/relu(relu(S1))))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return sinh(relu(_a0_))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return sinh(relu(_a0_))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S1/_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S1/_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return cos(S2)**_a0_/(_a0_ + relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return cos(S2)**_a0_/(_a0_ + relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sinh(relu(relu(S1)))**(sqrt(_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sinh(relu(relu(S1)))**(sqrt(_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sinh(relu(relu(S1)))**(sqrt(_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2 + _a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2 + _a0_)**_a0_\n", - " 89%|████████▉ | 1341/1500 [01:38<00:11, 13.57it/s]:2: RuntimeWarning: overflow encountered in sinh\n", - " return sinh(relu(relu(S2**S2)))**_a0_\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return sinh(relu(relu(S2**S2)))**_a0_\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return sinh(relu(relu(S2**S2)))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-S2/(_a0_*relu(relu(_a0_)))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(cos(log(S2**2))/sinh(S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-S1*S2)*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-S1*S2)*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-S1*S2)*exp(-S1)\n", - " 90%|████████▉ | 1343/1500 [01:38<00:11, 13.44it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-(S2 + _a0_)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(cos(S1))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(cos(S1))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (-sinh(S2))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (-sinh(S2))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2/_a0_ + sin((S1 + sin(S1*relu(_a0_))**(S1 + S2))**_a0_))*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2/_a0_ + sin((S1 + sin(S1*relu(_a0_))**(S1 + S2))**_a0_))*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(S1*_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(S1*_a0_)**_a0_\n", - " 90%|████████▉ | 1345/1500 [01:38<00:12, 12.29it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return exp(-S1)*sin((2*S1 + S2 + sin(S1*relu(_a0_)))**_a0_)**(S2/_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return exp(-S1)*sin((2*S1 + S2 + sin(S1*relu(_a0_)))**_a0_)**(S2/_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(sqrt(S2)*relu(_a0_)**2/(sqrt(-S2)*abs(relu(fac(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(sqrt(S2)*relu(_a0_)**2/(sqrt(-S2)*abs(relu(fac(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(sqrt(S2)*relu(_a0_)**2/(sqrt(-S2)*abs(relu(fac(S1)))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return (S2**(-S1)*relu(relu(S2/relu(_a0_))))**sig(S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(log(S1))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(log(S1))**_a0_\n", - " 90%|████████▉ | 1347/1500 [01:39<00:12, 12.57it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(cos(S2))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(cos(S2))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(cos(log(S2**2))/sinh(S1))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return exp(-sig(_a0_)/S1)/relu(log(S1))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return exp(-sig(_a0_)/S1)/relu(log(S1))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return exp(-sig(_a0_)/S1)/relu(log(S1))\n", - " 90%|████████▉ | 1349/1500 [01:39<00:11, 13.00it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(S2/cos(S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu((sinh(_a0_**S2)**2)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu((sinh(_a0_**S2)**2)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu((sinh(_a0_**S2)**2)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-S2/(_a0_*relu(relu(_a0_)))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_**S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_**S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_/S2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_/S2)**_a0_\n", - " 90%|█████████ | 1351/1500 [01:39<00:11, 13.19it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(sin(S2)/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(sin(S2)/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(cos(S2)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(cos(S2)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-_a0_**2/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(sqrt(S2)*relu(_a0_)**2/(sqrt(-S1)*abs(relu(fac(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(sqrt(S2)*relu(_a0_)**2/(sqrt(-S1)*abs(relu(fac(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(sqrt(S2)*relu(_a0_)**2/(sqrt(-S1)*abs(relu(fac(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return log(S1)**_a0_\n", - " 90%|█████████ | 1353/1500 [01:39<00:11, 12.88it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(S2/tan(S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_/S1)**_a0_/(_a0_ + relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-S1)*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-S1)*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-S1)*exp(-S1)\n", - " 90%|█████████ | 1355/1500 [01:39<00:11, 13.08it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_/S2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_/S2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S1*S2/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S1*S2/relu(relu(S1))))\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return relu(sinh(S2**S2)**(-_a0_))**2\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return relu(sinh(S2**S2)**(-_a0_))**2\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return relu(sinh(S2**S2)**(-_a0_))**2\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(S1)**(_a0_**S2)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(S1)**(_a0_**S2)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(S1)**(_a0_**S2)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu((sinh(S1)**2)**(_a0_**S2)))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu((sinh(S1)**2)**(_a0_**S2)))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu((sinh(S1)**2)**(_a0_**S2)))\n", - " 90%|█████████ | 1357/1500 [01:39<00:10, 13.46it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return relu(log(-S2*_a0_/relu(_a0_**S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-S2*_a0_/relu(_a0_**S1)))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(log(-S2*_a0_/relu(_a0_**S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-S2*_a0_/relu(_a0_**S1)))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(log(-S2*_a0_/relu(_a0_**S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-S2*_a0_/relu(_a0_**S1)))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_/S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_/S1)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-S2*_a0_/relu(relu(2*_a0_))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-S2*_a0_/relu(relu(2*_a0_))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-S2*_a0_/relu(relu(2*_a0_))))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(sinh(_a0_)**(-_a0_))**2\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(S1*_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(S1*_a0_)**_a0_\n", - " 91%|█████████ | 1359/1500 [01:40<00:10, 13.67it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return relu(_a0_**S2)**_a0_/(_a0_ + relu(S1))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(_a0_**S2)**_a0_/(_a0_ + relu(S1))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return sinh(relu(_a0_))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return sinh(relu(_a0_))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(log(S1))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(log(S1))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S1 + _a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S1 + _a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return exp(-sig(_a0_)/S1)/relu(log(S1))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return exp(-sig(_a0_)/S1)/relu(log(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2*tanh(S1)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2*tanh(S1)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2*tanh(S1)/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (relu(relu(S2/relu(_a0_)))/log(S1))**sig(S1)\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(sinh(relu(_a0_)))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(sinh(relu(_a0_)))**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(S1)**(_a0_**_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(S1)**(_a0_**_a0_)\n", - " 91%|█████████ | 1361/1500 [01:40<00:10, 13.71it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(cos(S2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(cos(S2))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(relu(relu(sinh(S1))**(S2**S2)))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(relu(relu(sinh(S1))**(S2**S2)))\n", - " 91%|█████████ | 1363/1500 [01:40<00:09, 13.73it/s]:2: RuntimeWarning: divide by zero encountered in log\n", - " return relu(log(fac(S2/(_a0_*relu(relu(S1))))))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return relu(log(fac(S2/(_a0_*relu(relu(S1))))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(sqrt(S2)*relu(_a0_)**2/(sqrt(S1**_a0_)*abs(relu(fac(tan(S2))))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(sqrt(S2)*relu(_a0_)**2/(sqrt(S1**_a0_)*abs(relu(fac(tan(S2))))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(sqrt(S2)*relu(_a0_)**2/(sqrt(S1**_a0_)*abs(relu(fac(tan(S2))))))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return sinh(relu(relu(S1/_a0_)))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return sinh(relu(relu(S1/_a0_)))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return sinh(relu(relu(S1/_a0_)))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_**S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_**S1)**_a0_\n", - " 91%|█████████ | 1365/1500 [01:40<00:09, 13.57it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(tan(S1))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(tan(S1))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(tan(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(tan(S1))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-S2/(_a0_*relu(log(S1)))))\n", - " 91%|█████████ | 1367/1500 [01:40<00:09, 14.16it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return (S1*_a0_)**_a0_/(_a0_ + relu(S1))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return sinh(relu(_a0_))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return sinh(relu(_a0_))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(_a0_)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(_a0_)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_**3)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_**3)**_a0_\n", - " 91%|█████████▏| 1369/1500 [01:40<00:09, 14.08it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(log(S2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(log(S2))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(tan(S1))**_a0_/(_a0_ + relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(relu(S2/_a0_)/sqrt(S1*(S2 + tan(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(relu(S2/_a0_)/sqrt(S1*(S2 + tan(S1)))))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return sinh(relu(_a0_/S2))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return sinh(relu(_a0_/S2))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return sinh(relu(_a0_/S2))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(exp(cos(S1 + exp(relu(_a0_**S2)**2/_a0_)))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(exp(cos(S1 + exp(relu(_a0_**S2)**2/_a0_)))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(exp(cos(S1 + exp(relu(_a0_**S2)**2/_a0_)))))\n", - " 91%|█████████▏| 1371/1500 [01:40<00:09, 14.29it/s]:2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return sinh(relu(relu(2*_a0_)))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return sinh(relu(relu(2*_a0_)))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return sinh(relu(relu(2*_a0_)))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S1*_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S1*_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return exp(-_a0_**S2/S1)/relu(S1)\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return exp(-_a0_**S2/S1)/relu(S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return exp(-_a0_**S2/S1)/relu(S1)\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return exp(-_a0_**S2/S1)/relu(S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(S2/sin(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S1/relu(relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S1/relu(relu(S1))))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(sinh(S1)**(S2**S2))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(sinh(S1)**(S2**S2))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(sinh(S1)**(S2**S2))\n", - " 92%|█████████▏| 1373/1500 [01:41<00:09, 13.60it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-S2/(_a0_*relu(relu(_a0_)))))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(sinh(tan(S2)))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(sinh(tan(S2)))**_a0_))\n", - " 92%|█████████▏| 1375/1500 [01:41<00:08, 14.26it/s]:2: RuntimeWarning: invalid value encountered in scalar power\n", - " return _a0_**_a0_/(_a0_ + relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sinh(S1)**(-_a0_**S2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(cos(S2/(_a0_*relu(relu(S1))))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(cos(S2/(_a0_*relu(relu(S1))))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return exp(-S1)*sqrt(log(_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return exp(-S1)*sqrt(log(_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S1*_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S1*_a0_)**_a0_\n", - " 92%|█████████▏| 1377/1500 [01:41<00:08, 14.09it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-S2/(_a0_*relu(relu(_a0_)))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (relu(relu(S2/relu(_a0_)))/tan(S1))**sig(S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (relu(relu(S2/relu(_a0_)))/tan(S1))**sig(S1)\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(_a0_)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(_a0_)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - " 92%|█████████▏| 1379/1500 [01:41<00:08, 14.09it/s]:2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-1/relu(relu(S1))))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return sinh(relu(relu(_a0_)))**_a0_\n", - " 92%|█████████▏| 1381/1500 [01:41<00:08, 14.28it/s]:2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return sinh(relu(_a0_))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return sinh(relu(_a0_))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (-sinh(relu(S1)))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (-sinh(relu(S1)))**_a0_\n", - " 92%|█████████▏| 1383/1500 [01:41<00:08, 13.97it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2/(_a0_*cos(relu(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(_a0_**S2)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(_a0_**S2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(_a0_**S2)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(_a0_**S2)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(sqrt(S2)*relu(_a0_)**2/(sqrt(S1**_a0_)*abs(relu(fac(sin(S1))))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(sqrt(S2)*relu(_a0_)**2/(sqrt(S1**_a0_)*abs(relu(fac(sin(S1))))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(sqrt(S2)*relu(_a0_)**2/(sqrt(S1**_a0_)*abs(relu(fac(sin(S1))))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2 + _a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2 + _a0_)**_a0_\n", - " 92%|█████████▏| 1385/1500 [01:41<00:08, 13.44it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2/(S1*relu(relu(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S1/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S1/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S1/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return -sqrt(S2*_a0_)/S1\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return exp(-sig(_a0_)/S1)/relu(_a0_)\n", - " 92%|█████████▏| 1387/1500 [01:42<00:08, 13.34it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(sqrt(S2)*relu(_a0_)**2/(sqrt(-S2)*abs(relu(fac(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(sqrt(S2)*relu(_a0_)**2/(sqrt(-S2)*abs(relu(fac(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return tan(S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-tan(S2)/(_a0_*relu(relu(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-tan(S2)/(_a0_*relu(relu(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-tan(S2)/(_a0_*relu(relu(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (-sinh(S1))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (-sinh(S1))**_a0_\n", - " 93%|█████████▎| 1389/1500 [01:42<00:08, 13.33it/s]:2: RuntimeWarning: divide by zero encountered in log\n", - " return log(log(_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(log(_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(log(_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(_a0_**S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(_a0_**S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (S2/_a0_ + sin((2*S1 + S2 + sqrt(-S1*_a0_))**_a0_))*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (S2/_a0_ + sin((2*S1 + S2 + sqrt(-S1*_a0_))**_a0_))*exp(-S1)\n", - " 93%|█████████▎| 1391/1500 [01:42<00:08, 13.01it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(cos(S1)/S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(cos(S1)/S1)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(_a0_/S2)**_a0_/(_a0_ + relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2/((S1 + _a0_)*relu(relu(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2/((S1 + _a0_)*relu(relu(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2/((S1 + _a0_)*relu(relu(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(cos(log(S2**3))/sinh(S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(cos(log(S2**3))/sinh(S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2*_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2*_a0_)**_a0_\n", - " 93%|█████████▎| 1393/1500 [01:42<00:08, 13.19it/s]:2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(log(S1))**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(_a0_**S2)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(_a0_**S2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(_a0_**S2)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(_a0_**S2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2/((S1 + S2)*relu(relu(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2/((S1 + S2)*relu(relu(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2/((S1 + S2)*relu(relu(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(S2/tan(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sqrt(sig(log(cos(S2)))/sinh(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sqrt(sig(log(cos(S2)))/sinh(S1))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(sinh(_a0_))**_a0_))\n", - " 93%|█████████▎| 1395/1500 [01:42<00:07, 13.83it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2/(S1*relu(relu(S1)))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return ((1/2)*relu(relu(S2/relu(_a0_)))/_a0_)**sig(S1)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return sinh(relu(S1 + _a0_))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return sinh(relu(S1 + _a0_))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return sinh(relu(S1 + _a0_))**_a0_\n", - " 93%|█████████▎| 1397/1500 [01:42<00:07, 14.04it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2/(S1*relu(relu(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S1 + _a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S1 + _a0_)**_a0_\n", - " 93%|█████████▎| 1399/1500 [01:42<00:07, 14.24it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(sig(log(S2**3))/sinh(sin(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(sig(log(S2**3))/sinh(sin(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(sig(log(S2**3))/sinh(sin(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sinh(relu(relu(log(_a0_))))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sinh(relu(relu(log(_a0_))))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sinh(relu(relu(log(_a0_))))**_a0_\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return sinh(S1)**(S1**S2)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return sinh(S1)**(S1**S2)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return sinh(S1)**(S1**S2)\n", - " 93%|█████████▎| 1401/1500 [01:43<00:07, 13.92it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_/S2)**_a0_/(_a0_ + relu(S1))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(relu(relu(S2/_a0_)/sqrt(S1*(-S1 + S2))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(relu(relu(S2/_a0_)/sqrt(S1*(-S1 + S2))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sin(S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(S2/cos(S2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(S2/cos(S2))\n", - " 94%|█████████▎| 1403/1500 [01:43<00:07, 13.45it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S1/relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S1/relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S1/relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(relu(S2/_a0_)/sqrt(S1*(S1**2 - _a0_))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(relu(S2/_a0_)/sqrt(S1*(S1**2 - _a0_))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(relu(S2/_a0_)/sqrt(S1*(S1**2 - _a0_))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S1/_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S1/_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return sinh(relu(S2*_a0_))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return sinh(relu(S2*_a0_))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return log(S2/relu(S1 + _a0_))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(sqrt(S2)*relu(_a0_)**2/(sqrt(-S2)*abs(relu(fac(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(sqrt(S2)*relu(_a0_)**2/(sqrt(-S2)*abs(relu(fac(S1)))))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return sinh(relu(_a0_))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return sinh(relu(_a0_))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sin(S1)**_a0_\n", - " 94%|█████████▎| 1405/1500 [01:43<00:07, 12.85it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(sqrt(S2)*relu(_a0_)**2/(sqrt(sin(S2))*abs(relu(fac(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(sqrt(S2)*relu(_a0_)**2/(sqrt(sin(S2))*abs(relu(fac(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(sqrt(S2)*relu(_a0_)**2/(sqrt(sin(S2))*abs(relu(fac(S1)))))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return sinh(relu(_a0_))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return sinh(relu(_a0_))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return sinh(relu(relu(_a0_)))**_a0_\n", - " 94%|█████████▍| 1407/1500 [01:43<00:07, 13.16it/s]:2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return sinh(relu(relu(tanh(_a0_))))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return sinh(relu(relu(tanh(_a0_))))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return sinh(relu(relu(tanh(_a0_))))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(S1*_a0_)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(S1*_a0_)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return exp(-_a0_**S1/S1)/relu(S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return exp(-_a0_**S1/S1)/relu(S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return exp(-_a0_**S1/S1)/relu(S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2))\n", - " 94%|█████████▍| 1409/1500 [01:43<00:07, 12.81it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", - " return (S1**(-S1)*relu(relu(S2/relu(_a0_))))**sig(S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sin(S1)**(2*_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sin(S1)**(2*_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return sinh(relu(_a0_))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return sinh(relu(_a0_))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sin(S1)**_a0_\n", - " 94%|█████████▍| 1411/1500 [01:43<00:07, 11.90it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2**2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2**2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2**2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu(exp(cos(_a0_**_a0_ + exp(relu(relu(S2))**2/_a0_)))))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu(exp(cos(_a0_**_a0_ + exp(relu(relu(S2))**2/_a0_)))))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(relu(exp(cos(_a0_**_a0_ + exp(relu(relu(S2))**2/_a0_)))))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(_a0_)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(_a0_)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(S2/log(S2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(S2/log(S2))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return cos(S1)**_a0_\n", - " 94%|█████████▍| 1413/1500 [01:44<00:06, 12.50it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(sin(sinh(S1))**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(sinh(S1)/_a0_)*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S1/_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S1/_a0_)**_a0_\n", - " 94%|█████████▍| 1415/1500 [01:44<00:06, 12.86it/s]:2: RuntimeWarning: invalid value encountered in scalar power\n", - " return (_a0_**(-_a0_)*relu(relu(S2/relu(_a0_))))**sig(S1)\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return (_a0_**(-_a0_)*relu(relu(S2/relu(_a0_))))**sig(S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(sig(log(S2**3))/sinh(S2 + _a0_))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return exp(-S1)*sqrt(log(S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return exp(-S1)*sqrt(log(S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return exp(-S1)*sqrt(log(S1))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_**3)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_**3)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return _a0_**(2*_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return _a0_**(2*_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return _a0_**(2*_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(_a0_**S2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(_a0_**S2)**_a0_\n", - " 94%|█████████▍| 1417/1500 [01:44<00:09, 8.63it/s]:2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return sinh(relu(relu(_a0_)))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(_a0_/relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(_a0_/relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(_a0_/relu(S1)))\n", - " 95%|█████████▍| 1419/1500 [01:44<00:08, 9.36it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2/relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2/relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2/relu(S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(relu(relu(sinh(_a0_))**_a0_))\n", - " 95%|█████████▍| 1421/1500 [01:44<00:07, 10.16it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(_a0_/S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(_a0_/S1)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(log(S2/S1))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(relu(S2*relu(log(_a0_))**S1))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return sinh(relu(S2 + _a0_))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return sinh(relu(S2 + _a0_))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(S2 + _a0_)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(S2 + _a0_)**_a0_))\n", - " 95%|█████████▍| 1423/1500 [01:45<00:07, 10.99it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(S2/log(S1))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**(2*_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**(2*_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(S1*_a0_)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(relu(relu(S1*_a0_)**_a0_))\n", - " 95%|█████████▌| 1425/1500 [01:45<00:06, 11.53it/s]:2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return sinh(relu(_a0_))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return sinh(relu(_a0_))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(sqrt(S2)*relu(_a0_)**2/(sqrt(relu(fac(S1)))*sqrt(cos(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(sqrt(S2)*relu(_a0_)**2/(sqrt(relu(fac(S1)))*sqrt(cos(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(sqrt(S2)*relu(_a0_)**2/(sqrt(relu(fac(S1)))*sqrt(cos(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(relu(S2/_a0_)/sqrt(S1*(S2 + log(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(relu(S2/_a0_)/sqrt(S1*(S2 + log(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(_a0_/S2)**(2*_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(_a0_/S2)**(2*_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(_a0_/S2)**(2*_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(relu(S2*relu(sig(log(_a0_)))**S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(relu(S2*relu(sig(log(_a0_)))**S1))\n", - " 95%|█████████▌| 1427/1500 [01:45<00:06, 12.04it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(cos(_a0_)/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2 + _a0_)**(2*_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2 + _a0_)**(2*_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2 + _a0_)**(2*_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sqrt(relu(sinh(_a0_**S2))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sqrt(relu(sinh(_a0_**S2))**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sqrt(relu(sinh(_a0_**S2))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sqrt(relu(sinh(_a0_**S2))**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sqrt(relu(sinh(_a0_**S2))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sqrt(relu(sinh(_a0_**S2))**_a0_))\n", - " 95%|█████████▌| 1429/1500 [01:45<00:05, 12.23it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2*_a0_/tan(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2*_a0_/tan(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return cos(S2)**_a0_/(_a0_ + relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_**S2)**(2*_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_**S2)**(2*_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_**S2)**(2*_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return sinh(relu(_a0_))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return sinh(relu(_a0_))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(S2 + _a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(S2 + _a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_/S2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_/S2)**_a0_\n", - " 95%|█████████▌| 1431/1500 [01:45<00:05, 12.23it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(S2**3*_a0_**3/relu(S1)**3))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(S2**3*_a0_**3/relu(S1)**3))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return sinh(fac(_a0_))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return sinh(fac(_a0_))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-cos(S2)/relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-cos(S2)/relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-cos(S2)/relu(S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sqrt(relu(-sinh(S2))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sqrt(relu(-sinh(S2))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sqrt(relu(-sinh(S2))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return sinh(relu(_a0_))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return sinh(relu(_a0_))**_a0_\n", - " 96%|█████████▌| 1433/1500 [01:45<00:05, 12.27it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S1*S2/relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S1*S2/relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sqrt(sig(log(-_a0_**3))/sinh(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sqrt(sig(log(-_a0_**3))/sinh(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sqrt(sig(log(-_a0_**3))/sinh(S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(S2/_a0_)**(2*_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(S2/_a0_)**(2*_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(S2/_a0_)**(2*_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return sinh(S1)**(2*S2**S2)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return sinh(S1)**(2*S2**S2)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return sinh(S1)**(2*S2**S2)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sqrt(tan(sinh(S1))**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sqrt(tan(sinh(S1))**_a0_))\n", - " 96%|█████████▌| 1435/1500 [01:46<00:05, 11.53it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-S1)*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(-S1)*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_/S2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_/S2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sqrt(relu(_a0_**S1)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sqrt(relu(_a0_**S1)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sqrt(relu(_a0_**S1)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sqrt(relu(_a0_**S1)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sqrt(relu(_a0_**S1)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sqrt(relu(_a0_**S1)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_/S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_/S1)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-S2*_a0_/relu(_a0_)))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-S2*_a0_/relu(_a0_)))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(S2/_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(S2/_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return (_a0_**_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return (_a0_**_a0_)**_a0_\n", - " 96%|█████████▌| 1437/1500 [01:46<00:05, 11.47it/s]:2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(sqrt(relu(sinh(sin(_a0_)))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(sqrt(relu(sinh(sin(_a0_)))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(sqrt(relu(sinh(sin(_a0_)))**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(tan(S2*_a0_/relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(tan(S2*_a0_/relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sqrt(relu(_a0_**S2)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sqrt(relu(_a0_**S2)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sqrt(relu(_a0_**S2)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sqrt(relu(_a0_**S2)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(sqrt(relu(_a0_**S2)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sqrt(relu(_a0_**S2)**_a0_))\n", - " 96%|█████████▌| 1439/1500 [01:46<00:05, 11.88it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2*sinh(S1)/relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2*sinh(S1)/relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2*sinh(S1)/relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(S2/log(S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(S2 + _a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(S2 + _a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2*_a0_/relu(S1)))**3\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return relu(sqrt(relu(sinh(S1**S2))**_a0_))\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return relu(sqrt(relu(sinh(S1**S2))**_a0_))\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return relu(sqrt(relu(sinh(S1**S2))**_a0_))\n", - " 96%|█████████▌| 1441/1500 [01:46<00:04, 12.21it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-_a0_*fac(S2)/relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(sqrt(S2)*relu(_a0_)**2/(sqrt(S1**_a0_)*sqrt(log(fac(S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(sqrt(S2)*relu(_a0_)**2/(sqrt(S1**_a0_)*sqrt(log(fac(S1)))))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(sqrt(relu(sinh(S1))**(S2**S2)))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(sqrt(relu(sinh(S1))**(S2**S2)))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(sqrt(relu(sinh(S1))**(S2**S2)))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2/S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2/S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2/S1))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return (relu(relu(S2/relu(_a0_)))/relu(-S2))**sig(S1)\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return (relu(relu(S2/relu(_a0_)))/relu(-S2))**sig(S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(relu(exp(cos(S1 + log(relu(relu(S2))**2/_a0_)))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(relu(exp(cos(S1 + log(relu(relu(S2))**2/_a0_)))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_/S2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_/S2)**_a0_\n", - " 96%|█████████▌| 1443/1500 [01:46<00:04, 12.45it/s]:2: RuntimeWarning: invalid value encountered in scalar power\n", - " return _a0_**(2*_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return _a0_**(2*_a0_)\n", - " 96%|█████████▋| 1445/1500 [01:46<00:04, 11.67it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(exp(-sig(_a0_)/S1)/relu(tanh(_a0_)))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(exp(-sig(_a0_)/S1)/relu(tanh(_a0_)))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(exp(-sig(_a0_)/S1)/relu(tanh(_a0_)))\n", - " 96%|█████████▋| 1447/1500 [01:47<00:04, 12.16it/s]:2: RuntimeWarning: overflow encountered in sinh\n", - " return sqrt(sig(log(S2**3))/sinh(S2**S1))\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return sqrt(sig(log(S2**3))/sinh(S2**S1))\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return sqrt(sig(log(S2**3))/sinh(S2**S1))\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return relu(S2)*relu(sig(sig(relu(_a0_))))**(_a0_*exp(S2))\n", - " 97%|█████████▋| 1449/1500 [01:47<00:04, 12.31it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(sig(log(S2**3))/sinh(S2*_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(sin(S1))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S1/relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S1/relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return (_a0_**_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return (_a0_**_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(sin(S1))**_a0_\n", - " 97%|█████████▋| 1451/1500 [01:47<00:04, 12.18it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(relu(relu(S2/_a0_)/sqrt(S1*(-S1 + S2))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(sin(log(S2**3))/sinh(S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(sin(log(S2**3))/sinh(S1))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(sqrt(relu(_a0_)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(sqrt(relu(_a0_)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(sqrt(relu(_a0_)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S1/_a0_)**(2*_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S1/_a0_)**(2*_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S1/_a0_)**(2*_a0_)\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(sqrt(relu(sinh(_a0_))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(sqrt(relu(sinh(_a0_))**_a0_))\n", - " 97%|█████████▋| 1453/1500 [01:47<00:03, 12.51it/s]:2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(sin(S2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(sin(S2))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return (relu(relu(S2/relu(_a0_)))/relu(cosh(S2)))**sig(S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return log(S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return _a0_**(2*_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return _a0_**(2*_a0_)\n", - " 97%|█████████▋| 1455/1500 [01:47<00:03, 12.86it/s]:2: RuntimeWarning: overflow encountered in sinh\n", - " return sinh(S1**S2)**_a0_\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return sinh(S1**S2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(sqrt(_a0_ + relu(sinh(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(sqrt(_a0_ + relu(sinh(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S1*_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S1*_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S1*S2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S1*S2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S1*S2))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return sinh(relu(_a0_))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_**_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_**_a0_)**_a0_\n", - " 97%|█████████▋| 1457/1500 [01:47<00:03, 12.82it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return log(S1)**(2*_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return log(S1)**(2*_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(exp(-sig(_a0_)/S1)/relu(_a0_**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(exp(-sig(_a0_)/S1)/relu(_a0_**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return relu(exp(-sig(_a0_)/S1)/relu(_a0_**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(sqrt(_a0_*relu(sinh(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(sqrt(_a0_*relu(sinh(S1))))\n", - " 97%|█████████▋| 1459/1500 [01:47<00:03, 13.32it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return sqrt(sig(log(tan(S2)**3))/sinh(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sqrt(sig(log(tan(S2)**3))/sinh(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sqrt(sig(log(tan(S2)**3))/sinh(S1))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(log(S2*_a0_/relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(log(S2*_a0_/relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(sinh(log(S2**3))/sinh(S1))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(sinh(log(S2**3))/sinh(S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_**S1)**(2*_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_**S1)**(2*_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_**S1)**(2*_a0_)\n", - " 97%|█████████▋| 1461/1500 [01:48<00:03, 12.98it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-sig(_a0_)/relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-sig(_a0_)/relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-sig(_a0_)/relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(2*_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(2*_a0_)**_a0_\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return sinh(S1)**(S2**S2)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return sinh(S1)**(S2**S2)\n", - " 98%|█████████▊| 1463/1500 [01:48<00:03, 11.95it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S1/_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S1/_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-_a0_**2/relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-_a0_**2/relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(sqrt(relu(sinh(S1))/_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(sqrt(relu(sinh(S1))/_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(exp(cos(S1 + exp(_a0_**(-S1)*relu(relu(relu(S2)))**2)))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(exp(cos(S1 + exp(_a0_**(-S1)*relu(relu(relu(S2)))**2)))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(exp(cos(S1 + exp(_a0_**(-S1)*relu(relu(relu(S2)))**2)))))\n", - " 98%|█████████▊| 1465/1500 [01:48<00:02, 11.86it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-S2*_a0_/relu(S2 + _a0_)))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(log(-S2*_a0_/relu(S2 + _a0_)))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(tan(S1))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(sqrt(relu(sinh(log(_a0_)))**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(sqrt(relu(sinh(log(_a0_)))**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(sqrt(relu(sinh(log(_a0_)))**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(S1 + _a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(S1 + _a0_)**_a0_\n", - " 98%|█████████▊| 1467/1500 [01:48<00:02, 11.07it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (relu(relu(S2/relu(sqrt(_a0_))))/relu(_a0_))**sig(S1)\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(sqrt(relu(_a0_)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(sqrt(relu(_a0_)**_a0_))\n", - " 98%|█████████▊| 1469/1500 [01:48<00:02, 11.61it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2*_a0_/tan(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return (relu(relu(S2 + relu(sqrt(_a0_))))/relu(S1))**sig(S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_**S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_**S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(sqrt(relu(sinh(S1))/_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2*_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2*_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(S1 + _a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(S1 + _a0_)**_a0_\n", - " 98%|█████████▊| 1471/1500 [01:49<00:02, 10.87it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(tan(S1)/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(tan(S1)/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(tan(S1)/relu(S1))\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(relu(exp(cos(S1 + exp(relu(relu(relu(S2)))**2*exp(-_a0_))))))\n", - ":2: RuntimeWarning: invalid value encountered in cos\n", - " return relu(relu(exp(cos(S1 + exp(relu(relu(relu(S2)))**2*exp(-_a0_))))))\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(relu(exp(cos(S1 + exp(relu(relu(relu(S2)))**2*exp(-_a0_))))))\n", - ":2: RuntimeWarning: invalid value encountered in cos\n", - " return relu(relu(exp(cos(S1 + exp(relu(relu(relu(S2)))**2*exp(-_a0_))))))\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(relu(exp(cos(S1 + exp(relu(relu(relu(S2)))**2*exp(-_a0_))))))\n", - ":2: RuntimeWarning: invalid value encountered in cos\n", - " return relu(relu(exp(cos(S1 + exp(relu(relu(relu(S2)))**2*exp(-_a0_))))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(log(-(S2*_a0_)**relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(log(-(S2*_a0_)**relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S1/_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S1/_a0_)**_a0_\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return sinh(S1)**(S2**S1)\n", - ":2: RuntimeWarning: overflow encountered in power\n", - " return sinh(S1)**(S2**S1)\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(S2/_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(S2/_a0_)**_a0_\n", - " 98%|█████████▊| 1473/1500 [01:49<00:02, 10.63it/s]:2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(sqrt(relu(2*_a0_)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(sqrt(relu(2*_a0_)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(sqrt(relu(2*_a0_)**_a0_))\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(exp(S2/S1**2)/relu(S1))\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(exp(S2/S1**2)/relu(S1))\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(exp(S2/S1**2)/relu(S1))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return sqrt(sig(log(log(_a0_)**3))/sinh(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sqrt(sig(log(log(_a0_)**3))/sinh(S1))\n", - " 98%|█████████▊| 1475/1500 [01:49<00:02, 11.44it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return log(tan(S2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return log(tan(S2))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return sqrt(S1/relu(_a0_))*exp(-S1)\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(sqrt(relu(sinh(_a0_))**_a0_))\n", - " 98%|█████████▊| 1477/1500 [01:49<00:01, 11.72it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(sin(S2))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(sin(S2))**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(exp(-_a0_/S1)/relu(fac(_a0_)))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return sqrt(tanh(S2)/relu(_a0_))*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - " 99%|█████████▊| 1479/1500 [01:49<00:01, 11.40it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2*cosh(S1)/relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2*cosh(S1)/relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2*cosh(S1)/relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sqrt(sinh(log(S2**3))/sinh(S1))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sqrt(relu(sinh(S2/_a0_))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sqrt(relu(sinh(S2/_a0_))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sqrt(relu(sinh(S2/_a0_))**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(S1*_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(S1*_a0_)**_a0_\n", - " 99%|█████████▊| 1481/1500 [01:49<00:01, 10.24it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return _a0_**S1*relu(sig(sig(relu(relu(_a0_)))))**(S1*_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(2*_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(2*_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(_a0_**S2*relu(sig(_a0_))**S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(_a0_**S2*relu(sig(_a0_))**S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(relu(_a0_**S2*relu(sig(_a0_))**S1))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S1 + _a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S1 + _a0_)**_a0_\n", - " 99%|█████████▉| 1483/1500 [01:50<00:01, 10.88it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(S2*_a0_/S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(S2*_a0_/S1))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return (relu(relu(S2/relu(_a0_)))/_a0_**2)**sig(S1)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sqrt(sig(log(S2 + _a0_))/sinh(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sinh(S1)**log(_a0_)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return sinh(S1)**log(_a0_)\n", - " 99%|█████████▉| 1485/1500 [01:50<00:01, 11.39it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(sin(S2*_a0_/relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(sin(S2*_a0_/relu(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2*_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S2*_a0_)**_a0_\n", - " 99%|█████████▉| 1487/1500 [01:50<00:01, 11.66it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(_a0_**S2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(_a0_**S2)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sqrt(relu(sinh(S1*_a0_))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sqrt(relu(sinh(S1*_a0_))**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sqrt(relu(sinh(S1*_a0_))**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return log(S2/relu(tan(S2)))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return log(S2/relu(tan(S2)))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return log(S2/relu(tan(S2)))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(relu(S1))**(_a0_**S2)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(relu(S1))**(_a0_**S2)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(relu(S1))**(_a0_**S2)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(sqrt(_a0_ + relu(sinh(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return tan(S1)**_a0_\n", - " 99%|█████████▉| 1489/1500 [01:50<00:00, 12.73it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (log(relu(S2/relu(_a0_)))/relu(S1))**sig(S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (log(relu(S2/relu(_a0_)))/relu(S1))**sig(S1)\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(relu(S2/_a0_)/sqrt((S1**3 + S2)*sin(S2))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(relu(S2/_a0_)/sqrt((S1**3 + S2)*sin(S2))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(relu(S2/_a0_)/sqrt((S1**3 + S2)*sin(S2))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(S1/_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(S1/_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(S1)**(_a0_**S2)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return relu(S1)**(_a0_**S2)\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S1*S2/relu(S1)))\n", - " 99%|█████████▉| 1491/1500 [01:50<00:00, 12.86it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(relu(S2/_a0_)/sqrt((S1**3 + S2)*tan(S2))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(relu(S2/_a0_)/sqrt((S1**3 + S2)*tan(S2))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(relu(relu(S2/_a0_)/sqrt((S1**3 + S2)*tan(S2))))\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return relu(sqrt(_a0_ + relu(sinh(S1))))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_/S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_/S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-2*S2**2/relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-2*S2**2/relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-2*S2**2/relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sin(relu(S1))**_a0_\n", - ":2: RuntimeWarning: overflow encountered in exp\n", - " return relu(relu(exp(cos(S1 + exp(_a0_*relu(relu(relu(S2)))**2/S1)))))\n", - ":2: RuntimeWarning: invalid value encountered in cos\n", - " return relu(relu(exp(cos(S1 + exp(_a0_*relu(relu(relu(S2)))**2/S1)))))\n", - ":2: RuntimeWarning: divide by zero encountered in scalar power\n", - " return relu(_a0_)**_a0_\n", - "100%|█████████▉| 1493/1500 [01:50<00:00, 12.74it/s]:2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_/S2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (_a0_/S2)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2**2/relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2**2/relu(S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return sqrt(S2/relu(_a0_))*exp(-S2)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(S2/_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(S2/_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sqrt(relu(S1 + _a0_)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sqrt(relu(S1 + _a0_)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sqrt(relu(S1 + _a0_)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(relu(exp(cos(exp(relu(relu(relu(S2)))**2/_a0_) + log(_a0_)))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(relu(exp(cos(exp(relu(relu(relu(S2)))**2/_a0_) + log(_a0_)))))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(relu(exp(cos(exp(relu(relu(relu(S2)))**2/_a0_) + log(_a0_)))))\n", - "100%|█████████▉| 1495/1500 [01:51<00:00, 12.62it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-sqrt(S1)*S2/relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-sqrt(S1)*S2/relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-sqrt(S1)*S2/relu(S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(log(_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in log\n", - " return log(log(_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-S2))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S1/_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return (S1/_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sinh(sqrt(_a0_))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sinh(sqrt(_a0_))**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in sqrt\n", - " return sinh(sqrt(_a0_))**_a0_\n", - "100%|█████████▉| 1497/1500 [01:51<00:00, 12.85it/s]:2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-tanh(S1)/relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-tanh(S1)/relu(S1)))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-tanh(S1)/relu(S1)))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return sqrt(S1**2/relu(_a0_))*exp(-S1)\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(_a0_**S1)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(_a0_**S1)**_a0_\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return sinh(S1**S2)**_a0_\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return sinh(S1**S2)**_a0_\n", - "100%|█████████▉| 1499/1500 [01:51<00:00, 12.89it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(sqrt(S2)*relu(_a0_)**2/(sqrt(S1**_a0_)*sqrt(relu(log(S1)))))\n", - ":2: RuntimeWarning: divide by zero encountered in divide\n", - " return relu(sqrt(S2)*relu(_a0_)**2/(sqrt(S1**_a0_)*sqrt(relu(log(S1)))))\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return sqrt(sig(log(S2**3))/sinh(S1**S2))\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return sqrt(sig(log(S2**3))/sinh(S1**S2))\n", - ":2: RuntimeWarning: overflow encountered in sinh\n", - " return sqrt(sig(log(S2**3))/sinh(S1**S2))\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in scalar power\n", - " return sinh(_a0_)**_a0_\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sqrt(relu(S2*_a0_)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sqrt(relu(S2*_a0_)**_a0_))\n", - ":2: RuntimeWarning: divide by zero encountered in power\n", - " return relu(sqrt(relu(S2*_a0_)**_a0_))\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(S2*_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in power\n", - " return sinh(S2*_a0_)**_a0_\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-_a0_/S1)/relu(S1))\n", - ":2: RuntimeWarning: invalid value encountered in log\n", - " return relu(log(-_a0_/S1)/relu(S1))\n", - "100%|██████████| 1500/1500 [01:51<00:00, 13.46it/s]\n", - "INFO:autora.skl.bms:BMS fitting finished\n", - "/Users/jholla10/Library/Caches/pypoetry/virtualenvs/autora-17yK3Jyq-py3.8/lib/python3.8/site-packages/pandas/core/arraylike.py:402: RuntimeWarning: divide by zero encountered in log\n", - " result = getattr(ufunc, method)(*inputs, **kwargs)\n", - "/Users/jholla10/Library/Caches/pypoetry/virtualenvs/autora-17yK3Jyq-py3.8/lib/python3.8/site-packages/mpl_toolkits/mplot3d/art3d.py:1180: RuntimeWarning: invalid value encountered in subtract\n", - " v1[poly_i, :] = ps[i1, :] - ps[i2, :]\n", - "/Users/jholla10/Library/Caches/pypoetry/virtualenvs/autora-17yK3Jyq-py3.8/lib/python3.8/site-packages/numpy/core/numeric.py:1665: RuntimeWarning: invalid value encountered in multiply\n", - " multiply(a1, b2, out=cp0)\n", - "/Users/jholla10/Library/Caches/pypoetry/virtualenvs/autora-17yK3Jyq-py3.8/lib/python3.8/site-packages/numpy/core/numeric.py:1666: RuntimeWarning: invalid value encountered in multiply\n", - " tmp = array(a2 * b1)\n", - "/Users/jholla10/Library/Caches/pypoetry/virtualenvs/autora-17yK3Jyq-py3.8/lib/python3.8/site-packages/numpy/core/numeric.py:1668: RuntimeWarning: invalid value encountered in multiply\n", - " multiply(a2, b0, out=cp1)\n", - "/Users/jholla10/Library/Caches/pypoetry/virtualenvs/autora-17yK3Jyq-py3.8/lib/python3.8/site-packages/numpy/core/numeric.py:1669: RuntimeWarning: invalid value encountered in multiply\n", - " multiply(a0, b2, out=tmp)\n", - "/Users/jholla10/Library/Caches/pypoetry/virtualenvs/autora-17yK3Jyq-py3.8/lib/python3.8/site-packages/mpl_toolkits/mplot3d/proj3d.py:180: RuntimeWarning: invalid value encountered in divide\n", - " txs, tys, tzs = vecw[0]/w, vecw[1]/w, vecw[2]/w\n" - ] - }, - { - "data": { - "text/plain": "
", - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "log((S2 / S1))\n" - ] - }, - { - "data": { - "text/plain": "array([[0. ],\n [1.82624565],\n [2.43545837],\n [2.81130323],\n [3.08383954]])" - }, - "execution_count": 31, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# initialize model\n", - "# hyper parameters\n", - "\n", - "prior_par = {\n", - " \"Nopi_/\": 5.912205942815285,\n", - " \"Nopi_cosh\": 8.12720511103694,\n", - " \"Nopi_-\": 3.350846072163632,\n", - " \"Nopi_sin\": 5.965917796154835,\n", - " \"Nopi_tan\": 8.127427922862411,\n", - " \"Nopi_tanh\": 7.799259068142255,\n", - " \"Nopi_**\": 6.4734429542245495,\n", - " \"Nopi_pow2\": 3.3017352779079734,\n", - " \"Nopi_pow3\": 5.9907496760026175,\n", - " \"Nopi_exp\": 4.768665265735502,\n", - " \"Nopi_log\": 4.745957377206544,\n", - " \"Nopi_sqrt\": 4.760686909134266,\n", - " \"Nopi_cos\": 5.452564657261127,\n", - " \"Nopi_sinh\": 7.955723540761046,\n", - " \"Nopi_abs\": 6.333544134938385,\n", - " \"Nopi_+\": 5.808163661224514,\n", - " \"Nopi_*\": 5.002213595420244,\n", - " \"Nopi_fac\": 10.0,\n", - " \"Nopi2_*\": 1.0,\n", - " \"Nopi_sig\": 1.0,\n", - " \"Nopi_relu\": 1.0,\n", - "}\n", - "\n", - "# temperatures\n", - "ts = [1.0] + [1.04**k for k in range(1, 20)]\n", - "\n", - "# epoch num\n", - "epochs = 1500\n", - "\n", - "# fit model\n", - "estimator = BMSRegressor(prior_par, ts, epochs)\n", - "estimator = estimator.fit(X, y)\n", - "\n", - "# model estimate\n", - "show_results(\n", - " estimator=estimator, label=\"BMS Regressor\"\n", - ")\n", - "print(estimator.model_)\n", - "\n", - "# model prediction\n", - "test_x = X.head()\n", - "estimator.predict(test_x)" - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "id": "375b5b94", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Best model:\t log((S2 / S1))\n", - "Desc. length:\t -659.941451339323\n" - ] - }, - { - "data": { - "text/plain": "
", - "image/png": "iVBORw0KGgoAAAANSUhEUgAABOYAAAHkCAYAAACaDCCGAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABrN0lEQVR4nO3dd3wUdf7H8femN1KAFEroRZqCdJEihwTFgh2kwyF6HF1Ffki9UwR7Rb1TQBE4UUFFEREFREORIkUIvQWSQCAFCKnz+wOysCQkm82GzYTX8/HIQ3fmOzOfCZNk8863WAzDMAQAAAAAAADgunJzdQEAAAAAAADAjYhgDgAAAAAAAHABgjkAAAAAAADABQjmAAAAAAAAABcgmAMAAAAAAABcgGAOAAAAAAAAcAGCOQAAAAAAAMAFCOYAAAAAAAAAFyCYAwAAAAAAAFyAYA4AAAAAAABwAYI5AAAAAAAAwAUI5gAAAIBi+PDDD9W4cWOVK1dOYWFhevjhh11dEgAAMAmCOQAAAKAIVq9erSNHjkiS3nnnHc2aNUuLFi1SSkqKNm3apHvuuceu82zYsEH79+8vyVIBAEApRzAHAAAA2Ck6Olo7duxQtWrVJElz5szRiBEj1KBBA1ksFkVGRmrAgAF2natly5aaNm2aTp06VYIVAwCA0oxgDgAAALDDmTNnNHPmTD311FPWbT4+Pnrvvff0zTffKCUlpUjns1gsmjJlip544glnlwoAAEyCYA4AAABFNmXKFFksliIfN2fOHFksFh06dMih6xb3+OIYN26chg8fLje3y2+hFyxYoBYtWmjIkCEKCwvTkCFDlJGRIenikNc2bdro9ttv1+jRo/M9Z82aNdWoUSPNmTPnetwCAAAoZQjmAAAArpAb/FgsFq1duzbPfsMwFBkZKYvFYjOX2JXHWSwW+fj4qHLlyoqKitJbb72l1NTUa17rjz/+KNF7QvHt379fGzduVOfOnW22R0ZGatasWTpx4oS+/fZbzZs3T1988YUkqU6dOlq9erXWrl2rhIQEbd++Pd9zDx06VJMnT1Z6enqJ3wcAAChdCOYAAADy4ePjo/nz5+fZvnr1ah07dkze3t75Hjdt2jR9+umnmjVrloYPHy5JGjVqlJo0aaJt27aVaM0oOW+88Yb69u17zf1ubm668847FR4ervPnz0uSqlSpYn1OPDw85O7unu+xVatWVfPmzTV37lznFw4AAEo1gjkAAIB83H333Vq0aJGysrJsts+fP1/NmzdXREREvsfddddd6tOnjwYOHKjx48dr+fLl+umnn5SQkKD77rtPaWlp16N8OFFmZqYWLFige++912b79OnTtX79emVmZurs2bN64YUXdO7cOd1///027bZs2aJTp06pYcOG17zGgw8+qI8//rhE6gcAAKUXwRwAAEA+evXqpcTERK1YscK6LSMjQ1988YUef/zxIp2rc+fOmjhxog4fPqx58+YVu7bc+d327NmjPn36KCgoSKGhoZo4caIMw9DRo0d1//33KzAwUBEREXr11VfznGPLli266667FBgYqICAAP3tb3/TunXr8r3e2rVr1bJlS/n4+Kh27dr64IMP8m0XGxurQYMGKTw8XN7e3mrUqJHdYdPu3bt15MgR+z8JDt7LqlWr1KJFC5t7KWy+vDVr1sjLy0t169a12X7mzBn17t1bISEhqlevnrZv367o6GiFhoZa2yQkJGjEiBGFfh7atGmj9evX6+jRo0W4cwAAYHYEcwAAAPmoUaOG2rZtqwULFli3LVu2TMnJyerZs2eRz5c7DPLHH390Wo2PPfaYcnJy9NJLL6l169b697//rTfeeEN33nmnqlSpohkzZqhOnTp6+umntWbNGutxO3fuVPv27fXnn3/q2Wef1cSJE3Xw4EF16tRJ69evt7nG9u3b1bVrVyUkJGjKlCkaOHCgJk+erMWLF9u0i4+PV5s2bfTTTz/pn//8p958803VqVNHgwcP1htvvFHovTRo0ED9+vUr8uegKPeyZcsWdevWTYmJiZo6daoGDx6sadOmacmSJQVeY/Xq1WrWrFme7TNnztS+fft09uxZHT9+XAsXLlSdOnWs+9PT0/X444/rjTfeUHh4eIHXqFOnjipWrKhVq1bZfe8AAMD8PFxdAAAAQGn1+OOPa/z48UpLS5Ovr68+++wzdezYUZUrVy7yuapWraqgoCDt37/fafW1atXK2nvtiSeeUI0aNTR27FhNnz5d48aNk3Sx51/lypX18ccfq0OHDpKk559/XpmZmVq7dq1q1aolSerXr5/q16+vZ599VqtXr7ZeY9KkSTIMQ7/++quqVasmSXrooYfUpEkTm1omTJig7Oxsbd++XRUqVJAkPfnkk+rVq5emTJmioUOHytfX12n3nqso9zJ58mS5u7vrt99+s/4bPvroo2rQoEGB19iyZYtq165d5No++eQTbd++XWPHjpV0cehr27Ztr9n+lltu0aZNmwqcyw4AAJQt9JgDAAC4hkcffVRpaWlaunSpUlNTtXTp0iIPY71SQEBAvquzOurvf/+79f/d3d3VokULGYahwYMHW7cHBwerfv36OnDggCQpOztbP/74o3r06GENsiSpUqVKevzxx7V27VqlpKRY2y5fvlw9evSwhnLSxd5tUVFR1teGYejLL7/UvffeK8MwdOrUKetHVFSUkpOTtXnz5gLvxTCMIvcWK+q9/PTTT+rRo4dNsFqnTh3dddddBV5n3759qlKlSpFqk6QhQ4YoPj5eq1at0qpVqwoM5SSpfPnyTg1uAQBA6UcwBwAAcA2hoaHq0qWL5s+fr6+++krZ2dl6+OGHHT7f2bNnVa5cOafVd2VYJklBQUHy8fFRxYoV82w/c+aMJOnkyZM6f/686tevn+d8DRo0UE5OjnWes5MnTyotLS3P3GqSbI4/efKkkpKS9OGHHyo0NNTmY+DAgZIuzrXmbEW5l4SEBKWlpdkMNc2V37YrxcXFKSgoyDlFFyAkJETx8fElfh0AAFB6MJQVAACgAI8//riGDBmiuLg43XXXXQoODnboPMeOHVNycnKhIVBRuLu727VNutgjraTk5ORIkvr06aP+/fvn2+bmm28useuXtHPnzsnHx6fErxMSEqKzZ8+W+HUAAEDpQTAHAABQgAceeEBDhw7VunXr9L///c/h83z66aeSZDME1BVCQ0Pl5+enmJiYPPt2794tNzc3RUZGWtv6+vpq7969edpeeXxoaKjKlSun7OxsdenSpeSKv0pR7iUsLEw+Pj7at29fnrb5bbuSYRjKysrKs72glVwLk19Q6uHBW3MAAG40DGUFAAAoQEBAgGbNmqUpU6bo3nvvdegcP//8s/71r3+pZs2a6t27t5MrLBp3d3d17dpVX3/9tQ4dOmTdHh8fr/nz5+v2229XYGCgtW1UVJSWLFmiI0eOWNvu2rVLy5cvtznnQw89pC+//FI7duzIc82TJ08WWtfu3bttrlES99KlSxctWbJEx48ft7bdt2+fli1bVuB1/P39lZSUlGe7YRgOf+QnLS1NAQEBRfocAAAAc+PPcgAAAIW41vDM/Cxbtky7d+9WVlaW4uPj9fPPP2vFihWqXr26vvnmm3yHRH788cf64Ycf8mwfOXKkU+eky/Xvf/9bK1as0O23365//OMf8vDw0AcffKD09HTNnDnTpu3UqVP1ww8/qH379vrHP/6hrKwsvf3222rUqJG2bdtmbffSSy/pl19+UevWrTVkyBA1bNhQp0+f1ubNm/XTTz/p9OnTBdbUoEEDdezYscgLQBTlXqZMmaIff/xR7dq101NPPaXs7Gy98847aty4sbZu3XrNa0RERFjn6MvPhx9+qLfeekuHDx+Wr6+vOnTooC+++KJI9yFJycnJioiIKPJxAADAvAjmAAAAnGjSpEmSJC8vL5UvX15NmjTRG2+8oYEDB14zZJs1a1a+2wcMGFAiwVyjRo3066+/avz48Zo+fbpycnLUunVrzZs3T61bt7Zpe/PNN2v58uUaM2aMJk2apKpVq2rq1Kk6ceKETTAXHh6uDRs2aNq0afrqq6/03nvvqUKFCmrUqJFmzJjh9Htw5F6aN2+uZcuW6emnn9bEiRMVGRmpadOmadeuXdq9e/c1r1GnTh0lJibmu++dd97RRx99pEWLFummm27SsWPHtHLlSofuJTY2Vg0aNHDoWAAAYE4WoyRnAgYAAABKuR49emjnzp35zqUnSZMnT9aPP/6o6OjoPPtatGihYcOGWVefLY66detq8uTJ6tOnT7HPBQAAzIE55gAAAHDDSEtLs3m9d+9eff/99+rUqdM1j+nUqZM2b96s9PT0PPt8fHz03nvv6ZtvvlFKSorDdaWmpmr//v3q2LGjw+cAAADmQzAHAACAG0atWrU0fvx4/ec//9Hzzz+vNm3ayMvLS88+++w1j+nQoYNCQkK0efPmPPsWLFigFi1aaMiQIQoLC9OQIUOUkZEhSUpPT1ebNm0UEBBQ6Mqvq1evVvPmza2ryAIAgBsDwRwAAABuGN26ddOCBQs0fPhwvf3222rZsqXWrFmjunXrXvMYd3d39e/fX1999VWefZGRkZo1a5ZOnDihb7/9VvPmzbMu/ODp6amvv/5aDz/8cKF1LV26VP369XP8xgAAgCmx+AMAAABuGLNnz3bouNGjR6tFixaaNm2afH198+x3c3PTnXfeqfDwcJ0/f966LTw8vNBzp6Wl6aefftIrr7ziUG0AAMC86DEHAAAAFCIiIkJDhgzRggULrNumT5+u9evXKzMzU2fPntULL7ygc+fO6f777y/SuT/55BMNHTpUAQEBzi4bAACUcgRzAAAAgB2ee+45ffHFF0pKSpIknTlzRr1791ZISIjq1aun7du3Kzo6WqGhoXaf89y5c1q6dKlGjx5dQlUDAIDSzGIYhuHqIgAAAAAz2Ldvn9555x298cYbdh8zYMAAPf/886pTp06efc8//7wGDx6smjVrOrFKAABgFgRzAAAAQBFs3LhR5cuXV+3atQtt26NHD23YsEE1a9bUqFGj9Mgjj1j3bdmyRZ6enmrcuHFJlgsAAEoxgjkAAAAAAADABViV1QlycnJ0/PhxlStXThaLxdXlAAAAAAAAwIUMw1BqaqoqV64sN7drL/FAMOcEx48fV2RkpKvLAAAAAAAAQCly9OhRVa1a9Zr7CeacoFy5cpIufrIDAwNdXA0AAAAAAABcKSUlRZGRkdbM6FoI5pwgd/hqYGAgwRwAAAAAAAAkqdApz649yBUAAAAAAABAiSGYAwAAAAAAAFyAYA4AAAAAAABwAYI5AAAAAAAAwAUI5gAAAAAAAAAXIJgDAAAAAAAAXIBgDgAAAAAAAHABgjkAAAAAAADABQjmAAAAAAAAABcgmAMAAAAAAABcgGAOAAAAAAAAcAGCOQAAAAAAAMAFCOYAAAAAAAAAF/BwdQEonR59P1opFzJttlUI8NJrjzZVeKCPi6oCAAAAAAAoOwjmkK+9Cak6cz4zz/ZVMQl6rGU1F1QEAAAAAABQthDMIV+z+jRXVrZhff3myj3aeOiMMq7YBgAAAAAAAMcRzCFfbWpVsHm9YOMRSVJODsEcAAAAAACAM7D4A+zi4WaRJGURzAEAAAAAADgFwRzs4n4pmMvOyXFxJQAAAAAAAGUDwRzsQo85AAAAAAAA5yKYg13c3S4+Ktks/gAAAAAAAOAUBHOwCz3mAAAAAAAAnItgDna5PMccwRwAAAAAAIAzEMzBLvSYAwAAAAAAcC6COdiFVVkBAAAAAACci2AOdnGnxxwAAAAAAIBTEczBLrlDWXMI5gAAAAAAAJyCYA52cXe7+KjQYw4AAAAAAMA5COZgFw93VmUFAAAAAABwJoI52IU55gAAAAAAAJyLYA528XCjxxwAAAAAAIAzEczBLvSYAwAAAAAAcC6COdjlco+5HBdXAgAAAAAAUDYQzMEu1lVZs+kxBwAAAAAA4AwEc7CL+6UnhTnmAAAAAAAAnINgDnax9pgjmAMAAAAAAHAKgjnYJXeOuRyDYA4AAAAAAMAZCOZgF+uqrMwxBwAAAAAA4BQEc7DL5VVZCeYAAAAAAACcgWAOdrH2mMvJcXElAAAAAAAAZQPBHOzi4U6POQAAAAAAAGcimINdWJUVAAAAAADAuQjmYBfmmAMAAAAAAHAugjnY5fIccwRzAAAAAAAAzkAwB7u402MOAAAAAADAqQjmYBdWZQUAAAAAAHAugjnYxTrHXDY95gAAAAAAAJyBYA52sQ5lNQjmAAAAAAAAnIFgDnbxcLv4qDDHHAAAAAAAgHMQzMEurMoKAAAAAADgXARzsAtzzAEAAAAAADgXwRzsQo85AAAAAAAA5yKYg1083C/1mCOYAwAAAAAAcAqCOdjlco+5HBdXAgAAAAAAUDYQzMEu7paLwVyOIeXQaw4AAAAAAKDYTB3MTZ8+XS1btlS5cuUUFhamHj16KCYmxqbNhQsXNGzYMFWoUEEBAQF66KGHFB8fb9PmyJEj6t69u/z8/BQWFqZnnnlGWVlZ1/NWSj0Pt8uPSrZBMAcAAAAAAFBcpg7mVq9erWHDhmndunVasWKFMjMz1bVrV507d87aZvTo0fr222+1aNEirV69WsePH9eDDz5o3Z+dna3u3bsrIyNDv//+u+bOnas5c+Zo0qRJrrilUsv90hxzEvPMAQAAAAAAOIPFMMpO96eTJ08qLCxMq1evVocOHZScnKzQ0FDNnz9fDz/8sCRp9+7datCggaKjo9WmTRstW7ZM99xzj44fP67w8HBJ0vvvv69x48bp5MmT8vLyynOd9PR0paenW1+npKQoMjJSycnJCgwMvD43e51dyMzWTRN/kCTtnBolf28Pp51769EkHTx1VhlZOfp9f6KSzmcW63ye7hYN7VhbLWuUd1KFAAAAAAAA9ktJSVFQUFChWZHz0pVSIDk5WZJUvvzFQGbTpk3KzMxUly5drG1uuukmVatWzRrMRUdHq0mTJtZQTpKioqL01FNPaefOnWrWrFme60yfPl1Tp04t4bspXXIXf5CkLCf1mFt3IFH/99V2HTh1rvDGRZSWma3P/t7G6ecFAAAAAABwljITzOXk5GjUqFFq166dGjduLEmKi4uTl5eXgoODbdqGh4crLi7O2ubKUC53f+6+/IwfP15jxoyxvs7tMVeW5S7+IEljP98qL4/ij4LeeOiMTqZe7HnYNDJY5Xw8VL2Cn26pGiy3K65XFHEpF/Ty8hjFxJ0tdn0AAAAAAAAlqcwEc8OGDdOOHTu0du3aEr+Wt7e3vL29S/w6pYmbm0UVA7x06myGftqV4LTz+nq668unblPDys4ZAnw+I0uv/BijU2fTlXg2XRUCbqx/JwAAAAAAYB5lIpj75z//qaVLl2rNmjWqWrWqdXtERIQyMjKUlJRk02suPj5eERER1jYbNmywOV/uqq25bXDRp4Nba+Oh0047n0VS+7qhqlHR32nn9PPyULXyfjqceF6jP/9TIX6ekqRujSJ0V5NKTrsOAAAAAABAcZk6mDMMQ8OHD9fixYu1atUq1axZ02Z/8+bN5enpqZUrV+qhhx6SJMXExOjIkSNq27atJKlt27Z64YUXlJCQoLCwMEnSihUrFBgYqIYNG17fGyrlGlQKVINKpX9xi5urButw4nmt2XPSum3lrgRFNYqQm5tjQ2QBAAAAAACczdTB3LBhwzR//nx9/fXXKleunHVOuKCgIPn6+iooKEiDBw/WmDFjVL58eQUGBmr48OFq27at2rS5uDBA165d1bBhQ/Xt21czZ85UXFycnn/+eQ0bNuyGG65aVky8p4Fa1ghRZvbFRSpm/rBbZ9Oz9OexJP3314M6fS7DofN6e7rpmaj6alQ5yJnlAgAAAACAG5TFMAznLLHpApZrLBAwe/ZsDRgwQJJ04cIFjR07VgsWLFB6erqioqL03nvv2QxTPXz4sJ566imtWrVK/v7+6t+/v1566SV5eNiXW9q7BC5c4/53f9OfR5NUNyxAexOKtyhE/fByeqRFVQX5eureWyrLx9PdSVUCAAAAAICywt6syNTBXGlBMFe6jf9quxZsOGJ9PbRjLTUuYq+37BxDExZv17mMbJvtnu6FD431dHfTlPsa6dEWtiv3xsSlqvd/1ys5reg9+JpFhmj+kNbycC/+6rgAAAAAAMC57M2KTD2UFbBHx3oVrcFceKC3Rv2tnny9it7TLdDXQ99sPa6sHEPR+xOVeC7DOly2IJnZ2fps3eE8wdziLbE6dTa9yHVI0oZDp3Uo8bzqhAU4dDwAAAAAAHA9gjmUed0aV9Kvz96h1AtZiizv61AoJ0mdbwpX55vCJUmZ2Tl2hWqJZzN0z9trtT02WWv3npKXx+UebqtiEiRJU+9rpK6Nwu2uo//HG7Qn/qyOniGYAwAAAADAzAjmcEOILO/n1PN5urupUpBvoe0qBfmqVkV/HTh1Tn0+Wp9vm66Nwu06V64aFfwvBnOnz9t9DAAAAAAAKH0I5oASNuJvdfXuL/uUnZN32GvH+qFFCuWkyyHjkUSCOQAAAAAAzIxgDihhPZpVUY9mVZx2vsiQi0Heyt0JysjOsW5vW6uC7mpSyWnXAQAAAAAAJYtgDjCZuuHlJEkHT53TwVPnrNsXbjyqLg3D5clKrQAAAAAAmALBHGAyt9WuoBcfaKK45DRJUnp2jj5YfUAZWTnKMQpfJRYAAAAAAJQOBHOAyVgsFj3eupr1deqFTH2w+oAkiVwOAAAAAADzYMwbAAAAAAAA4AIEc4DJWSwWV5cAAAAAAAAcQDAHmNyVsRxDWQEAAAAAMA+COaAMMUQyBwAAAACAWRDMASbHSFYAAAAAAMyJYA4wOcsVg1kZygoAAAAAgHkQzAEAAAAAAAAuQDAHmNyVQ1npMAcAAAAAgHkQzAFliMFYVgAAAAAATINgDgAAAAAAAHABgjnA5BjKCgAAAACAORHMAWUII1kBAAAAADAPgjnA5CyyFN4IAAAAAACUOgRzgMldOZSVsawAAAAAAJgHwRxQhhgkcwAAAAAAmAbBHGByDGQFAAAAAMCcCOaAMoTFHwAAAAAAMA+COcDkLBb6zAEAAAAAYEYEc4DJsfYDAAAAAADmRDAHlCEGY1kBAAAAADANgjnA5BjJCgAAAACAORHMASZ35Rxz9JcDAAAAAMA8COaAMoSRrAAAAAAAmAfBHAAAAAAAAOACBHNAGWIwmBUAAAAAANMgmAPKABaAAAAAAADAfAjmgDLAmsvRYQ4AAAAAANMgmAPKEHI5AAAAAADMg2AOKAMsjGUFAAAAAMB0PBw98OTJk5o9e7Y2btyopKQkZWdn52ljsVi0cuXKYhUIoHC5sZxBlzkAAAAAAEzDoWBu27Zt6ty5s86cOSOjgCSAXjzA9cWqrAAAAAAAmIdDQ1nHjh2r06dPa8KECTp48KAyMzOVk5OT5yO/XnQAnI8MHAAAAAAA83Gox1x0dLR69OihadOmObseAA6wyCLJYCgrAAAAAAAm4lCPOS8vL9WuXdvZtQAAAAAAAAA3DIeCuY4dO+qPP/5wdi0AHHVpKCsd5gAAAAAAMA+HgrlXXnlFO3bs0CuvvOLsegAUQ0GLsQAAAAAAgNLFrjnmBg0alGdb48aNNW7cOL3//vtq2rSpAgMD87SxWCz66KOPil8lgAKx9gMAAAAAAOZjVzA3Z86ca+47cOCADhw4kO8+gjng+shdlZUOcwAAAAAAmIddwdzBgwdLug4AAAAAAADghmJXMFe9evWSrgNAMVgYzAoAAAAAgOk4tPjDoEGD9M033xTYZunSpfnOTQfA+RjKCgAAAACA+TgUzM2ZM0dbt24tsM2ff/6puXPnOnJ6AAAAAAAAoMxzKJizx4ULF+ThYddIWQDFlDuQ1RBd5gAAAAAAMAuHkzOLJf85rQzD0NGjR7Vs2TJVrlzZ4cIAFB1DWQEAAAAAMA+7e8y5ubnJ3d1d7u7ukqQpU6ZYX1/54eHhoZo1a2rz5s3q2bNniRUO4LJrBeUAAAAAAKD0srvHXIcOHay//K9Zs0bVqlVTjRo18rRzd3dX+fLl1blzZw0ZMsRphQK4tstDWQEAAAAAgFnYHcytWrXK+v9ubm4aOHCgJk2aVBI1AXCQwVhWAAAAAABMw6E55nJycpxdB4DiYCQrAAAAAACmU2KrsgK4fhjKCgAAAACA+TjUY65z586FtnFzc1NgYKDq16+vHj16qHXr1o5cCgAAAAAAACiTHArmcuebs1gs+c5pdfX2mTNnauDAgfrvf//rWJUACpS7MAtTzAEAAAAAYB4ODWVNS0vTvffeqwYNGmj+/Pk6fPiwLly4oMOHD2v+/Plq1KiR7rvvPh09elQ//vijbr31Vs2ePVuzZs1ydv0AbJDMAQAAAABgFg4Fc5MnT9b27du1fv169ezZU5GRkfLy8lJkZKR69uyp6Ohobdu2TW+//ba6dOmiFStWKDQ0VLNnz3Z2/U717rvvqkaNGvLx8VHr1q21YcMGV5cE2MXC4g8AAAAAAJiOQ8Hc/Pnz9eCDD8rf3z/f/f7+/nrwwQe1YMECSVJwcLC6deumXbt2OV5pCfvf//6nMWPGaPLkydq8ebNuueUWRUVFKSEhwdWlAYWyLv5AhzkAAAAAAEzDoWDu5MmTyszMLLBNVlaWTahVqVIlZWdnO3K56+K1117TkCFDNHDgQDVs2FDvv/++/Pz89PHHH+dpm56erpSUFJsPoDQglwMAAAAAwDwcCuZq166tRYsWKTExMd/9iYmJ+vzzz1W7dm3rtuPHj6t8+fKOVVnCMjIytGnTJnXp0sW6zc3NTV26dFF0dHSe9tOnT1dQUJD1IzIy8nqWC+RhYSwrAAAAAACm41AwN3z4cMXFxenWW2/VW2+9pU2bNuno0aPatGmT3nrrLd16662Kj4/X8OHDJUk5OTn6+eef1bJlS6cW7yynTp1Sdna2wsPDbbaHh4crLi4uT/vx48crOTnZ+nH06NHrVSqQL4ayAgAAAABgPh6OHDR06FDFxsZq+vTpGj16tM0+wzDk5uam8ePHa+jQoZKk06dP6+mnn9Ztt91W/IpLAW9vb3l7e7u6DAAAAAAAAJiYQ8GcJE2bNk19+/bV/PnztW3bNqWkpCgwMFC33HKLevbsqXr16lnbVqxYUSNHjnRKwSWhYsWKcnd3V3x8vM32+Ph4RUREuKgqwH65I1kNZpkDAAAAAMA0HA7mJKlu3bqaPHmys2pxGS8vLzVv3lwrV65Ujx49JF0cfrty5Ur985//dG1xQBEwlBUAAAAAAPMoVjBXlowZM0b9+/dXixYt1KpVK73xxhs6d+6cBg4c6OrSADuw+AMAAAAAAGZTrGBuw4YN2rhxo5KSkpSdnZ1nv8Vi0cSJE4tzievmscce08mTJzVp0iTFxcWpadOm+uGHH/IsCAGURtahrPSYAwAAAADANCyGUfRf5U+fPq0ePXrot99+U0GHWyyWfAO7siYlJUVBQUFKTk5WYGCgq8vBDajlCz/pZGq6vhtxuxpVDnJ1OQAAAAAA3NDszYoc6jE3ZswYrV27Vp06dVL//v1VtWpVeXgwKhZwFQayAgAAAABgPg6laUuXLlWrVq20cuVKWSxEAoCrMZQVAAAAAADzcXPkoLS0NHXo0IFQDgAAAAAAAHCQQ8Fc06ZNdejQISeXAsBRFgazAgAAAABgOg4Fc5MnT9Y333yjdevWObseAMXAUFYAAAAAAMzDoTnm4uLi1L17d3Xs2FG9e/fWrbfees0VJvr161esAgEUjlHlAAAAAACYj8Uwit7Hxs3NTRaLRVceevV8c4ZhyGKxKDs7u/hVlnL2LoELlJTbpq/U8eQL+uaf7XRz1WBXlwMAAAAAwA3N3qzIoR5zs2fPdrgwACWHoawAAAAAAJiHQ8Fc//79nV0HgGJghWQAAAAAAMzHocUfAJROdJgDAAAAAMA8ihXMLV68WI8++qhuvvlm1alTx7p99+7dmjlzpmJjY4tdIAD7OTBlJAAAAAAAcBGHhrLm5OSoV69e+uKLLyRJvr6+SktLs+4PCQnRhAkTlJ2drfHjxzunUgDXxEhWAAAAAADMx6Eec6+//roWLVqkoUOH6syZM3r66adt9oeHh6t9+/b67rvvnFIkAPvQXw4AAAAAAPNwKJibM2eOWrZsqffee0+BgYH5Tjxfp04dHTx4sNgFAigcPeYAAAAAADAfh4K5ffv2qX379gW2qVChghITEx0qCkDRWHQxmWOKOQAAAAAAzMOhYM7X11fJyckFtjl8+LCCg4MdOT0Ah5HMAQAAAABgFg4Fc82aNdPy5ct14cKFfPefPn1aP/zwg9q0aVOs4gDYh6GsAAAAAACYj0PB3IgRI3Ts2DE99NBDOnbsmM2+/fv364EHHlBycrJGjBjhlCIBFCw3l2MoKwAAAAAA5uHhyEH333+/xo0bpxkzZqh69ery9/eXJIWFhSkxMVGGYWjixInq3LmzU4sFUDByOQAAAAAAzMOhHnOSNH36dC1fvlz33HOP/Pz85O7urpycHHXr1k3Lli3T1KlTnVkngALktzIyAAAAAAAo3RzqMZfrzjvv1J133umsWgA4iKGsAAAAAACYj8M95gAAAAAAAAA4jmAOKAsudZkz6DIHAAAAAIBp2DWU1c3NzaE5rCwWi7Kysop8HADHEMsBAAAAAGAedgVzHTp0YHJ5oBTjqxMAAAAAAPOxK5hbtWpVCZcBoDhyg3NGsgIAAAAAYB7MMQeUIQaDWQEAAAAAMA2COaAMYCgrAAAAAADmQzAHlAHWKSDpMAcAAAAAgGkQzAEAAAAAAAAuQDAHlAGWS4NZ6TAHAAAAAIB5EMwBZQirsgIAAAAAYB4Ec0AZYGH1BwAAAAAATIdgDihDDAazAgAAAABgGh7FOXjDhg3auHGjkpKSlJ2dnWe/xWLRxIkTi3MJAEXAUFYAAAAAAMzDoWDu9OnT6tGjh3777TcZBSQBBHPA9WFhLCsAAAAAAKbjUDA3ZswYrV27Vp06dVL//v1VtWpVeXgUq/MdgGLIjeXoMAcAAAAAgHk4lKYtXbpUrVq10sqVK+mpAwAAAAAAADjAocUf0tLS1KFDB0I5oJTI/VIsaGg5AAAAAAAoXRwK5po2bapDhw45uRQAxUUsBwAAAACAeTgUzE2ePFnffPON1q1b5+x6ADiAzqsAAAAAAJiPQ3PMxcXFqXv37urYsaN69+6tW2+9VYGBgfm27devX7EKBFA4S+7yD3SZAwAAAADANCyGA5NSubm5yWKx2MxndfV8c4ZhyGKxKDs7u/hVlnIpKSkKCgpScnLyNQNKoCTd+/ZabY9N1scDWqjzTeGuLgcAAAAAgBuavVmRQz3mZs+e7XBhAJyPoawAAAAAAJiPQ8Fc//79nV0HgGLIzeVYlBUAAAAAAPNwaPEHAAAAAAAAAMXjUI+5XIcOHdJnn32mrVu3KiUlRYGBgWratKl69+6tGjVqOKlEAIW6NJaVHnMAAAAAAJiHw8Hcm2++qWeffVZZWVk2i0B8+eWXmjZtmmbOnKmRI0c6pUgA9iGXAwAAAADAPBwayrp06VKNHj1aQUFB+ve//63ff/9dBw8eVHR0tF588UUFBQVpzJgx+u6775xdL4B8sPYDAAAAAADm41CPuddee03ly5fX5s2bVbVqVev26tWrq3Xr1urdu7eaNWum1157Td27d3dasQDyl7sqq8FYVgAAAAAATMOhHnObN2/WY489ZhPKXSkyMlKPPvqoNm3aVKziABQNsRwAAAAAAObhUDCXkZEhf3//AtsEBAQoIyPDoaIAFA1DWQEAAAAAMB+Hgrl69erp22+/VVZWVr77s7KytHTpUtWrV69YxQGwj4VVWQEAAAAAMB2Hgrl+/fopJiZGUVFReYar/vHHH7rrrrsUExOj/v37O6VIAAAAAAAAoKxxaPGHkSNHas2aNfrmm2/UqlUr+fn5KSwsTAkJCTp//rwMw9D999+vkSNHOrteAPm4PJSVLnMAAAAAAJiFQz3m3N3dtWTJEs2ZM0edOnWSl5eXjhw5Ii8vL91xxx2aO3euFi9eLDc3h04PwEEMZQUAAAAAwDwc6jGXq1+/furXr5+zagHgIAurPwAAAAAAYDp0aQPKAMulwax0mAMAAAAAwDwI5oAyhKGsAAAAAACYh13BnJubmzw8PLRnzx7ra3d390I/PDyKNVIWgL0YygoAAAAAgOnYlZx16NBBFotFfn5+Nq9d6dChQ/rXv/6ln3/+WXFxcapcubL69OmjCRMmyMvLy9pu27ZtGjZsmDZu3KjQ0FANHz5czz77rM25Fi1apIkTJ+rQoUOqW7euZsyYobvvvvt63xLgsNyvRoPBrAAAAAAAmIZdwdyqVasKfO0Ku3fvVk5Ojj744APVqVNHO3bs0JAhQ3Tu3Dm98sorkqSUlBR17dpVXbp00fvvv6/t27dr0KBBCg4O1hNPPCFJ+v3339WrVy9Nnz5d99xzj+bPn68ePXpo8+bNaty4sStvESgyhrICAAAAAGAeFsMoO7/Kv/zyy5o1a5YOHDggSZo1a5YmTJiguLg4ay+65557TkuWLNHu3bslSY899pjOnTunpUuXWs/Tpk0bNW3aVO+//75d101JSVFQUJCSk5MVGBjo5LsCCtfzw2itO3Bab/dqpntvqezqcgAAAAAAuKHZmxU5tPhDrVq19NZbbxXY5t1331WtWrUcOb3DkpOTVb58eevr6OhodejQwWZoa1RUlGJiYnTmzBlrmy5duticJyoqStHR0de8Tnp6ulJSUmw+gNKgzKTsAAAAAADcABwK5g4dOqSkpKQC2yQlJenw4cOOnN4h+/bt09tvv62hQ4dat8XFxSk8PNymXe7ruLi4Atvk7s/P9OnTFRQUZP2IjIx01m0ADrGw+gMAAAAAAKbjUDBnj+TkZHl7exf5uOeee04Wi6XAj9xhqLliY2PVrVs3PfLIIxoyZIizbuGaxo8fr+TkZOvH0aNHS/yaQEFy12IpQyPTAQAAAAAo8+xa/EGS1qxZY/P60KFDebZJUnZ2to4eParPPvtM9erVK3JBY8eO1YABAwpsc+UQ2ePHj+uOO+7Qbbfdpg8//NCmXUREhOLj42225b6OiIgosE3u/vx4e3s7FDoCAAAAAAAAuewO5jp16iTLpW45FotFc+fO1dy5c/NtaxiGLBaLXnrppSIXFBoaqtDQULvaxsbG6o477lDz5s01e/ZsubnZdgBs27atJkyYoMzMTHl6ekqSVqxYofr16yskJMTaZuXKlRo1apT1uBUrVqht27ZFrh1wFQsjWQEAAAAAMB27g7lJkybJYrHIMAxNmzZNHTt2VKdOnfK0c3d3V/ny5XXHHXeoQYMGzqzVRmxsrDp16qTq1avrlVde0cmTJ637cnu7Pf7445o6daoGDx6scePGaceOHXrzzTf1+uuvW9uOHDlSHTt21Kuvvqru3btr4cKF+uOPP/L0vgNKs9w55hjJCgAAAACAedgdzE2ZMsX6/6tXr9bAgQPVr1+/kqjJLitWrNC+ffu0b98+Va1a1WZf7jxbQUFB+vHHHzVs2DA1b95cFStW1KRJk/TEE09Y2952222aP3++nn/+ef3f//2f6tatqyVLlqhx48bX9X4AZzBYlxUAAAAAANOwGMwWX2wpKSkKCgpScnKyAgMDXV0ObkB9P1qvX/ee0uuP3aIHmlUt/AAAAAAAAFBi7M2K7O4xl58TJ05o4cKF2rJli5KTkxUUFKRmzZqpZ8+eqlSpUnFODcABxOwAAAAAAJiHw8Hcu+++q2eeeUbp6em6stPdvHnzNGHCBL3yyiv6xz/+4ZQiAQAAAAAAgLLGoWBu4cKFGj58uCpWrKgJEyaoffv2Cg8PV3x8vNasWaM333zTuv/RRx91ds0ArpK7YjI95gAAAAAAMA+HgrmZM2eqYsWK2rp1qypXrmzdXr9+fXXo0EEDBgxQs2bNNGPGDII54DoilwMAAAAAwDzcHDlo165devTRR21CuStVrVpVjzzyiHbt2lWs4gDYx+LqAgAAAAAAQJE5FMwFBwfL39+/wDYBAQEKDg525PQAiujSSFaxyDIAAAAAAObhUDB333336dtvv1VWVla++zMzM/Xtt9/q/vvvL1ZxAIqGWA4AAAAAAPNwKJibOXOm/P391bVrV61bt85mX3R0tLp27apy5crppZdeckqRAArGUFYAAAAAAMzHocUfmjVrpoyMDG3evFnt2rWTh4eHKlasqFOnTll70VWqVEnNmjWzOc5isWj//v3FrxqADYt1LKtr6wAAAAAAAPZzKJjLycmRp6enqlWrZrP96sUgrp7vivmvAAAAAAAAgIscCuYOHTrk5DIAFEfuUFaDLnMAAAAAAJiGQ3PMASid6JQKAAAAAIB5EMwBZYCF1R8AAAAAADAdu4ayTps2TRaLRcOGDVP58uU1bdo0u05usVg0ceLEYhUIwB4Xkzk6zAEAAAAAYB4Ww44VGdzc3GSxWLRr1y7Vq1dPbm72dbSzWCzKzs4udpGlXUpKioKCgpScnKzAwEBXl4Mb0N/n/qGfdsXrxQea6PHW1Qo/AAAAAAAAlBh7syK7esz98ssvkmRdhTX3NYDSgaGsAAAAAACYj13BXMeOHQt8DcC1WJUVAAAAAADzcWjxh86dOzN3HAAAAAAAAFAMDgVz69evvyHmjgPMIncoa+EzRgIAAAAAgNLCoWDupptu0uHDh51dC4BiIpcDAAAAAMA8HArmhg8frq+//lp//fWXs+sB4ACLWP0BAAAAAACzsWvxh6vVqlVLnTp1Ups2bTR06FC1bNlS4eHhsuSzNGSHDh2KXSSAglm/9BjLCgAAAACAaTgUzHXq1EkWi0WGYejVV1/NN5DLxVx0wPVDLAcAAAAAgHk4FMxNmjSpwDAOwPXFlyMAAAAAAObjUDA3ZcoUJ5cBoDhy55hjJCsAAAAAAObh0OIPAAAAAAAAAIrHoWDut99+05gxYxQXF5fv/hMnTmjMmDFat25dsYoDYKdLQ1kNuswBAAAAAGAaDgVzr732mr799ltFRETku79SpUpaunSpXn/99WIVB6BoiOUAAAAAADAPh4K5jRs36vbbby+wTYcOHegxB1wnrP0AAAAAAID5OBTMJSQkqEqVKgW2iYiIUEJCgkNFASia3FWSGckKAAAAAIB5OBTMBQcH68iRIwW2OXz4sAICAhwqCoBjyOUAAAAAADAPh4K5Nm3aaPHixTp69Gi++48cOaIlS5botttuK1ZxAOzDUFYAAAAAAMzHoWBuzJgxOn/+vNq1a6dPPvlEJ06ckHRxNda5c+eqXbt2SktL09ixY51aLID8WViVFQAAAAAA0/Fw5KAOHTrotdde09ixYzVw4EBJF+e4yg0F3Nzc9Oabb6pDhw7OqxQAAAAAAAAoQxwK5iRp5MiRuuOOO/T+++9r48aNSk5OVnBwsFq1aqUnn3xSjRs3dmadAArAUFYAAAAAAMzH4WBOkm6++Wa99957zqoFQDExkhUAAAAAAPNwaI65gqSnpyszM9PZpwVQAIuFPnMAAAAAAJiNQ8HcmjVrNGnSJCUlJVm3JSYm6q677lJAQICCgoL03HPPOatGAIXIjeUM0WUOAAAAAACzcCiYe+WVVzR//nwFBwdbt40dO1bLly9XzZo1FRwcrJdfflmff/65s+oEYAeGsgIAAAAAYB4OBXNbtmzR7bffbn194cIFff755+ratav27NmjmJgYVatWTbNmzXJaoQAKwEhWAAAAAABMx6FgLjExUVWqVLG+jo6O1oULFzRw4EBJUrly5XTPPfcoJibGOVUCKJDlUjJHhzkAAAAAAMzDoWDO19dXqamp1te//PKLLBaLOnbsaN0WEBCgM2fOFL9CAHZjKCsAAAAAAObh4chBderU0Q8//KD09HRZLBYtXLhQDRs2VEREhLXNkSNHFBYW5rRCAVwbi7ICAAAAAGA+DvWYGzJkiPbt26c6deqoQYMG2r9/v3UYa65NmzapYcOGTikSgH1YlRUAAAAAAPNwKJgbPHiwnnnmGaWlpSk5OVlPPfWURo0aZd0fHR2tPXv26G9/+5uz6gRQADrMAQAAAABgPg4NZbVYLJoxY4ZmzJiR7/7mzZvrzJkz8vf3L1ZxAOyTO5SVOeYAAAAAADAPh4K5wnh5ecnLy6skTg0AAAAAAACUCQ4NZc21ePFiPfroo7r55ptVp04d6/bdu3dr5syZio2NLXaBAApnYTArAAAAAACm41CPuZycHPXq1UtffPGFJMnX11dpaWnW/SEhIZowYYKys7M1fvx451QK4JouD2VlLCsAAAAAAGbhUI+5119/XYsWLdLQoUN15swZPf300zb7w8PD1b59e3333XdOKRKAfcjlAAAAAAAwD4eCuTlz5qhly5Z67733FBgYKIsl7zC6OnXq6ODBg8UuEEDh8vkSBAAAAAAApZxDwdy+ffvUvn37AttUqFBBiYmJDhUFoKguJnN0mAMAAAAAwDwcCuZ8fX2VnJxcYJvDhw8rODjYkdMDAAAAAAAAZZ5DwVyzZs20fPlyXbhwId/9p0+f1g8//KA2bdoUqzgA9rm8+INr6wAAAAAAAPZzKJgbMWKEjh07poceekjHjh2z2bd//3498MADSk5O1ogRI5xSJAD7GAxmBQAAAADANDwcOej+++/XuHHjNGPGDFWvXl3+/v6SpLCwMCUmJsowDE2cOFGdO3d2arEA8sfaDwAAAAAAmI9DPeYkafr06Vq+fLnuuece+fn5yd3dXTk5OerWrZuWLVumqVOnOrNOAAVgKCsAAAAAAObjUI+5XHfeeafuvPNOZ9UCoJjI5QAAAAAAMA+He8wBKD0sDGYFAAAAAMB0HOoxFxsbqyVLlmjjxo06deqUJCk0NFQtW7bUAw88oEqVKjm1SAAFyx3KylhWAAAAAADMo8g95iZPnqw6depoxIgR+uSTT/T999/r+++/19y5czV8+HDVrl1b//rXv0qi1mtKT09X06ZNZbFYtHXrVpt927ZtU/v27eXj46PIyEjNnDkzz/GLFi3STTfdJB8fHzVp0kTff//9daocAAAAAAAAN6oi9ZibMGGCpk+fLm9vb/Xp00edOnVS5cqVJUnHjx/XL7/8okWLFmnKlCnKzs7WlClTSqLmPJ599llVrlxZf/75p832lJQUde3aVV26dNH777+v7du3a9CgQQoODtYTTzwhSfr999/Vq1cvTZ8+Xffcc4/mz5+vHj16aPPmzWrcuPF1qR8oLmuHOZdWAQAAAAAAisJiGPaNfTtw4IDq16+vatWqadmyZapXr16+7fbs2aOoqCjFxsYqJiZGNWvWdGrBV1u2bJnGjBmjL7/8Uo0aNdKWLVvUtGlTSdKsWbM0YcIExcXFycvLS5L03HPPacmSJdq9e7ck6bHHHtO5c+e0dOlS6znbtGmjpk2b6v3337erhpSUFAUFBSk5OVmBgYHOvUHADpO/3qG50Yf1zzvq6Omo+q4uBwAAAACAG5q9WZHdQ1nnzp2rnJwcffrpp9cM5SSpXr16mjdvnrKysvTJJ58Ureoiio+P15AhQ/Tpp5/Kz88vz/7o6Gh16NDBGspJUlRUlGJiYnTmzBlrmy5dutgcFxUVpejo6GteNz09XSkpKTYfgCtZLCz+AAAAAACA2dgdzP32229q3LixbrvttkLbtmvXTk2aNNGvv/5arOIKYhiGBgwYoCeffFItWrTIt01cXJzCw8NttuW+jouLK7BN7v78TJ8+XUFBQdaPyMjI4twK4DQGg1kBAAAAADANu4O5Xbt2qVWrVnafuFWrVtbhokXx3HPPyWKxFPixe/duvf3220pNTdX48eOLfI3iGj9+vJKTk60fR48eve41APlhUVYAAAAAAMzD7sUfkpKSFBYWZveJw8LClJSUVOSCxo4dqwEDBhTYplatWvr5558VHR0tb29vm30tWrRQ7969NXfuXEVERCg+Pt5mf+7riIgI63/za5O7Pz/e3t55rgu4EiNZAQAAAAAwH7uDubS0tCKFUV5eXkpLSytyQaGhoQoNDS203VtvvaV///vf1tfHjx9XVFSU/ve//6l169aSpLZt22rChAnKzMyUp6enJGnFihWqX7++QkJCrG1WrlypUaNGWc+1YsUKtW3btsi1A65iubQuKx3mAAAAAAAwD7uDudKmWrVqNq8DAgIkSbVr11bVqlUlSY8//rimTp2qwYMHa9y4cdqxY4fefPNNvf7669bjRo4cqY4dO+rVV19V9+7dtXDhQv3xxx/68MMPr9/NAAAAAAAA4IZTpGBu3rx5WrdunV1t9+3b51BBzhQUFKQff/xRw4YNU/PmzVWxYkVNmjRJTzzxhLXNbbfdpvnz5+v555/X//3f/6lu3bpasmSJGjdu7MLKgaLJHcrKHHMAAAAAAJhHkYK5ffv2FSlws1zHia9q1KghI59U4uabby50ddhHHnlEjzzySEmVBlw3rMoKAAAAAIB52B3MHTx4sCTrAFAMrP0AAAAAAID52B3MVa9evSTrAFAM1s6pdJgDAAAAAMA03FxdAADnIZcDAAAAAMA8COaAMuB6zucIAAAAAACcg2AOKAOsI1lZlhUAAAAAANMgmAMAAAAAAABcgGAOKAsudZmjwxwAAAAAAOZBMAeUIeRyAAAAAACYB8EcUAZYxOIPAAAAAACYDcEcUAZYGMoKAAAAAIDpEMwBZYjBYFYAAAAAAEyDYA4oAxjICgAAAACA+RDMAWUAQ1kBAAAAADAfgjkAAAAAAADABQjmgDKAVVkBAAAAADAfgjmgDDEYywoAAAAAgGkQzAFlgIUOcwAAAAAAmA7BHFAG5OZy9JcDAAAAAMA8COaAMoSRrAAAAAAAmAfBHFAWMJYVAAAAAADTIZgDyoDLQ1npMgcAAAAAgFkQzAFlCENZAQAAAAAwD4I5oAxgJCsAAAAAAOZDMAeUIXSYAwAAAADAPAjmgDLAIrrMAQAAAABgNgRzQBmQO5SVOeYAAAAAADAPgjmgTCGZAwAAAADALAjmgDKAgawAAAAAAJgPwRxQBjCUFQAAAAAA8yGYA8oQgjkAAAAAAMyDYA4oAywWBrMCAAAAAGA2BHNAGWKw+AMAAAAAAKZBMAcAAAAAAAC4AMEcUAaw+AMAAAAAAOZDMAeUIeRyAAAAAACYB8EcUAZYxOIPAAAAAACYDcEcUAYwlBUAAAAAAPMhmAPKEFZlBQAAAADAPAjmgDKAgawAAAAAAJgPwRxQBuQOZaXDHAAAAAAA5kEwBwAAAAAAALgAwRxQBuSuykqHOQAAAAAAzINgDihDDJZlBQAAAADANAjmgDLAwuoPAAAAAACYDsEcUIbQXw4AAAAAAPMgmAPKEEayAgAAAABgHgRzQBlgYSwrAAAAAACmQzAHlAG5sRwd5gAAAAAAMA+COQAAAAAAAMAFCOaAMiB3JKvBJHMAAAAAAJgGwRxQhhDLAQAAAABgHgRzQBnA0g8AAAAAAJgPwRxQBlhXZaXLHAAAAAAApkEwB5QhBskcAAAAAACmQTAHlAEWxrICAAAAAGA6BHNAGZCby7EoKwAAAAAA5kEwBwAAAAAAALgAwRxQFlway0qPOQAAAAAAzINgDihDWPwBAAAAAADzIJgDygDWfgAAAAAAwHxMH8x99913at26tXx9fRUSEqIePXrY7D9y5Ii6d+8uPz8/hYWF6ZlnnlFWVpZNm1WrVunWW2+Vt7e36tSpozlz5ly/GwCcIHdVVoayAgAAAABgHh6uLqA4vvzySw0ZMkQvvviiOnfurKysLO3YscO6Pzs7W927d1dERIR+//13nThxQv369ZOnp6defPFFSdLBgwfVvXt3Pfnkk/rss8+0cuVK/f3vf1elSpUUFRXlqlsDHEIuBwAAAACAeVgMw5x9bLKyslSjRg1NnTpVgwcPzrfNsmXLdM899+j48eMKDw+XJL3//vsaN26cTp48KS8vL40bN07fffedTaDXs2dPJSUl6YcffrCrlpSUFAUFBSk5OVmBgYHFvzmgiOavP6L/W7xddzYM13/6tXB1OQAAAAAA3NDszYpMO5R18+bNio2NlZubm5o1a6ZKlSrprrvusgnYoqOj1aRJE2soJ0lRUVFKSUnRzp07rW26dOlic+6oqChFR0df89rp6elKSUmx+QBciaGsAAAAAACYj2mDuQMHDkiSpkyZoueff15Lly5VSEiIOnXqpNOnT0uS4uLibEI5SdbXcXFxBbZJSUlRWlpavteePn26goKCrB+RkZFOvTcAAAAAAACUfaUumHvuuedksVgK/Ni9e7dycnIkSRMmTNBDDz2k5s2ba/bs2bJYLFq0aFGJ1jh+/HglJydbP44ePVqi1wMKc3lVVrrMAQAAAABgFqVu8YexY8dqwIABBbapVauWTpw4IUlq2LChdbu3t7dq1aqlI0eOSJIiIiK0YcMGm2Pj4+Ot+3L/m7vtyjaBgYHy9fXN9/re3t7y9va2/6aA64ShrAAAAAAAmEepC+ZCQ0MVGhpaaLvmzZvL29tbMTExuv322yVJmZmZOnTokKpXry5Jatu2rV544QUlJCQoLCxMkrRixQoFBgZaA722bdvq+++/tzn3ihUr1LZtW2feFlCiLJbC2wAAAAAAgNKl1A1ltVdgYKCefPJJTZ48WT/++KNiYmL01FNPSZIeeeQRSVLXrl3VsGFD9e3bV3/++aeWL1+u559/XsOGDbP2eHvyySd14MABPfvss9q9e7fee+89ff755xo9erTL7g0oKsulwax0mAMAAAAAwDxKXY+5onj55Zfl4eGhvn37Ki0tTa1bt9bPP/+skJAQSZK7u7uWLl2qp556Sm3btpW/v7/69++vadOmWc9Rs2ZNfffddxo9erTefPNNVa1aVf/9738VFRXlqtsCHGYwlhUAAAAAANOwGPwmX2wpKSkKCgpScnKyAgMDXV0ObkCf/3FUz36xTXfUD9Xsga1cXQ4AAAAAADc0e7Mi0w5lBXBZ7hRzpOwAAAAAAJgHwRxQhtD/FQAAAAAA8yCYA8oAC8uyAgAAAABgOgRzQBlChzkAAAAAAMyDYA4oA+gvBwAAAACA+RDMAWVA7khWFlkGAAAAAMA8COYAAAAAAAAAF/BwdQEAio+1HwAAuL5SL2Rq85EktatdQR7uBf+tOyfH0Oo9J5V4LiPPvgoBXupUL7TULORkGIZW7TmprGxDd9QP1amzGfpt36k889jWrOin5tXLF3qu3/cn6qaIcqoQ4F1yRcMpsrJz9Nv+RKWkZcrNYlHLmiEKK+fj6rJM5crRK1cOZDHy2W+xWOTuVjq+7lEycv+9c//Zr34OCvvZgRsHwRxQBlguzTK3Oy5VYz7fWvwTGtLehLP660RK8c/lAB8PN7WrU1EBPub7FuVmsahljRBVCvJ1aR2+Xu5qFhlcZn7g74lPVWSIn3y93F1Ww4GTZ3XsTFqxzlE7LEBVggt+NgzD0PbYZCWdz8yzLyzQWzdFBCrxbLp2Hk+Rn5e7mlULMe0b+7PpWXrg3d904NQ5h47v0iBMH/Rt4eSqSo9FfxzVqj0nHTq2dkV/jb6zXpHCnt/3n9LCDUeVfcUvjv5e7hrxt7qqGuLnUB1l2aiFW7Vyd4Im3N1AQzrUKrDtLzEJGjz3j2vunz2gpe64KczZJTrkl5gEDZpzsdbXHr1Fn60/ok2Hz+RpZ7FIa565Q5Hlr/1sLN8ZryfnbVKdsAD9NKZjidV8NcMwNOSTP/RLzOWvn54tI/XCA03sPkdWdo56/WedQvy89GG/Fvrpr3iN/t9Wnc/MLvC4rg3DNatPc4drd6WvtsTq2S+22WzL7+dLs8hgLXyiTZl5j1GYz/84qklf71BGVo6kK8OV4p3Xy8NNbzzWVHc3qVS8ExVT4tl0PfDe74pNKvp7nOrl/bR4WDsF+XoW2nbKNzv1275T+uoft6mcT+HtzSAu+YIefO83xaVccOi5qB9eTnXCAgqcMNzdYlGfNtXVqubFP4ScTc/S6yv26MylP/RceTmbYNhmu+057Tmmgr+Xnu12k/y93PX6T3vVsFKgbq9bUTN/2J3vH5mcxd1i0Vu9mpXY+Usr8/3WCyCPIL+LP9xOpqbrq82xLq6m+M5lZOvHv+JdXYbDvth0zNUlSJKe7VZf/+hUx9VlFNtv+06p93/X686G4fpPP9eEMEdPn9edr69Rdk7x3oWX8/ZQ9P/9TQHe1/7xm/uL7LUsGdZOIxdu0eHE85Kkifc01ODbaxarLlfZeiRJexPOOnz88p3xSrmQqcAy8gb/ShcyszX+q+3KKsYz17lBuJpGBtvd/t9Ld+X7B5lgPy/9390NHK6jrFq5O0GS9NHag4UGczuPX/y8Vgn2Vd3wAOv2vfFnFZuUpp3Hk0tNMLf92OVnYNuxZO2ITZYk3Va7grw8LgYxW44kKTkt8+IfTQoI5r758+J7kn3F+Dp3xOlzGfppV4LNti83H9O/ezS2O6zeE39WGw9dDCSTz2fqu+0nlJqeVehxy3bE6Wx6VoHf50urLUeSJEnVyvvJ28NNexPO5vtz74/DZ7Q34awaVAq8zhW6xjdbj+tCZo7Tz5uRlaMfdsS5PJhbd+C0jpw+79CxB06d0+bDZwr9/mUYhub8fkiS9P32E3qsZTWHrlfa/Lr3pI4nX3D4+Jj4VMXEpxba7tiZ8/rqH+0kSV9vjdVHaw86fM2iaFgpUOFBPnpr5V5J0osPNNEn0YdL9JoebgRzAEyqfZ2KeuOxpkpIdfwHw9V8PN3Vrk5FlXPBG8u9CWe183jydb+uM5xMTdf6g6eVle26hTiS0zIVm5SmTYfy9nAwow/XHJAkrXBhWLv5yBll5xgK8PZQtQJ+CS3I/pNnlZqepd0nUtSixrWHf204eFqSFFrOW6FXDP06npympPOZ+n77CWsoJ0kbD542bTB3+PTFnnLt61bUq4/cUqRj737rV506m6EjiefVuEpQSZTnUkdPn1dWjiE/L3eN63ZTkY6dt+6w9iac1f6Es3YHczk5hg6cuhiejLmznoJ8PbXlyBkt2Xpc+69zqFIW5X7NPt66mobdcfkPJm+t3KvXVuyx+Zp2tYOnLv97rzuQqPSsHHm4WfTJoFbWHlJPfrpJP+yM09FCfpm/spdGVnbOdethdfhSXeGB3loyrJ1un/GLLmTmKCE1XeGB9g3NPJF8uffQ4dPndDjx4verlx5sos7XCCG6vfmrTp/L0OHEc2pU2Xzfl/afvPw9oEezKjp9LkNZ2baB1BOfbtLWo0naE596wwRzuT+r/tOvhW6JvPzvmjti5cqs98rY98oQ2GLddvG/K3claOyiP63Pqivl3t/dTSI05d5Gdh/33Ffb9fPuBOvXRkGu7GF1Nr3gXqdmcvBSj/+Hm1fVs93qS7r4XOT+O1/+d7fkeQbOpmfpt32nCgx9E8+m662f92n/ycuf49w/dLSrU0Gd6l3+XlTQ3xzyexbzOyb35crdCfp17yntTTir9KzL9W04mCjp4vu2Lg3Cr33BYjDpIJBiI5gDygAPdzf1aFbF1WU4TVigj9rVqejqMkzr9/2n9Ph/1mvfybL3y3RaRrZLhrPuufTXzPuaVtaLRRgKdaUBszdoVcxJxcSnFhjM5V7rma719WjLSOv2N3/aq9d/2qNv/zyeb3szOnIpjKgdGqAwO39ZzlWtvJ9Onc3Q4TIazOW+2a8dGqD+t9Uo0rEx8anam3DWeg57xKde0IXMHLm7WfRUp9rydHdTnbAALdl6XAft+KXrRpOeVbRfLI9c+sX36t5luUF/afjlPNfBK0LC3XEXv79UK+9nE6pVDbk4JL+w4f1X/kJ3IvlCgb3rCnPqbLo1JK4U5KtqFa59rtzvLTUq+KtSkK8qB/vo6Ok0HU48b3cwd2VYejjxvLVHUeMqQdf8flWtvJ9On7v4BwNTBnOXPr91wi726izv75WnTcPKgdp6NEkxceb92VMUmdk5Op508Q/fN1cNctqcezdVKidJOlIKvr/mfr3UDStXpJ/FdcICLgZzdnz/uvLrKS65eNOClCaHLv37NagUWORnI9jPq9Ceg2kZ2Xrr531KTsvUmXMZCvH3sv5s796ksh5vXTI9D7093fXr3lPaf/KsPK5IynJHNHVvUkk9W5WNXo+lBcEcAJQxuW+oj54+rwuZ2fLxdN28bM5w5vzlv7IePHVODSsX7S/0FzKzdTjxvIw8U5fbb+vRJEkX5wJxVP3wcloVc1IbD55W8+oh12y3O+7iMLJ6EbbXqh9x8d/1xKUhEy2qh+iPw2d0KPGcdsQmy8O95P7EWK28n/y8nP+WIfeNevUCfsG+luoV/LX5SJL1L/1lTe4b7xoV/Yt8bM0KF48pSqB28NJf4yNDfOV5KYDJvfaRxPPXtbeTGeT+oi5J5zKyCv0+c/DUpWf96mDu0rN/8NQ569d+YQJ9PFX50lyVhmHoUOL5IgeF5zOy9fu+U/n2XNmXT9h/9XOYG7AdPVPwL+SxVwR3R8+cdziYO5uepbvf/FUJqemSJE93i7755+3X7LF19feW6uX9LwVz56zzNBXmyqF9u06k6NTZiz+LCgoEq1fw09ajSXYFFWkZ2Ro6b5P2lpI/rhjG5V5NtUKv/X0n9+fg7N8OafGWkp8+xdPdTc93b6CujSKs21IvZGrop5sK/OODu5tFwzvX0WMtq+mF7/7S0m0nbPb7ebnr9cea6uaqwQVeP/ZMmrJzDPl4uimsnPMWMKl+6fv0mfOZBU7J8PXWWL3yY4xDIzG8Pdw09f7G6lgvtMB2jv4szv3DwhE7evweueJndWnqIXwtFzKzraFbQfbEXwyza1YsmXlYfb3cVSnIRyeSL+jAqXNq7u+lQ5ee+5oOvD+wV+3Qi+8598SlWudWlC7+7JAuzpkM5yKYA4AyJjTAW+V8PJR6IUt3v/WrvEz+y/SVcxM98ekfRZ63JzYpTakXCp8XyB71ihHM5R67ZOtxLdl6vJDWUt2r3vRcfe12dSpq/8mzOnM+U/e8vdbhuuzh5+WuyBA/p68AXZxgLvcXgv+sOaBv7Ph8mk1uAOHIG+/cY37elaBub6yx65iUtMw816sU6CNvDzelZ+Wo25u/2vzV/EaXdsUCAKkXstTyhZ/s+j5z9bOeG9SdTE1Xtzd+tfv6NSv6y9vDTakXshyasL0wnu4WWWRRxqVhjFfOiydJkeUvBoNr9pwq8Bm7suf205//qUA7JojPz9n0LCWkpivA20PeHm5KPJehvh9tUMWAvD26JCku5WJwmht+VKvgJ+2TZi6PsXtupis/r7lzKoX4eRY4p2Xuv+eHaw5oSSGh1dn0rGIvKFQSbokMLvAPMW1qVZCb5eLXQFry9RmSOHLhVpuvHXuf+4lLduqjtQet4cnV+n60QZWCCu7llBtEVCvv59SVkwO8PVTB30uJ5zLU453frPM3Xu3AqXM2wUhR/WPepkID8dwFmIr6szi3/W/7C/4+INkOZV2z96TdP5tc5diZNJ21Y07JXDUrllxQVbOiv04kX9CIBVtUzsfDGvyXbDB38dzHky/kO4debnAH5yGYA4AyxmKxqGWN8vp5d4IOnCxbvYkc/SXG19Nd/t7F6zlYJyxAzaoFO3z8HTeFqXGVQMXZMUlwt8YR8r8qgKxRwV/dGkXoj8OnFejrqXturiQvDzfN+f2QzYpaznY+I1vnM7LtmpzYEZ7uFoeGfOX+W5w5n6kz+axgW1bc6sAz16RqkDzdLUrLzLYORbT/epd7c7q5WdSsWrDWHTh93SfvN5vUC1ny8XQr8A8HHeuF5Vm5sLy/lx5sVkVr9tq3+m5ur6Yrewq5WfIfcliYumHl1LByYL6LAbapVUE+nu5aFZMgPy939btqOHXDSkV/xq71C15RvPBAYzWsFKjub63VqbPpOnU2vcD2uXMsNosM1vz1R3QyNV0nUws+Jj+5v6AXNmdjs0tfP6fPZei0HasWWizSzIduLlVztdUppCdM/Yhy+v25vxX6uXcGw5AmLNmubceS8zxnbhbp9ceaXjMgeHl5jFbvOWkN5Qa1q6kHb7047UtGdo7+MW+z4lIuKDnNvp8fRVlIx17NqgXrp10Jha5M3rpmeU28p2GRzm0Y0tOL/lRMfKpdX6P+Xu6qE1a0Pz42qBQoLw83XcjMKdLPmqK2dxV73zveWi0kT29oZ7q1Woh+359oE0ZXCfZVeKDzenBerby/lx66tapW77m4iM659GwF+3kqMztHHeuFOfQzBwWzGCX5bv4GkZKSoqCgICUnJyswsPT8YAVw4zqfkaWtR5JUzEVES41aof46dibNob8ae3m4qVm1YOvwPBRNdo6hrUfPKC3D+SvSSRd7IRQ0NOxaDMPQXydSdOZc2Q3lQvw91bBSoEO9NI5cMSeWvXw83dQ0MthmyOrZ9Cz9eTRJvFvMy93Notqh/toTf1ZeHhc/d9fq9eJMx86c16FTl/9tG1QqpwoBJfcL2rUcTjyno6cL/2NJrVB/xSalKb2Yq1oG+XqqSdWLIf7BU+dshsnmp7y/lxpUKieLxaKcHEPbY5OL3Hs6PNBbmdmGTp/LkJvlYm+yq/9ocqWifl8KLeet+hGO98S+EaReyNS2Y8l5vgdFBHkXGCRdyMzW5iNnlJNz8XvbrdVC5HZFr99TZ9O1+4R94ZCH+8U/Unh7OHdqEHveq7m5XQwFHZlOIjktUzti837u8lMz1F9VLg2RL4qjp8/bPTQ1wMdDIX6edn3fcLX8fh66SlZ2jrYcTbL5Huqq7/soOnuzIoI5JyCYAwAAAAAAQC57syLXR8AAAAAAAADADYhgDgAAAAAAAHABgjkAAAAAAADABQjmAAAAAAAAABcgmAMAAAAAAABcgGAOAAAAAAAAcAGCOQAAAAAAAMAFCOYAAAAAAAAAFyCYAwAAAAAAAFyAYA4AAAAAAABwAYI5AAAAAAAAwAUI5gAAAAAAAAAXIJgDAAAAAAAAXIBgDgAAAAAAAHABD1cXUBYYhiFJSklJcXElAAAAAAAAcLXcjCg3M7oWgjknSE1NlSRFRka6uBIAAAAAAACUFqmpqQoKCrrmfotRWHSHQuXk5Oj48eMqV66cLBaLq8txipSUFEVGRuro0aMKDAx0dTkwAZ4ZFBXPDIqKZwZFxTODouKZQVHxzKCoeGZuHIZhKDU1VZUrV5ab27VnkqPHnBO4ubmpatWqri6jRAQGBvLNAkXCM4Oi4plBUfHMoKh4ZlBUPDMoKp4ZFBXPzI2hoJ5yuVj8AQAAAAAAAHABgjkAAAAAAADABQjmkC9vb29NnjxZ3t7eri4FJsEzg6LimUFR8cygqHhmUFQ8MygqnhkUFc8MrsbiDwAAAAAAAIAL0GMOAAAAAAAAcAGCOQAAAAAAAMAFCOYAAAAAAAAAFyCYAwAAAAAAAFyAYA75evfdd1WjRg35+PiodevW2rBhg6tLggtMnz5dLVu2VLly5RQWFqYePXooJibGps2FCxc0bNgwVahQQQEBAXrooYcUHx9v0+bIkSPq3r27/Pz8FBYWpmeeeUZZWVnX81bgIi+99JIsFotGjRpl3cYzg6vFxsaqT58+qlChgnx9fdWkSRP98ccf1v2GYWjSpEmqVKmSfH191aVLF+3du9fmHKdPn1bv3r0VGBio4OBgDR48WGfPnr3et4LrIDs7WxMnTlTNmjXl6+ur2rVr61//+peuXM+MZ+bGtmbNGt17772qXLmyLBaLlixZYrPfWc/Htm3b1L59e/n4+CgyMlIzZ84s6VtDCSnomcnMzNS4cePUpEkT+fv7q3LlyurXr5+OHz9ucw6emRtLYd9nrvTkk0/KYrHojTfesNnOM4NcBHPI43//+5/GjBmjyZMna/PmzbrlllsUFRWlhIQEV5eG62z16tUaNmyY1q1bpxUrVigzM1Ndu3bVuXPnrG1Gjx6tb7/9VosWLdLq1at1/PhxPfjgg9b92dnZ6t69uzIyMvT7779r7ty5mjNnjiZNmuSKW8J1tHHjRn3wwQe6+eabbbbzzOBKZ86cUbt27eTp6ally5bpr7/+0quvvqqQkBBrm5kzZ+qtt97S+++/r/Xr18vf319RUVG6cOGCtU3v3r21c+dOrVixQkuXLtWaNWv0xBNPuOKWUMJmzJihWbNm6Z133tGuXbs0Y8YMzZw5U2+//ba1Dc/Mje3cuXO65ZZb9O677+a73xnPR0pKirp27arq1atr06ZNevnllzVlyhR9+OGHJX5/cL6Cnpnz589r8+bNmjhxojZv3qyvvvpKMTExuu+++2za8czcWAr7PpNr8eLFWrdunSpXrpxnH88MrAzgKq1atTKGDRtmfZ2dnW1UrlzZmD59ugurQmmQkJBgSDJWr15tGIZhJCUlGZ6ensaiRYusbXbt2mVIMqKjow3DMIzvv//ecHNzM+Li4qxtZs2aZQQGBhrp6enX9wZw3aSmphp169Y1VqxYYXTs2NEYOXKkYRg8M8hr3Lhxxu23337N/Tk5OUZERITx8ssvW7clJSUZ3t7exoIFCwzDMIy//vrLkGRs3LjR2mbZsmWGxWIxYmNjS654uET37t2NQYMG2Wx78MEHjd69exuGwTMDW5KMxYsXW1876/l47733jJCQEJufS+PGjTPq169fwneEknb1M5OfDRs2GJKMw4cPG4bBM3Oju9Yzc+zYMaNKlSrGjh07jOrVqxuvv/66dR/PDK5EjznYyMjI0KZNm9SlSxfrNjc3N3Xp0kXR0dEurAylQXJysiSpfPnykqRNmzYpMzPT5nm56aabVK1aNevzEh0drSZNmig8PNzaJioqSikpKdq5c+d1rB7X07Bhw9S9e3ebZ0PimUFe33zzjVq0aKFHHnlEYWFhatasmf7zn/9Y9x88eFBxcXE2z0xQUJBat25t88wEBwerRYsW1jZdunSRm5ub1q9ff/1uBtfFbbfdppUrV2rPnj2SpD///FNr167VXXfdJYlnBgVz1vMRHR2tDh06yMvLy9omKipKMTExOnPmzHW6G7hKcnKyLBaLgoODJfHMIK+cnBz17dtXzzzzjBo1apRnP88MrkQwBxunTp1Sdna2zS/EkhQeHq64uDgXVYXSICcnR6NGjVK7du3UuHFjSVJcXJy8vLysb0pyXfm8xMXF5fs85e5D2bNw4UJt3rxZ06dPz7OPZwZXO3DggGbNmqW6detq+fLleuqppzRixAjNnTtX0uV/84J+LsXFxSksLMxmv4eHh8qXL88zUwY999xz6tmzp2666SZ5enqqWbNmGjVqlHr37i2JZwYFc9bzwc+qG9eFCxc0btw49erVS4GBgZJ4ZpDXjBkz5OHhoREjRuS7n2cGV/JwdQEAzGHYsGHasWOH1q5d6+pSUIodPXpUI0eO1IoVK+Tj4+PqcmACOTk5atGihV588UVJUrNmzbRjxw69//776t+/v4urQ2n0+eef67PPPtP8+fPVqFEjbd26VaNGjVLlypV5ZgCUqMzMTD366KMyDEOzZs1ydTkopTZt2qQ333xTmzdvlsVicXU5MAF6zMFGxYoV5e7unmeFxPj4eEVERLioKrjaP//5Ty1dulS//PKLqlatat0eERGhjIwMJSUl2bS/8nmJiIjI93nK3YeyZdOmTUpISNCtt94qDw8PeXh4aPXq1Xrrrbfk4eGh8PBwnhnYqFSpkho2bGizrUGDBjpy5Iiky//mBf1cioiIyLNAUVZWlk6fPs0zUwY988wz1l5zTZo0Ud++fTV69GhrL12eGRTEWc8HP6tuPLmh3OHDh7VixQprbzmJZwa2fv31VyUkJKhatWrW98OHDx/W2LFjVaNGDUk8M7BFMAcbXl5eat68uVauXGndlpOTo5UrV6pt27YurAyuYBiG/vnPf2rx4sX6+eefVbNmTZv9zZs3l6enp83zEhMToyNHjlifl7Zt22r79u02P3hy38xc/cs4zO9vf/ubtm/frq1bt1o/WrRood69e1v/n2cGV2rXrp1iYmJstu3Zs0fVq1eXJNWsWVMRERE2z0xKSorWr19v88wkJSVp06ZN1jY///yzcnJy1Lp16+twF7iezp8/Lzc327ew7u7uysnJkcQzg4I56/lo27at1qxZo8zMTGubFStWqH79+jarSqNsyA3l9u7dq59++kkVKlSw2c8zgyv17dtX27Zts3k/XLlyZT3zzDNavny5JJ4ZXMXVq0+g9Fm4cKHh7e1tzJkzx/jrr7+MJ554wggODrZZIRE3hqeeesoICgoyVq1aZZw4ccL6cf78eWubJ5980qhWrZrx888/G3/88YfRtm1bo23bttb9WVlZRuPGjY2uXbsaW7duNX744QcjNDTUGD9+vCtuCS5w5aqshsEzA1sbNmwwPDw8jBdeeMHYu3ev8dlnnxl+fn7GvHnzrG1eeuklIzg42Pj666+Nbdu2Gffff79Rs2ZNIy0tzdqmW7duRrNmzYz169cba9euNerWrWv06tXLFbeEEta/f3+jSpUqxtKlS42DBw8aX331lVGxYkXj2WeftbbhmbmxpaamGlu2bDG2bNliSDJee+01Y8uWLdYVNJ3xfCQlJRnh4eFG3759jR07dhgLFy40/Pz8jA8++OC63y+Kr6BnJiMjw7jvvvuMqlWrGlu3brV5T3zlapk8MzeWwr7PXO3qVVkNg2cGlxHMIV9vv/22Ua1aNcPLy8to1aqVsW7dOleXBBeQlO/H7NmzrW3S0tKMf/zjH0ZISIjh5+dnPPDAA8aJEydsznPo0CHjrrvuMnx9fY2KFSsaY8eONTIzM6/z3cBVrg7meGZwtW+//dZo3Lix4e3tbdx0003Ghx9+aLM/JyfHmDhxohEeHm54e3sbf/vb34yYmBibNomJiUavXr2MgIAAIzAw0Bg4cKCRmpp6PW8D10lKSooxcuRIo1q1aoaPj49Rq1YtY8KECTa/IPPM3Nh++eWXfN+/9O/f3zAM5z0ff/75p3H77bcb3t7eRpUqVYyXXnrpet0inKygZ+bgwYPXfE/8yy+/WM/BM3NjKez7zNXyC+Z4ZpDLYhiGcT165gEAAAAAAAC4jDnmAAAAAAAAABcgmAMAAAAAAABcgGAOAAAAAAAAcAGCOQAAAAAAAMAFCOYAAAAAAAAAFyCYAwAAAAAAAFyAYA4AAAAAAABwAYI5AAAAAAAAwAUI5gAAAAAAAAAXIJgDAABwkUOHDslischisSgiIkJZWVn5ttu1a5e1XY0aNfJtYxiGvvrqKz344IOqWrWqvL29Va5cOd1yyy0aPXq0/vrrL5v2nTp1sp5z6dKl16yxdevW1narVq3Kt82ePXs0fPhwNWrUSIGBgfL29lZkZKQefvhhffnll8rJybHr82GP3M/ZgAEDnHZOAAAAVyGYAwAAcDEPDw/Fx8fr+++/z3f/Rx99JDc3N7m55f/W7fTp0+rSpYseeugh/fLLL7rttts0evRoDRkyRBEREXrvvffUpEmTfIM1Dw8Pffzxx/med+fOndqwYYM8PDyuWfurr76qhg0b6t1331WFChU0aNAgjR07Vp06ddJvv/2mhx9+WEOGDCn8kwAAAHADuva7LAAAAFwXt912m/788099/PHHuu+++2z2ZWVlad68eerSpYtWr16d59isrCw98MADWrNmjfr06aN3331XgYGBNm1OnDihCRMmKDk5Oc/xd911l5YuXaqTJ08qNDTUZl9uIBgVFaXvvvsuz7Effvihnn76adWoUUNffvmlbr311jy1zZ07V7/++qvdnwsAAIAbCT3mAAAAXMzX11c9e/bUd999p4SEBJt9S5cuVXx8vAYNGpTvsZ9++qnWrFmjDh06aO7cuXlCOUmqVKmSPv74Y3Xr1i3PvkGDBikzM1OffvqpzfbMzEzNmzdPXbt2VdWqVfMcl5SUpGeeeUZeXl767rvv8oRy0sXeeIMHD9YHH3xQ4P3n+vLLL9WxY0eFhYXJx8dHlStXVpcuXfTll19KkubMmaOaNWtKkubOnWsdYnv1MFvDMPTxxx+rXbt2CgwMlJ+fn1q0aJFvz8ApU6ZYj//oo4/UpEkT+fj4qEqVKho9erRSU1Ptqh0AAMARBHMAAAClwKBBg5SVlZUnIPv4449Vvnx59ejRI9/jPvroI0nS888/f82hrrm8vb3zbGvTpo0aNmyo2bNn22z/9ttvdfLkyWsGgl988YVSUlL08MMPq2HDhkW+7tVmzZqlhx9+WHv37tUDDzygMWPGqFu3boqLi9PixYslSU2bNtXIkSMlSbfccosmT55s/cide88wDPXu3VuDBw/WyZMn9fjjj+vvf/+7zp07p8GDB+vpp5/O9/qvvfaaRowYoZYtW2rUqFGqVKmS3njjDXXt2lWZmZmF1g8AAOAIhrICAACUAq1atVLjxo01e/ZsjR07VpIUFxenZcuW6amnnso33MrKyrLOAde+fXuHrz1o0CA9/fTT2rhxo1q2bCnpYuBXoUIF3X///Vq5cmWeY3777TdJUufOnR2+7pX++9//ysvLS1u3blVYWJjNvsTEREkXg7lRo0bpzTffVNOmTTVlypR8z7NgwQINHDhQH3zwgTw9PSVJGRkZevjhh/Xqq6+qV69eat68uc1xy5cv18aNG3XzzTdLuhjw9enTR/Pnz9dbb71l/TcBAABwJnrMAQAAlBKDBg3Szp07tX79ekkXh2tmZWVds9daYmKiMjMzVbFiRfn4+Dh83b59+8rT09M61PP48eNavny5+vTpIy8vr3yPiYuLk6R8h7k6ytPT0xqkXalChQp2n+Odd96Rv7+/3n33XZtzeXl56YUXXpAkLViwIM9x/fr1s4ZykmSxWPTiiy/K3d1dc+bMKcJdAAAA2I8ecwAAAKVEnz59NG7cOH388cdq3bq1Zs+erWbNmqlp06Ylet2wsDB1795dCxcu1Ouvv665c+cqOzv7moFgSejZs6eeffZZNW7cWI8//rjuuOMO3X777fnOmXct58+f1/bt21W5cmXNmDEjz/7cIam7d+/Osy+/HofVq1dXZGSkdu7cqYyMjGuGlAAAAI4imAMAACglQkNDde+992rhwoV65JFHFBMTo7fffvua7StUqCBPT08lJiYqPT3drrncrmXQoEFasmSJvvzyS82ePVvNmze36UF2tYiICElSbGysw9e80tNPP60KFSpo1qxZevXVV/XKK6/Iw8ND3bt31+uvv25d9KEgZ86ckWEYio2N1dSpU6/Z7ty5c3m2hYeH59s2PDxchw4dUmpqapF67gEAANiDoawAAAClyODBg5WSkqIBAwbIx8dHvXv3vmZbDw8PtWrVSpmZmVqzZk2xrnv33XerUqVKGjdunPbu3avBgwcX2L5du3aSlO/8c46wWCwaNGiQNm7cqJMnT2rx4sV68MEH9fXXX+uee+5RdnZ2oefI7V3XvHlzGYZxzY9ffvklz7Hx8fH5njM+Pl4Wi0XlypUr3g0CAADkg2AOAACgFImKilKVKlUUGxurHj16KCQkpMD2uQHaiy++KMMwCmybnp5+zX3u7u7q16+fYmNj5ePjo169ehV4rocffliBgYH68ssv8x0aau9181OhQgX16NFD//vf/9S5c2f99ddf2rdvn7VOSfkGdeXKlVODBg20a9cuJSUlFemav/76a55thw8f1tGjR9WoUSOGsQIAgBJBMAcAAFCKuLu7a8mSJVq8eLGmT59eaPu+ffuqffv2WrVqlQYOHKjU1NQ8beLj4zVkyBD98MMPBZ5rzJgxWrx4sZYvX67g4OAC2wYHB+vll19Wenq6unfvrq1bt+Zpk52drblz5+rJJ58s9D5WrVqVJ1jMzMzU6dOnJcm6uEVISIgsFouOHj2a73lGjBih8+fPa8iQIfkOWT148KAOHTqUZ/snn3yibdu2WV8bhqH/+7//U3Z2tgYMGFBo/QAAAI5gjjkAAIBSpkWLFmrRooVdbT08PLRkyRI98sgjmjt3rr755ht17dpVNWvWVEZGhv766y+tWrVKmZmZ6tOnT4HnCgsLU48ePeyu84knnlBKSoqee+453XrrrerQoYOaNWsmX19fxcbGauXKlYqNjdXf//73Qs/Vo0cPBQYGqk2bNqpevboyMzO1YsUK/fXXX3r44YdVvXp1SVJAQIBatmypNWvWqG/fvqpbt67c3NzUt29fVa9eXUOHDtW6des0d+5c/fbbb+rSpYsqV66s+Ph47d69W+vXr9f8+fNVo0YNm+tHRUWpbdu26tmzp0JDQ7Vy5Ur98ccfatOmjYYPH2735wQAAKAoCOYAAABMrnz58vrpp5/01Vdfad68efr111+1ePFieXh4qFatWnriiSf05JNPqkGDBk6/9tNPP617771X77zzjn7++Wf997//VXp6usLCwtSyZUu9+eabevDBBws9z/Tp0/XDDz9ow4YN+vbbb+Xv76/atWtr1qxZeea7+/TTTzV69GgtXbpUycnJMgxDt99+u6pXry6LxaI5c+bo7rvv1n/+8x8tXbpUZ8+eVVhYmOrWratXXnlFXbp0yXP9MWPG6L777tMbb7yhffv2qXz58ho5cqT+9a9/MYwVAACUGItR2GQkAAAAQBk1ZcoUTZ06Vb/88os6derk6nIAAMANhjnmAAAAAAAAABcgmAMAAAAAAABcgGAOAAAAAAAAcAHmmAMAAAAAAABcgB5zAAAAAAAAgAsQzAEAAAAAAAAuQDAHAAAAAAAAuADBHAAAAAAAAOACBHMAAAAAAACACxDMAQAAAAAAAC5AMAcAAAAAAAC4AMEcAAAAAAAA4AL/D8QGjm5pzotiAAAAAElFTkSuQmCC" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "estimator.present_results()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": [], - "metadata": { - "collapsed": false - } - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "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.8.13" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/docs/theorist/bsr/bsr.ipynb b/docs/theorist/bsr/bsr.ipynb deleted file mode 100644 index 651d16d29..000000000 --- a/docs/theorist/bsr/bsr.ipynb +++ /dev/null @@ -1,142 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "source": [ - "# Bayesian Symbolic Regression (BSR)\n", - "\n", - "## Introduction\n", - "\n", - "Symbolic regression (SR) refers to a class of algorithms that search for interpretable symbolic expressions which capture relationships within data. More specifically, SR attempts to find compositions of simple functions that accurately map independent variables to dependent variables within a given dataset. Bayesian Symbolic Regression, proposed by [Jin et. al (2019)](https://arxiv.org/abs/1910.08892), is a specific SR method that uses a Bayesian framework to search for concise and interpretable expressions. The following are its main contributions, listed in sequential order:\n", - "\n", - "1. It models equations as expression trees, with root and intermediate tree nodes representing operators (e.g. `*` for a binary node and `sin` for a unary node) and leaf nodes representing features in the data. BSR then defines the search space as the union of the following three parts:\n", - " - Tree structure (T): this represents the structure of the expression tree (e.g. how to recursively construct the tree and when to stop by using leaf nodes), and also specifies the assignment of operators to non-leaf nodes.\n", - " - Leaf nodes (M): this assigns features to leaf nodes that are already defined from part **T**.\n", - " - Operator parameters ($\\Theta$): this uses a vector $\\Theta$ to collect additional parameters for certain operators which require them (e.g. a linear operator `ln` with intercept and slope params).\n", - "\n", - "2. It specifies priors for each of the three parts above. `Autora`'s implementation of BSR allows users to either specify custom priors for part `T` or choose among a pre-specified set.\n", - "\n", - "3. It defines `actions` that mutate one expression tree (`original`) into a new expression tree (`proposed`), and supports the calculation of transition probabilities based on the likelihoods of the `original` and `proposed` models.\n", - "\n", - "4. It designs and implements a Reversible-Jump Markov-Chain Monte-Carlo algorithm (RJ-MCMC), which iteratively accepts new samples (where each sample is a valid expression tree) based on the transition probabilities calculated above. In each iteration, `K` expression trees are obtained either from the `original` samples or the new `proposed` samples.\n", - "\n", - "5. With each iteration, the candidate prediction model is a linear mixture of the `K` trees, wherein the ground truth response is regressed on the results generated by the `K` expression trees to obtain the linear regression parameters $\\beta$.\n", - "\n", - "`AutoRA`'s implementation of BSR is adapted from original authors' [codebase](https://github.com/ying531/MCMC-SymReg), and includes comprehensive refactoring of data structures and MCMC computations. It also provides new priors that suit the cognitive and behavioral sciences.\n", - "\n", - "## Meta-Parameters\n", - "\n", - "Meta-Parameters are used to control the search space and the model configuration. In BSR, they are mainly defined in the theorist constructor (see `bsr.py`). Below is a basic overview of these parameters. Note, there are additional algorithm-irrelevant configurations that can be customized in the constructor; please refer to code documentation for their details.\n", - "\n", - "- `tree_num`: the number of expression trees to use in the linear mixture (final prediction model); also denoted by `K` in BSR.\n", - "- `iter_num`: the number of RJ-MCMC steps to execute (note: this can also be understood as the number of `K`-samples to take in the fitting process).\n", - "- `val`: the number of validation steps to execute following each iteration.\n", - "- `beta`: the hyperparameter that controls growth of a new expression tree. This needs to be < 0, and in general, smaller values of `beta` correspond to deeper expression trees.\n", - "\n", - "## Search Space\n", - "\n", - "The following are built-in operators which constitute the search space:\n", - "\n", - "- **\\+**: The output of the computation $x_j$ is the sum over its inputs $x_i, x_{ii}$: $x_j = x_i + x_{ii}$.\n", - "- **\\-**: The output of the computation $x_j$ is the respective difference between its inputs $x_i, x_{ii}$: $x_j = x_i - x_{ii}$.\n", - "- __\\*__: The output of the computation $x_j$ is the product over its two inputs $x_i, x_{ii}$: $x_j = x_i * x_{ii}$.\n", - "- **exp**: The output of the computation $x_j$ is the natural exponential function applied to its input $x_i$: $x_j = \\exp(x_i)$.\n", - "- **pow2**: The output of the computation $x_j$ is the square function applied to its input $x_i$: $x_j$ = $x_i^2$.\n", - "- **pow3**: The output of the computation $x_j$ is the cube function applied to its input $x_i$: $x_j$ = $x_i^3$.\n", - "- **sin**: The output of the computation $x_j$ is the sine function applied to its input $x_i$: $x_j = \\sin(x_i)$.\n", - "- **cos**: The output of the computation $x_j$ is the cosine function applied to its input $x_i$: $x_j = \\cos(x_i)$.\n", - "- **ln**: The output of the computation $x_j$ is the linear transformation applied to its input $x_i$: $x_j = a * x_i + b$, where $a$ and $b$ are slope and intercept parameters.\n", - "\n", - "In BSR, a new operator can be added in two steps. First, define an operator as a function, as demonstrated in `operations.py`. Second, add the name of the operator and its prior information to the dictionaries in `__get_prior()` within `prior.py`.\n", - "\n", - "## Examples\n", - "\n", - "The following toy example shows out-of-the-box functionality of BSR. It first generates data using the equation, $y = \\sin(x) + x^3$, as ground-truth, and then fits the data with default meta-parameters. For ease and efficiency of illustration, it applies a small number of iterations, `itr_num`. As displayed in the plot below, the algorithm provides results that are not only reasonable, but exactly match the ground-truth equation." - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": [ - "# Uncomment the following line when running on Google Colab\n", - "# !pip install autora" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": 28, - "outputs": [ - { - "data": { - "text/plain": "
", - "image/png": "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\n" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "from autora.skl.bsr import BSRRegressor\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "\n", - "x = np.expand_dims(np.linspace(start=-1, stop=1, num=500), 1)\n", - "y = np.power(x, 3) + np.sin(x)\n", - "\n", - "# initialize regressor\n", - "bsr = BSRRegressor(itr_num = 500)\n", - "bsr.fit(x, y)\n", - "y_pred = bsr.predict(x)\n", - "\n", - "# plot out the ground truth versus predicted responses\n", - "plt.figure()\n", - "plt.plot(x, y, \"o\")\n", - "plt.plot(x, y_pred, \"-\")\n", - "plt.show()" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "markdown", - "source": [ - "
\n", - "\n", - "## References\n", - "Jin, Ying, et al. \"Bayesian symbolic regression.\" arXiv preprint arXiv:1910.08892 (2019).\n" - ], - "metadata": { - "collapsed": false - } - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 2 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython2", - "version": "2.7.6" - } - }, - "nbformat": 4, - "nbformat_minor": 0 -} diff --git a/docs/theorist/bsr/how_it_works.md b/docs/theorist/bsr/how_it_works.md deleted file mode 100644 index 69052bae0..000000000 --- a/docs/theorist/bsr/how_it_works.md +++ /dev/null @@ -1,20 +0,0 @@ -# Bayesian Symbolic Regression - -## How it works - -Bayesian Symbolic Regression (BSR) has the following features: - -1. It models equations as expression trees, with root and intermediate tree nodes representing operators (e.g. `*` for a binary node and `sin` for a unary node) and leaf nodes representing features in the data. BSR then defines the search space as the union of the following three parts: - - Tree structure (T): this represents the structure of the expression tree (e.g. how to recursively construct the tree and when to stop by using leaf nodes), and also specifies the assignment of operators to non-leaf nodes. - - Leaf nodes (M): this assigns features to leaf nodes that are already defined from part **T**. - - Operator parameters ($\Theta$): this uses a vector $\Theta$ to collect additional parameters for certain operators which require them (e.g. a linear operator `ln` with intercept and slope params). - -2. It specifies priors for each of the three parts above. `Autora`'s implementation of BSR allows users to either specify custom priors for part `T` or choose among a pre-specified set. - -3. It defines `actions` that mutate one expression tree (`original`) into a new expression tree (`proposed`), and supports the calculation of transition probabilities based on the likelihoods of the `original` and `proposed` models. - -4. It designs and implements a Reversible-Jump Markov-Chain Monte-Carlo algorithm (RJ-MCMC), which iteratively accepts new samples (where each sample is a valid expression tree) based on the transition probabilities calculated above. In each iteration, `K` expression trees are obtained either from the `original` samples or the new `proposed` samples. - -5. With each iteration, the candidate prediction model is a linear mixture of the `K` trees, wherein the ground truth response is regressed on the results generated by the `K` expression trees to obtain the linear regression parameters $\beta$. - -`AutoRA`'s implementation of BSR is adapted from original authors' [codebase](https://github.com/ying531/MCMC-SymReg), and includes comprehensive refactoring of data structures and MCMC computations. It also provides new priors that suit the cognitive and behavioral sciences. diff --git a/docs/theorist/bsr/img.png b/docs/theorist/bsr/img.png deleted file mode 100644 index 3d278fd1e..000000000 Binary files a/docs/theorist/bsr/img.png and /dev/null differ diff --git a/docs/theorist/bsr/introduction.md b/docs/theorist/bsr/introduction.md deleted file mode 100644 index 52d7b3123..000000000 --- a/docs/theorist/bsr/introduction.md +++ /dev/null @@ -1,16 +0,0 @@ -# Bayesian Symbolic Regression - -## Introduction - -Symbolic regression (SR) refers to a class of algorithms that search for interpretable symbolic expressions which -capture relationships within data. More specifically, SR attempts to find compositions of simple functions that -accurately map independent variables to dependent variables within a given dataset. Bayesian Symbolic Regression (BSR), -proposed by [Jin et. al (2019)](https://arxiv.org/abs/1910.08892), is a specific SR method that uses a Bayesian -framework to search for concise and interpretable expressions. - -AutoRA provides an adapted version of BSR for automating the discovery of interpretable models of human information -processing. - -## References - -Jin et al., Bayesian Symbolic Regression. (2020). diff --git a/docs/theorist/bsr/meta_parameters.md b/docs/theorist/bsr/meta_parameters.md deleted file mode 100644 index ecb740fa3..000000000 --- a/docs/theorist/bsr/meta_parameters.md +++ /dev/null @@ -1,10 +0,0 @@ -# Bayesian Symbolic Regression - -## Meta-Parameters - -Meta-Parameters are used to control the search space and the model configuration. In BSR, they are mainly defined in the theorist constructor (see `bsr.py`). Below is a basic overview of these parameters. Note, there are additional algorithm-irrelevant configurations that can be customized in the constructor; please refer to code documentation for their details. - -- `tree_num`: the number of expression trees to use in the linear mixture (final prediction model); also denoted by `K` in BSR. -- `iter_num`: the number of RJ-MCMC steps to execute (note: this can also be understood as the number of `K`-samples to take in the fitting process). -- `val`: the number of validation steps to execute following each iteration. -- `beta`: the hyperparameter that controls growth of a new expression tree. This needs to be < 0, and in general, smaller values of `beta` correspond to deeper expression trees. diff --git a/docs/theorist/bsr/search_space.md b/docs/theorist/bsr/search_space.md deleted file mode 100644 index eda9d6d45..000000000 --- a/docs/theorist/bsr/search_space.md +++ /dev/null @@ -1,17 +0,0 @@ -# Bayesian Symbolic Regression - -## Search space - -The following are built-in operators which constitute the search space: - -- **\+**: The output of the computation $x_j$ is the sum over its inputs $x_i, x_{ii}$: $x_j = x_i + x_{ii}$. -- **\-**: The output of the computation $x_j$ is the respective difference between its inputs $x_i, x_{ii}$: $x_j = x_i - x_{ii}$. -- __\*__: The output of the computation $x_j$ is the product over its two inputs $x_i, x_{ii}$: $x_j = x_i * x_{ii}$. -- **exp**: The output of the computation $x_j$ is the natural exponential function applied to its input $x_i$: $x_j = \exp(x_i)$. -- **pow2**: The output of the computation $x_j$ is the square function applied to its input $x_i$: $x_j$ = $x_i^2$. -- **pow3**: The output of the computation $x_j$ is the cube function applied to its input $x_i$: $x_j$ = $x_i^3$. -- **sin**: The output of the computation $x_j$ is the sine function applied to its input $x_i$: $x_j = \sin(x_i)$. -- **cos**: The output of the computation $x_j$ is the cosine function applied to its input $x_i$: $x_j = \cos(x_i)$. -- **ln**: The output of the computation $x_j$ is the linear transformation applied to its input $x_i$: $x_j = a * x_i + b$, where $a$ and $b$ are slope and intercept parameters. - -In BSR, a new operator can be added in two steps. First, define an operator as a function, as demonstrated in `operations.py`. Second, add the name of the operator and its prior information to the dictionaries in `__get_prior()` within `prior.py`. diff --git a/docs/theorist/darts/example.ipynb b/docs/theorist/darts/example.ipynb deleted file mode 100644 index a79322552..000000000 --- a/docs/theorist/darts/example.ipynb +++ /dev/null @@ -1,342 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "source": [ - "# Differentiable Architecture Search\n", - "\n", - "## Example" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": [ - "# Uncomment the following line when running on Google Colab\n", - "# !pip install autora" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "markdown", - "source": [ - "Let's generate a simple data set with two features $x_1, x_2 \\in [0, 1]$ and a target $y$. We will use the following generative model:\n", - "$y = 2 x_1 - e^{(5 x_2)}$" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "import numpy as np\n", - "\n", - "x_1 = np.linspace(0, 1, num=10)\n", - "x_2 = np.linspace(0, 1, num=10)\n", - "X = np.array(np.meshgrid(x_1, x_2)).T.reshape(-1,2)\n", - "\n", - "y = 2 * X[:,0] + np.exp(5 * X[:,1])" - ] - }, - { - "cell_type": "markdown", - "source": [ - "Now let us define the search space, that is, the space of operations to consider when searching over the space of computation graphs." - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": 2, - "outputs": [], - "source": [ - "primitives = [\n", - " \"none\",\n", - " \"add\",\n", - " \"subtract\",\n", - " 'mult',\n", - " \"logistic\",\n", - " 'exp',\n", - " 'relu',\n", - "]" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "markdown", - "source": [ - "## Set up the DARTS Regressor\n", - "\n", - "We will use the DARTS Regressor to predict the outcomes. There are a number of parameters that determine how the architecture search is performed. The most important ones are listed below:\n", - "\n", - "- **num_graph_nodes**: The number of latent variables used to represent the model.\n", - "- **arch_updates_per_epoch**: The number of architecture updates per training epoch. These updates affect the architecture weights $\\alpha$ indicating the relative contribution of each operation for a given computation step.\n", - "- **arch_learning_rate_max**: The initial learning rate of the architecture weight optimizer.\n", - "- **param_updates_per_epoch**: The number of parameter updates per epoch. Once the architecture updates are complete, the parameters associated with each operation are updated.\n", - "- **param_momentum**: The momentum of the parameter optimizer.\n", - "- **max_epochs**: The maximum number of epochs to run DARTS.\n", - "- **output_type**: The type of output to produce. In our case, we treat the outcome as a real variable, i.e., \"real\".\n", - "\n", - "\n", - "Let's set up the DARTS regressor with some default parameters.\n" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": 3, - "outputs": [], - "source": [ - "from autora.skl.darts import DARTSRegressor\n", - "\n", - "darts_estimator = DARTSRegressor(\n", - " num_graph_nodes=1,\n", - " arch_updates_per_epoch=1,\n", - " arch_learning_rate_max=0.001,\n", - " param_updates_per_epoch=500,\n", - " param_momentum=0.9,\n", - " max_epochs=300,\n", - " output_type=\"real\",\n", - " primitives=primitives,\n", - ")" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "markdown", - "source": [ - "Now we have everything to run differentiable architecture search and visualize the model resulting from the highest architecture weights. Note that the current model corresponds to the model with the highest architecture weights." - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": 4, - "outputs": [ - { - "data": { - "text/plain": " 0%| | 0/300 [00:00\n\n\n\n\n\n\n\n\nx1\n\nx1\n\n\n\nk1\n\nk1\n\n\n\nx1->k1\n\n\nexp(x)\n\n\n\nx2\n\nx2\n\n\n\nx2->k1\n\n\nexp(x)\n\n\n\nP(detected) = (x + 0.00)\n\nP(detected) = (x + 0.00)\n\n\n\nk1->P(detected) = (x + 0.00)\n\n\n1.00 * x\n\n\n\n", - "text/plain": "" - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "darts_estimator.fit(X, y)\n", - "darts_estimator.visualize_model()" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "markdown", - "source": [ - "We can refine the fit by running the `fit` method again, after changing the parameters. This allows us to keep the same architecture but refit the parameters in the final sampled model, for example:" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": 5, - "outputs": [ - { - "data": { - "text/plain": "0it [00:00, ?it/s]", - "application/vnd.jupyter.widget-view+json": { - "version_major": 2, - "version_minor": 0, - "model_id": "bece0e3dc61b41cca6eae1d70d0af091" - } - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/svg+xml": "\n\n\n\n\n\n\n\n\nx1\n\nx1\n\n\n\nk1\n\nk1\n\n\n\nx1->k1\n\n\nexp(x)\n\n\n\nx2\n\nx2\n\n\n\nx2->k1\n\n\nexp(x)\n\n\n\nP(detected) = (x + 0.00)\n\nP(detected) = (x + 0.00)\n\n\n\nk1->P(detected) = (x + 0.00)\n\n\n1.00 * x\n\n\n\n", - "text/plain": "" - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "darts_estimator.set_params(\n", - " max_epochs=0, # no epochs of architecture fitting\n", - " param_updates_for_sampled_model=1000, # 1000 steps of param optimiziation\n", - ")\n", - "darts_estimator.fit(X, y)\n", - "darts_estimator.visualize_model()" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "markdown", - "source": [ - "We can also change how the model is sampled from the architecture weight distribution:" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": 6, - "outputs": [ - { - "data": { - "text/plain": "0it [00:00, ?it/s]", - "application/vnd.jupyter.widget-view+json": { - "version_major": 2, - "version_minor": 0, - "model_id": "c7be110e32954ed092c008d024a309b3" - } - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/svg+xml": "\n\n\n\n\n\n\n\n\nx1\n\nx1\n\n\n\nk1\n\nk1\n\n\n\nx1->k1\n\n\n47.75 * x\n\n\n\nx2\n\nx2\n\n\n\nx2->k1\n\n\nReLU(x)\n\n\n\nP(detected) = (x + 0.00)\n\nP(detected) = (x + 0.00)\n\n\n\nk1->P(detected) = (x + 0.00)\n\n\n1.00 * x\n\n\n\n", - "text/plain": "" - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "darts_estimator.set_params(\n", - " max_epochs=0, # no epochs of architecture fitting\n", - " sampling_strategy=\"sample\", # overriding default \"max\"\n", - " param_updates_for_sampled_model=800,\n", - ")\n", - "darts_estimator.fit(X, y)\n", - "darts_estimator.visualize_model()" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "markdown", - "source": [ - "To recover the initial model, we need to return the sampling strategy to the default `\"max\"`:" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": 7, - "outputs": [ - { - "data": { - "text/plain": "0it [00:00, ?it/s]", - "application/vnd.jupyter.widget-view+json": { - "version_major": 2, - "version_minor": 0, - "model_id": "4f4026df6f5e4934905010e90bc42fc8" - } - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/svg+xml": "\n\n\n\n\n\n\n\n\nx1\n\nx1\n\n\n\nk1\n\nk1\n\n\n\nx1->k1\n\n\nexp(x)\n\n\n\nx2\n\nx2\n\n\n\nx2->k1\n\n\nexp(x)\n\n\n\nP(detected) = (x + 0.00)\n\nP(detected) = (x + 0.00)\n\n\n\nk1->P(detected) = (x + 0.00)\n\n\n1.00 * x\n\n\n\n", - "text/plain": "" - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "darts_estimator.set_params(\n", - " max_epochs=0, # no epochs of architecture fitting\n", - " sampling_strategy=\"max\",\n", - " param_updates_for_sampled_model=1000,\n", - ")\n", - "darts_estimator.fit(X, y)\n", - "darts_estimator.visualize_model()" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "markdown", - "source": [ - "As long as the architecture has not been refitted in the meantime, the architecture should be identical to the initial result, as the `sampling_strategy=\"max\"` is deterministic. The coefficients of the architecture functions may, however, be different, as they have different starting values compared to when they were initially set.\n" - ], - "metadata": { - "collapsed": false - } - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 2 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython2", - "version": "2.7.6" - } - }, - "nbformat": 4, - "nbformat_minor": 0 -} diff --git a/docs/theorist/darts/how_it_works.md b/docs/theorist/darts/how_it_works.md deleted file mode 100644 index b703f69fe..000000000 --- a/docs/theorist/darts/how_it_works.md +++ /dev/null @@ -1,39 +0,0 @@ -# Differentiable Architecture Search - -## How it works - -Regular DARTS treats the architecture of a neural network as a directed acyclic computation graph (DAG), containing $N$ nodes in sequential order. - -![Computation Graph](img/darts_computation_graph.jpg) - -Each node $x_i$ corresponds to a latent representation of the input space. Each directed edge $e_{i, j}$ is associated with some operation $o_{i,j}$ that transforms the representation of the preceding node $i$, and feeds it to node $j$. Each intermediate node is computed by integrating over its transformed predecessors: - -$$ -x_j = \sum_{i
- -$$ -\min_\alpha \mathscr{L}_{\textrm{val}}\left(w^*(\alpha),\alpha\right) \\ -\textrm{s.t. } w^*(\alpha) = \underset{w}{\operatorname{argmin}} \mathscr{L}_{\textrm{train}}(w, \alpha). -$$ - -That is, one can obtain $\alpha^*$ through gradient descent, by iterating through the following steps: - - -- Obtain the optimal set of weights $w^*$ for the current architecture $\alpha$ by minimizing the training loss $\mathscr{L}_{\textrm{train}}(w, \alpha)$. -- Update the architecture $\alpha$ (cf. Figure C) by following the gradient of the validation loss $\nabla \mathscr{L}_{\textrm{val}}\left(w^*,\alpha\right)$. - - -Once $\alpha^*$ is found, one can obtain the final architecture by replacing $\bar{o}_{i,j}$ with the operation that has the highest architectural weight, i.e. $o_{i,j}\leftarrow \textrm{argmax}_o \alpha^{*o}_{i,j}$ (Figure D). - -## References - -Liu, H., Simonyan, K., & Yang, Y. (2018). Darts: Differentiable architecture search. In *International Conference on Learning Representations*. arXiv: https://arxiv.org/abs/1806.09055 diff --git a/docs/theorist/darts/img/darts_computation_graph.jpg b/docs/theorist/darts/img/darts_computation_graph.jpg deleted file mode 100644 index 972ddef14..000000000 Binary files a/docs/theorist/darts/img/darts_computation_graph.jpg and /dev/null differ diff --git a/docs/theorist/darts/introduction.md b/docs/theorist/darts/introduction.md deleted file mode 100644 index 133560da2..000000000 --- a/docs/theorist/darts/introduction.md +++ /dev/null @@ -1,17 +0,0 @@ -# Differentiable Architecture Search - -## Introduction - -Neural Architecture Search refers to a family of methods for automating the discovery of useful neural network architectures. There are a number of methods to guide this search, such as evolutionary algorithms, reinforcement learning, or Bayesian optimization (for a recent survey of NAS search strategies, see Elsken, Metzen, & Hutter, 2019). However, most of these methods are computationally demanding due to the nature of the optimization problem: The search space of candidate computation graphs is high-dimensional and discrete. To address this problem, Liu et al. (2018) proposed **differentiable architecture search (DARTS)**, which relaxes the search space to become continuous, making architecture search amenable to gradient descent. - -DARTS has been shown to yield useful network architectures for image classification and language modeling that are on par with architectures designed by human researchers. AutoRA provides an adaptation of DARTS for automate the discovery of interpretable quantitative models to explain human information processing (Musslick, 2021). - -## References - -Liu, H., Simonyan, K., & Yang, Y. (2018). Darts: Differentiable architecture search. In *International Conference on Learning Representations*. arXiv: https://arxiv.org/abs/1806.09055 - -Elsken, T., Metzen, J. H., Hutter, F., et al. (2019). Neural architecture search: A survey. *JMLR*, 20(55), 1–21 - -Musslick, S. (2021). Recovering quantitative models of human information processing with differentiable architecture search. In *Proceedings of the 43rd Annual Conference of the Cognitive Science Society* (pp. 348–354). Vienna, AT. arXiv: https://arxiv.org/abs/2103.13939 - - diff --git a/docs/theorist/darts/meta_parameters.md b/docs/theorist/darts/meta_parameters.md deleted file mode 100644 index 88daeee52..000000000 --- a/docs/theorist/darts/meta_parameters.md +++ /dev/null @@ -1,32 +0,0 @@ -# Differentiable Architecture Search - -## Meta-Parameters - -Meta-parameters are used to control the search space and the search algorithm. DARTS has quite a lot of those parameters. This section provides a basic overview of all parameters along with a description of their effects. - -### General DARTS meta-parameters - -- **`num_graph_nodes`**: The number of latent variables used to represent the model. -- **`max_epochs`**: The maximum number of epochs to run DARTS. This corresponds to the total number of architecture updates. These updates affect the architecture weights $\alpha$ indicating the relative contribution of each operation for a given computation step. - -### Meta-parameters for the architecture updates -The following parameters affect the updating of the architecture weights $\alpha$: - -- **`arch_learning_rate_max`**: The initial (maximum) learning rate for updating the architecture updates. The higher the learning rate, the larger the steps taken to update the architecture weights. The learning rate decays with each epoch. -- **`arch_weight_decay`**: The weight decay for the architecture weights. The higher the weight decay, the more the high architecture weights are pressured to be small. -- **`arch_weight_decay_df`**: An additional weight decay that scales with the number of parameters (degrees of freedom) per operation. The higher this weight decay, the more DARTS will favor operations with few parameters. - -### Meta-parameters for the parameter updates -The following parameters affect the updating of the parameters associated with each operation: - -- **`param_updates_per_epoch`**: The number of steps taken by the parameter optimizer per epoch. Once the architecture updates are complete, the parameters associated with each operation are updated by a stochastic gradient descent over this number of steps. -- **`param_learning_rate_max`**: The initial (maximum) learning rate for updating the parameters. The higher the learning rate, the larger the steps taken to update the parameters. Note that the learning rate is scheduled to converge over the total number of parameter updates to **`learning_rate_min`**. -- **`param_learning_rate_min`**: The smallest possible learning rate for updating the parameters. -- **`param_momentum`**: The momentum for the architecture updates. The higher the momentum, the more the steps taken to update the architecture weights will be influenced by previous steps. -- **`param_weight_decay`**: The weight decay for the parameters. The higher the weight decay, the more the high parameters of each operation are pressured to be small. - -### Meta-parameters for the classifier -The final output of the DARTS model is computed by concatenating all edges in the computation graph into a single vector and then adding a linear classifier. The linear classifier can attach a coefficient to each edge (weighing the contribution of that edge to the final output), and it can add a constant bias term. The following parameters affect the behavior of the classifier: - -- **`train_classifier_coefficients`**: If set to `True`, the classifier coefficient of each edge will be trained (otherwise each coefficient is set to `1`, reflecting an equal contribution of each edge to the final output). -- **`train_classifier_bias`**: If set to `True`, the bias term of the classifier will be trained (otherwise the bias term is set to `0`). diff --git a/docs/theorist/darts/search_space.md b/docs/theorist/darts/search_space.md deleted file mode 100644 index 2cdf9af47..000000000 --- a/docs/theorist/darts/search_space.md +++ /dev/null @@ -1,61 +0,0 @@ -# Differentiable Architecture Search - -## Search space - -DARTS uses a search space of operations to find the best model. The search space is defined by the set of operations that can be applied in each computation step of the model. These operations are also referred to as *primitives*. We can select from the following space of primitives: - -- **zero**: The output of the computation $x_j$ is not dependent on its input $x_i$. -- **add**: The output of the computation $x_j$ amounts to its input $x_i$. -- **subtract**: The output of the computation $x_j$ amounts to $-x_i$. -- **mult**: The output of the computation $x_j$ is its input $x_i$ multiplied by some constant $a$. -- **linear**: The output of the computation $x_j$ is linearly dependent on its input $x_i$: $x_j = a * x_i + b$. -- **relu**: The output of the computation $x_j$ is a rectified linear function of its input $x_i$: $x_j = \max(0, x_i)$. -- **exp**: The output of the computation $x_j$ is exponentially dependent on its input $x_i$: $x_j = \exp(x_i)$. -- **logistic**: The output of the computation $x_j$ is a logistic function of its input $x_i$: $x_j = \frac{1}{1 + \exp(-b * x_i)}$. -- **sin**: The output of the computation $x_j$ is the sine function of its input $x_i$: $x_j = \sin(x_i)$. -- **cos**: The output of the computation $x_j$ is the cosine function of its input $x_i$: $x_j = \cos(x_i)$. -- **tanh**: The output of the computation $x_j$ is the hyperbolic tangent function of its input $x_i$: $x_j = \tanh(x_i)$. - -Some of the primitives above may also be preceded by a linear transformation, allowing for more degrees of freedom in the search space: - -- **linear_relu**: The output of the computation $x_j$ is a rectified linear function of its *linearly transformed* input $x_i$: $x_j = \max(0, (a * x_i + b)$. -- **linear_exp**: The output of the computation $x_j$ is exponentially dependent on its *linearly transformed* input $x_i$: $x_j = \exp(a * x_i + b)$. -- **linear_logistic**: The output of the computation $x_j$ is a logistic function of its *linearly transformed* input $x_i$: $x_j = \frac{1}{1 + \exp(-b * (a * x_i + b))}$. -- **linear_sin**: The output of the computation $x_j$ the sine function of its *linearly transformed* input $x_i$: $x_j = a * \sin(a * x_i + b)$. -- **linear_cos**: The output of the computation $x_j$ the cosine function of its *linearly transformed* input $x_i$: $x_j = a * \cos(a * x_i + b)$. -- **linear_tanh**: The output of the computation $x_j$ the hyperbolic tangent function of its *linearly transformed* input $x_i$: $x_j = a * \tanh(a * x_i + b)$. - -Note that the following functions are available but currently not identifiable by DARTS (please use the following functions with caution): - -- **reciprocal**: The output of the computation $x_j$ is the multiplicative inverse of its input $x_i$: $x_j = \frac{1}{x_i}$. -- **ln**: The output of the computation $x_j$ is the natural logarithm of its input $x_i$: $x_j = \ln(x_i)$. -- **softplus**: The output of the computation $x_j$ is a softplus function of its input $x_i$: $x_j = \log(1 + \exp(a * x_i)) / a$. -- **softminus**: The output of the computation $x_j$ is a softminus function of its input $x_i$: $x_j = x_j - \log(1 + \exp(a * x_i)) / a$. - -# Example - -The following example sets up a search space with the following primitives: - -- zero operation -- addition -- multiplication -- sigmoid operation - -```python -primitives = [ - "zero", - "add", - "mult", - "linear_exp", -] -``` - -We can then pass these primitives directly to the DARTS regressor: - -```python -from autora.skl.darts import DARTSRegressor - -darts_estimator = DARTSRegressor( - primitives=primitives -) -``` diff --git a/docs/theorist/darts/weber.ipynb b/docs/theorist/darts/weber.ipynb deleted file mode 100644 index c728c226a..000000000 --- a/docs/theorist/darts/weber.ipynb +++ /dev/null @@ -1,348 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "source": [ - "Example file which shows some simple curve fitting using DARTSRegressor and some other estimators." - ], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": [ - "# Uncomment the following line when running on Google Colab\n", - "# !pip install autora" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": 1, - "outputs": [], - "source": [ - "from functools import partial\n", - "\n", - "import matplotlib.pyplot as plt\n", - "import numpy as np\n", - "import pandas as pd\n", - "from sklearn.linear_model import LinearRegression\n", - "from sklearn.model_selection import GridSearchCV\n", - "from sklearn.pipeline import make_pipeline\n", - "from sklearn.preprocessing import PolynomialFeatures\n", - "\n", - "from autora.skl.darts import DARTSRegressor\n", - "from autora.synthetic import retrieve, describe" - ], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "# %% Define some helper functions\n", - "\n", - "def show_results_complete(\n", - " data_: pd.DataFrame,\n", - " estimator=None,\n", - " show_results=True,\n", - " projection=\"2d\",\n", - " label=None,\n", - "):\n", - " \"\"\"\n", - " Function to plot input data (x_, y_) and the predictions of an estimator for the same x_.\n", - " \"\"\"\n", - " if projection == \"2d\":\n", - " plt.figure()\n", - " data_.plot.scatter(\n", - " \"S1\", \"S2\", c=\"difference_detected\", cmap=\"viridis\", zorder=10\n", - " )\n", - " elif projection == \"3d\":\n", - " fig = plt.figure()\n", - " ax = fig.add_subplot(projection=\"3d\")\n", - " ax.scatter(data_[\"S1\"], data[\"S2\"], data[\"difference_detected\"])\n", - "\n", - " if estimator is not None:\n", - " xs, ys = np.mgrid[0:5:0.2, 0:5:0.2] # type: ignore\n", - "\n", - " zs = estimator.predict(np.column_stack((xs.ravel(), ys.ravel())))\n", - "\n", - " ax.plot_surface(xs, ys, zs.reshape(xs.shape), alpha=0.5)\n", - "\n", - " if label is not None:\n", - " plt.title(label)\n", - "\n", - " if show_results:\n", - " plt.show()\n", - "\n", - " return\n" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "outputs": [], - "source": [ - "# %% Load the data\n", - "s = retrieve(\"weber_fechner\",rng=np.random.default_rng(seed=180), resolution=20)\n", - "X = s.domain()\n", - "y = s.experiment_runner(X)\n", - "data = pd.DataFrame(np.column_stack([X, y]), columns=[\"S1\", \"S2\", \"difference_detected\"])" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": 4, - "outputs": [ - { - "data": { - "text/plain": "
", - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "show_results = partial(show_results_complete, data_=data, projection=\"3d\")\n", - "show_results(label=\"input data\")" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": "
", - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# %% Fit first using a super-simple linear regression\n", - "\n", - "first_order_linear_estimator = LinearRegression()\n", - "first_order_linear_estimator.fit(X, y)\n", - "\n", - "show_results(estimator=first_order_linear_estimator, label=\"1st order linear\")" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": "
", - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# %% Fit using a 0-3 order polynomial, getting the best fit for the data.\n", - "polynomial_estimator = GridSearchCV(\n", - " make_pipeline(PolynomialFeatures(), LinearRegression(fit_intercept=False)),\n", - " param_grid=dict(polynomialfeatures__degree=range(4)),\n", - ")\n", - "polynomial_estimator.fit(X, y)\n", - "\n", - "show_results(estimator=polynomial_estimator, label=\"[0th-3rd]-order linear\")" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "outputs": [ - { - "data": { - "text/plain": " 0%| | 0/30 [00:00", - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/svg+xml": "\n\n\n\n\n\n\n\n\nx1\n\nx1\n\n\n\nk1\n\nk1\n\n\n\nx1->k1\n\n\nlogistic(x)\n\n\n\nk3\n\nk3\n\n\n\nx1->k3\n\n\n-2.40 * x + -0.14\n\n\n\nk5\n\nk5\n\n\n\nx1->k5\n\n\n-0.92 * x + 0.12\n\n\n\nx2\n\nx2\n\n\n\nx2->k1\n\n\n-0.73 * x + -0.66\n\n\n\nk2\n\nk2\n\n\n\nx2->k2\n\n\nlogistic(x)\n\n\n\nx2->k3\n\n\n0.52 * x + -0.51\n\n\n\nk4\n\nk4\n\n\n\nx2->k4\n\n\n0.71 * x + 0.45\n\n\n\nx2->k5\n\n\nlogistic(x)\n\n\n\nk1->k2\n\n\n-1.12 * x + -0.91\n\n\n\nk1->k3\n\n\n-1.02 * x + -0.76\n\n\n\nk1->k4\n\n\n-0.39 * x + 0.70\n\n\n\nP(detected) = Sigmoid(x + 0.00)\n\nP(detected) = Sigmoid(x + 0.00)\n\n\n\nk1->P(detected) = Sigmoid(x + 0.00)\n\n\n1.00 * x\n\n\n\nk2->k4\n\n\nlogistic(x)\n\n\n\nk2->k5\n\n\nlogistic(x)\n\n\n\nk2->P(detected) = Sigmoid(x + 0.00)\n\n\n1.00 * x\n\n\n\nk3->k4\n\n\n1.35 * x + 0.49\n\n\n\nk3->k5\n\n\n1.35 * x + 0.37\n\n\n\nk3->P(detected) = Sigmoid(x + 0.00)\n\n\n1.00 * x\n\n\n\nk4->k5\n\n\n0.54 * x + 0.56\n\n\n\nk4->P(detected) = Sigmoid(x + 0.00)\n\n\n1.00 * x\n\n\n\nk5->P(detected) = Sigmoid(x + 0.00)\n\n\n1.00 * x\n\n\n\n", - "text/plain": "" - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "darts_estimator_tuned = DARTSRegressor(\n", - " batch_size=64,\n", - " arch_updates_per_epoch=100,\n", - " param_updates_per_epoch=100,\n", - " max_epochs=30,\n", - " output_type=\"probability\",\n", - " num_graph_nodes=5,\n", - " primitives=[\n", - " \"none\",\n", - " \"linear\",\n", - " \"logistic\",\n", - " ]\n", - ")\n", - "\n", - "darts_estimator_tuned.fit(X, y)\n", - "\n", - "show_results(estimator=darts_estimator_tuned, label=\"pre-tuned DARTSRegressor\")\n", - "darts_estimator_tuned.visualize_model()" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": 8, - "outputs": [ - { - "data": { - "text/plain": " 0%| | 0/1 [00:00", - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/svg+xml": "\n\n\n\n\n\n\n\n\nx1\n\nx1\n\n\n\nk4\n\nk4\n\n\n\nx1->k4\n\n\n-0.63 * x + 0.40\n\n\n\nk5\n\nk5\n\n\n\nx1->k5\n\n\n-1.56 * x + 0.03\n\n\n\nx2\n\nx2\n\n\n\nk2\n\nk2\n\n\n\nx2->k2\n\n\n-0.27 * x + -0.38\n\n\n\nk3\n\nk3\n\n\n\nx2->k3\n\n\nlogistic(x)\n\n\n\nx2->k4\n\n\n0.81 * x + 0.32\n\n\n\nx2->k5\n\n\nlogistic(x)\n\n\n\nk1\n\nk1\n\n\n\nk1->k3\n\n\n-1.38 * x + -1.09\n\n\n\nk1->k4\n\n\nlogistic(x)\n\n\n\nP(detected) = Sigmoid(x + 0.00)\n\nP(detected) = Sigmoid(x + 0.00)\n\n\n\nk1->P(detected) = Sigmoid(x + 0.00)\n\n\n1.00 * x\n\n\n\nk2->k4\n\n\nlogistic(x)\n\n\n\nk2->P(detected) = Sigmoid(x + 0.00)\n\n\n1.00 * x\n\n\n\nk3->k4\n\n\n1.40 * x + 0.36\n\n\n\nk3->k5\n\n\n1.36 * x + 0.26\n\n\n\nk3->P(detected) = Sigmoid(x + 0.00)\n\n\n1.00 * x\n\n\n\nk4->k5\n\n\nlogistic(x)\n\n\n\nk4->P(detected) = Sigmoid(x + 0.00)\n\n\n1.00 * x\n\n\n\nk5->P(detected) = Sigmoid(x + 0.00)\n\n\n1.00 * x\n\n\n\n", - "text/plain": "" - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "darts_estimator_tuned.set_params(\n", - " arch_updates_per_epoch=0,\n", - " param_updates_per_epoch=1000,\n", - " sampling_strategy=\"sample\",\n", - " max_epochs=1\n", - ")\n", - "darts_estimator_tuned.fit(X, y)\n", - "show_results(estimator=darts_estimator_tuned, label=\"resampled DARTSRegressor\")\n", - "darts_estimator_tuned.visualize_model()\n" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "execution_count": 9, - "outputs": [ - { - "data": { - "text/plain": "0it [00:00, ?it/s]", - "application/vnd.jupyter.widget-view+json": { - "version_major": 2, - "version_minor": 0, - "model_id": "d795b0ef59f340ecaa60a90cd7d9b0ff" - } - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": "
", - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/svg+xml": "\n\n\n\n\n\n\n\n\nx1\n\nx1\n\n\n\nk1\n\nk1\n\n\n\nx1->k1\n\n\nlogistic(x)\n\n\n\nk3\n\nk3\n\n\n\nx1->k3\n\n\n-2.40 * x + -0.11\n\n\n\nk5\n\nk5\n\n\n\nx1->k5\n\n\n-0.90 * x + 0.12\n\n\n\nx2\n\nx2\n\n\n\nx2->k1\n\n\n-0.66 * x + -0.67\n\n\n\nk2\n\nk2\n\n\n\nx2->k2\n\n\nlogistic(x)\n\n\n\nx2->k3\n\n\n0.47 * x + -0.46\n\n\n\nk4\n\nk4\n\n\n\nx2->k4\n\n\n0.70 * x + 0.43\n\n\n\nx2->k5\n\n\nlogistic(x)\n\n\n\nk1->k2\n\n\n-1.14 * x + -0.85\n\n\n\nk1->k3\n\n\n-1.11 * x + -0.70\n\n\n\nk1->k4\n\n\n-0.42 * x + 0.67\n\n\n\nP(detected) = Sigmoid(x + 0.00)\n\nP(detected) = Sigmoid(x + 0.00)\n\n\n\nk1->P(detected) = Sigmoid(x + 0.00)\n\n\n1.00 * x\n\n\n\nk2->k4\n\n\nlogistic(x)\n\n\n\nk2->k5\n\n\nlogistic(x)\n\n\n\nk2->P(detected) = Sigmoid(x + 0.00)\n\n\n1.00 * x\n\n\n\nk3->k4\n\n\n1.38 * x + 0.47\n\n\n\nk3->k5\n\n\n1.35 * x + 0.36\n\n\n\nk3->P(detected) = Sigmoid(x + 0.00)\n\n\n1.00 * x\n\n\n\nk4->k5\n\n\n0.56 * x + 0.54\n\n\n\nk4->P(detected) = Sigmoid(x + 0.00)\n\n\n1.00 * x\n\n\n\nk5->P(detected) = Sigmoid(x + 0.00)\n\n\n1.00 * x\n\n\n\n", - "text/plain": "" - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "darts_estimator_tuned.set_params(\n", - " arch_updates_per_epoch=0,\n", - " param_updates_per_epoch=1000,\n", - " sampling_strategy=\"max\",\n", - " max_epochs=0\n", - ")\n", - "darts_estimator_tuned.fit(X, y)\n", - "show_results(estimator=darts_estimator_tuned, label=\"resampled DARTSRegressor\")\n", - "darts_estimator_tuned.visualize_model()\n" - ], - "metadata": { - "collapsed": false - } - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "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.8.13" - } - }, - "nbformat": 4, - "nbformat_minor": 1 -} diff --git a/docs/theorist/overview.md b/docs/theorist/index.md similarity index 100% rename from docs/theorist/overview.md rename to docs/theorist/index.md diff --git a/docs/tutorials/index.md b/docs/tutorials/index.md new file mode 100644 index 000000000..81c8590f8 --- /dev/null +++ b/docs/tutorials/index.md @@ -0,0 +1 @@ +# Tutorials diff --git a/mkdocs.yml b/mkdocs.yml index 2eeebf594..889e87f8f 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -1,9 +1,12 @@ # yaml-language-server: $schema=https://squidfunk.github.io/mkdocs-material/schema.json -site_name: Autonomous Empirical Research +site_name: Automated Research Assistant repo_url: 'https://github.com/autoresearch/autora' edit_uri: 'blob/main/docs/' +extra: + colab_base_url: 'https://colab.research.google.com/github/AutoResearch/autora/blob/gh-pages' + theme: name: material logo: img/logo.png @@ -24,85 +27,81 @@ theme: custom_dir: mkdocs/overrides features: - content.action.edit - -watch: - - autora/ + - content.action.view + - navigation.indexes plugins: - - search - - gen-files: - scripts: - - mkdocs/_gen_ref_pages.py - - literate-nav: - nav_file: SUMMARY.md - - section-index - - mkdocstrings: - handlers: - python: - import: - - https://scikit-learn.org/stable/objects.inv - - mkdocs-jupyter: - include_source: true - execute: false - ignore_h1_titles: True - + multirepo: + nav_repos: + - name: core + import_url: https://github.com/autoresearch/autora-core/?branch=main&extra_imports=["mkdocs/base.yml"] + imports: ["docs/pipeline/*",] + - name: falsification + import_url: https://github.com/autoresearch/autora-experimentalist-falsification/?branch=main&extra_imports=["mkdocs/base.yml"] + imports: ["docs/*", "docs/sampler/*", "docs/pooler/*"] + mkdocs-jupyter: # required to convert Jupyter notebooks + include_source: true + execute: false + ignore_h1_titles: true + search: {} markdown_extensions: - - pymdownx.arithmatex: - generic: true - -extra_javascript: - - javascripts/mathjax.js - - https://polyfill.io/v3/polyfill.min.js?features=es6 - - https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-mml-chtml.js + admonition: {} + pymdownx.details: {} + pymdownx.superfences: {} + pymdownx.arithmatex: # required for equation display + generic: true + pymdownx.snippets: {} + pymdownx.tabbed: + alternate_style: true +extra_javascript: [ + # requirements for pymdownx.arithmetex: + "javascripts/mathjax.js", + "https://polyfill.io/v3/polyfill.min.js?features=es6", + "https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-chtml.js" +] nav: - Introduction: 'index.md' -- Tutorials: - - Automated Theorist - - Automated Experimentalist - - Closed-Loop Discovery - User Guide: - Theorists: - - Overview: 'theorist/overview.md' - - DARTS: - - Introduction: 'theorist/darts/introduction.md' - - How it works: 'theorist/darts/how_it_works.md' - - Meta parameters: 'theorist/darts/meta_parameters.md' - - Search space: 'theorist/darts/search_space.md' - - Examples: - - Basic Usage: 'theorist/darts/example.ipynb' - - Weber-Fechner Law: 'theorist/darts/weber.ipynb' - - BMS: - - Introduction: 'theorist/bms/introduction.md' - - How it works: 'theorist/bms/how_it_works.md' - - Meta parameters: 'theorist/bms/meta_parameters.md' - - Search space: 'theorist/bms/search_space.ipynb' - - Examples: - - Basic Usage: 'theorist/bms/example.ipynb' - - Weber-Fechner Law: 'theorist/bms/weber.ipynb' - - BSR: - - Introduction: 'theorist/bsr/introduction.md' - - How it works: 'theorist/bsr/how_it_works.md' - - Meta parameters: 'theorist/bsr/meta_parameters.md' - - Search space: 'theorist/bsr/search_space.md' - - Example: 'theorist/bsr/bsr.ipynb' + - Home: 'theorist/index.md' + - DARTS: '!import https://github.com/autoresearch/autora-theorist-darts/?branch=main&extra_imports=["mkdocs/base.yml"]' + - BMS: '!import https://github.com/autoresearch/autora-theorist-bms/?branch=main&extra_imports=["mkdocs/base.yml"]' + - BSR: '!import https://github.com/autoresearch/autora-theorist-bsr/?branch=main&extra_imports=["mkdocs/base.yml"]' - Experimentalists: - - Overview: 'experimentalists/overview.md' - - Pipeline: 'pipeline/Experimentalist Pipeline Examples.ipynb' - - Synthetic Experiments: - - Inventory: 'synthetic/inventory.ipynb' - - Cycle: - - Scoring: - - Logistic Regression: 'cycle/cycle_scoring.ipynb' - - BMS: 'cycle/cycle_scoring_bms.ipynb' - - Plotting: 'cycle/cycle_results_plots.ipynb' - - Examples: - - DARTS & BMS: 'cycle/simple_cycle_bms_darts.ipynb' - - BMS & Poppernet: 'cycle/simple_cycle_bms_model_poppernet.ipynb' - - Uncertainty Experimentalist: 'cycle/simple_cycle_uncertainty_experimentalist.ipynb' + - Home: 'experimentalist/index.md' + - Pipeline: 'core/docs/pipeline/Experimentalist Pipeline Examples.ipynb' + - Samplers: + - Novelty: '!import https://github.com/autoresearch/autora-experimentalist-sampler-novelty/?branch=main&extra_imports=["mkdocs/base.yml"]' + - Inequality: '!import https://github.com/autoresearch/autora-experimentalist-sampler-inequality/?branch=main&extra_imports=["mkdocs/base.yml"]' + - Nearest Value: '!import https://github.com/autoresearch/autora-experimentalist-sampler-nearest-value/?branch=main&extra_imports=["mkdocs/base.yml"]' + - Model Disagreement: '!import https://github.com/autoresearch/autora-experimentalist-sampler-model-disagreement/?branch=main&extra_imports=["mkdocs/base.yml"]' + - Uncertainty: '!import https://github.com/autoresearch/autora-experimentalist-sampler-uncertainty/?branch=main&extra_imports=["mkdocs/base.yml"]' + - Falsification: + - Home: 'falsification/docs/sampler/index.md' + - Quickstart: 'falsification/docs/sampler/quickstart.md' + - Examples: + - Basic Usage: 'falsification/docs/sampler/Basic Usage.ipynb' + - Poolers: + - Falsification: + - Home: 'falsification/docs/pooler/index.md' + - Quickstart: 'falsification/docs/pooler/quickstart.md' + - Examples: + - Basic Usage: 'falsification/docs/pooler/Basic Usage.ipynb' + - Experiment Runners: + - Home: 'experiment-runner/index.md' + - Synthetic: '!import https://github.com/autoresearch/autora-synthetic/?branch=main&extra_imports=["mkdocs/base.yml"]' + - Firebase-Prolific: '!import https://github.com/autoresearch/autora-experiment-runner-firebase-prolific/?branch=main&extra_imports=["mkdocs/base.yml"]' + - Experimentation Managers: + - Firebase: '!import https://github.com/autoresearch/autora-experiment-runner-experimentation-manager-firebase/?branch=main&extra_imports=["mkdocs/base.yml"]' + - Recruitment Managers: + - Prolific: '!import https://github.com/autoresearch/autora-experiment-runner-recruitment-manager-prolific/?branch=main&extra_imports=["mkdocs/base.yml"]' + - Workflow: '!import https://github.com/autoresearch/autora-workflow/?branch=main&extra_imports=["mkdocs/base.yml"]' - Contributor Guide: - - Module Contributions - - Core Contributions -- Code Reference: reference/autora/ + - Overview: 'contribute/index.md' + - Module Contributions: 'contribute/module.md' + - Core Contributions: 'contribute/core.md' + - Environment Setup: 'contribute/setup.md' + - Pre-Commit Hooks: 'contribute/pre-commit-hooks.md' diff --git a/mkdocs/_gen_ref_pages.py b/mkdocs/_gen_ref_pages.py deleted file mode 100644 index 5942f2eb3..000000000 --- a/mkdocs/_gen_ref_pages.py +++ /dev/null @@ -1,36 +0,0 @@ -"""Generate the code reference pages and navigation.""" - -from pathlib import Path -from typing import List - -import mkdocs_gen_files - -nav = mkdocs_gen_files.Nav() - -source_paths = sorted(Path("./autora").rglob("*.py")) -special_paths: List[Path] = [] - -for path in source_paths + special_paths: - module_path = path.relative_to(".").with_suffix("") - doc_path = path.relative_to(".").with_suffix(".md") - full_doc_path = Path("reference", doc_path) - - parts = tuple(module_path.parts) - - if parts[-1] == "__init__": - parts = parts[:-1] - doc_path = doc_path.with_name("index.md") - full_doc_path = full_doc_path.with_name("index.md") - elif parts[-1] == "__main__": - continue - - nav[parts] = doc_path.as_posix() - - with mkdocs_gen_files.open(full_doc_path, "w") as fd: - ident = ".".join(parts) - fd.write(f"::: {ident}") - - mkdocs_gen_files.set_edit_path(full_doc_path, path) - -with mkdocs_gen_files.open("reference/SUMMARY.md", "w") as nav_file: - nav_file.writelines(nav.build_literate_nav()) diff --git a/mkdocs/overrides/main.html b/mkdocs/overrides/main.html index 611f41563..6fd63f8e9 100644 --- a/mkdocs/overrides/main.html +++ b/mkdocs/overrides/main.html @@ -5,15 +5,10 @@ {% include ".icons/material/download.svg" %} + + {% include ".icons/material/play-circle-outline.svg" %} + {% endif %} -{% if page.file.src_uri %} - {% if page.file.src_uri.endswith('.ipynb') %} - - {% include ".icons/material/play-circle-outline.svg" %} - - {% endif %} -{% endif %} - {{ super() }} {% endblock content %} diff --git a/poetry.lock b/poetry.lock deleted file mode 100644 index 1e33ccde2..000000000 --- a/poetry.lock +++ /dev/null @@ -1,3864 +0,0 @@ -# This file is automatically @generated by Poetry and should not be changed by hand. - -[[package]] -name = "anyio" -version = "3.6.2" -description = "High level compatibility layer for multiple asynchronous event loop implementations" -category = "dev" -optional = false -python-versions = ">=3.6.2" -files = [ - {file = "anyio-3.6.2-py3-none-any.whl", hash = "sha256:fbbe32bd270d2a2ef3ed1c5d45041250284e31fc0a4df4a5a6071842051a51e3"}, - {file = "anyio-3.6.2.tar.gz", hash = "sha256:25ea0d673ae30af41a0c442f81cf3b38c7e79fdc7b60335a4c14e05eb0947421"}, -] - -[package.dependencies] -idna = ">=2.8" -sniffio = ">=1.1" - -[package.extras] -doc = ["packaging", "sphinx-autodoc-typehints (>=1.2.0)", "sphinx-rtd-theme"] -test = ["contextlib2", "coverage[toml] (>=4.5)", "hypothesis (>=4.0)", "mock (>=4)", "pytest (>=7.0)", "pytest-mock (>=3.6.1)", "trustme", "uvloop (<0.15)", "uvloop (>=0.15)"] -trio = ["trio (>=0.16,<0.22)"] - -[[package]] -name = "appnope" -version = "0.1.3" -description = "Disable App Nap on macOS >= 10.9" -category = "dev" -optional = false -python-versions = "*" -files = [ - {file = "appnope-0.1.3-py2.py3-none-any.whl", hash = "sha256:265a455292d0bd8a72453494fa24df5a11eb18373a60c7c0430889f22548605e"}, - {file = "appnope-0.1.3.tar.gz", hash = "sha256:02bd91c4de869fbb1e1c50aafc4098827a7a54ab2f39d9dcba6c9547ed920e24"}, -] - -[[package]] -name = "argon2-cffi" -version = "21.3.0" -description = "The secure Argon2 password hashing algorithm." -category = "dev" -optional = false -python-versions = ">=3.6" -files = [ - {file = "argon2-cffi-21.3.0.tar.gz", hash = "sha256:d384164d944190a7dd7ef22c6aa3ff197da12962bd04b17f64d4e93d934dba5b"}, - {file = "argon2_cffi-21.3.0-py3-none-any.whl", hash = "sha256:8c976986f2c5c0e5000919e6de187906cfd81fb1c72bf9d88c01177e77da7f80"}, -] - -[package.dependencies] -argon2-cffi-bindings = "*" - -[package.extras] -dev = ["cogapp", "coverage[toml] (>=5.0.2)", "furo", "hypothesis", "pre-commit", "pytest", "sphinx", "sphinx-notfound-page", "tomli"] -docs = ["furo", "sphinx", "sphinx-notfound-page"] -tests = ["coverage[toml] (>=5.0.2)", "hypothesis", "pytest"] - -[[package]] -name = "argon2-cffi-bindings" -version = "21.2.0" -description = "Low-level CFFI bindings for Argon2" -category = "dev" -optional = false -python-versions = ">=3.6" -files = [ - {file = "argon2-cffi-bindings-21.2.0.tar.gz", hash = "sha256:bb89ceffa6c791807d1305ceb77dbfacc5aa499891d2c55661c6459651fc39e3"}, - {file = "argon2_cffi_bindings-21.2.0-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:ccb949252cb2ab3a08c02024acb77cfb179492d5701c7cbdbfd776124d4d2367"}, - {file = "argon2_cffi_bindings-21.2.0-cp36-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9524464572e12979364b7d600abf96181d3541da11e23ddf565a32e70bd4dc0d"}, - {file = "argon2_cffi_bindings-21.2.0-cp36-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b746dba803a79238e925d9046a63aa26bf86ab2a2fe74ce6b009a1c3f5c8f2ae"}, - {file = "argon2_cffi_bindings-21.2.0-cp36-abi3-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:58ed19212051f49a523abb1dbe954337dc82d947fb6e5a0da60f7c8471a8476c"}, - {file = "argon2_cffi_bindings-21.2.0-cp36-abi3-musllinux_1_1_aarch64.whl", hash = "sha256:bd46088725ef7f58b5a1ef7ca06647ebaf0eb4baff7d1d0d177c6cc8744abd86"}, - {file = "argon2_cffi_bindings-21.2.0-cp36-abi3-musllinux_1_1_i686.whl", hash = "sha256:8cd69c07dd875537a824deec19f978e0f2078fdda07fd5c42ac29668dda5f40f"}, - {file = "argon2_cffi_bindings-21.2.0-cp36-abi3-musllinux_1_1_x86_64.whl", hash = "sha256:f1152ac548bd5b8bcecfb0b0371f082037e47128653df2e8ba6e914d384f3c3e"}, - {file = "argon2_cffi_bindings-21.2.0-cp36-abi3-win32.whl", hash = "sha256:603ca0aba86b1349b147cab91ae970c63118a0f30444d4bc80355937c950c082"}, - {file = "argon2_cffi_bindings-21.2.0-cp36-abi3-win_amd64.whl", hash = "sha256:b2ef1c30440dbbcba7a5dc3e319408b59676e2e039e2ae11a8775ecf482b192f"}, - {file = "argon2_cffi_bindings-21.2.0-cp38-abi3-macosx_10_9_universal2.whl", hash = "sha256:e415e3f62c8d124ee16018e491a009937f8cf7ebf5eb430ffc5de21b900dad93"}, - {file = "argon2_cffi_bindings-21.2.0-pp37-pypy37_pp73-macosx_10_9_x86_64.whl", hash = "sha256:3e385d1c39c520c08b53d63300c3ecc28622f076f4c2b0e6d7e796e9f6502194"}, - {file = "argon2_cffi_bindings-21.2.0-pp37-pypy37_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2c3e3cc67fdb7d82c4718f19b4e7a87123caf8a93fde7e23cf66ac0337d3cb3f"}, - {file = "argon2_cffi_bindings-21.2.0-pp37-pypy37_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6a22ad9800121b71099d0fb0a65323810a15f2e292f2ba450810a7316e128ee5"}, - {file = "argon2_cffi_bindings-21.2.0-pp37-pypy37_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f9f8b450ed0547e3d473fdc8612083fd08dd2120d6ac8f73828df9b7d45bb351"}, - {file = "argon2_cffi_bindings-21.2.0-pp37-pypy37_pp73-win_amd64.whl", hash = "sha256:93f9bf70084f97245ba10ee36575f0c3f1e7d7724d67d8e5b08e61787c320ed7"}, - {file = "argon2_cffi_bindings-21.2.0-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:3b9ef65804859d335dc6b31582cad2c5166f0c3e7975f324d9ffaa34ee7e6583"}, - {file = "argon2_cffi_bindings-21.2.0-pp38-pypy38_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d4966ef5848d820776f5f562a7d45fdd70c2f330c961d0d745b784034bd9f48d"}, - {file = "argon2_cffi_bindings-21.2.0-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:20ef543a89dee4db46a1a6e206cd015360e5a75822f76df533845c3cbaf72670"}, - {file = "argon2_cffi_bindings-21.2.0-pp38-pypy38_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ed2937d286e2ad0cc79a7087d3c272832865f779430e0cc2b4f3718d3159b0cb"}, - {file = "argon2_cffi_bindings-21.2.0-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:5e00316dabdaea0b2dd82d141cc66889ced0cdcbfa599e8b471cf22c620c329a"}, -] - -[package.dependencies] -cffi = ">=1.0.1" - -[package.extras] -dev = ["cogapp", "pre-commit", "pytest", "wheel"] -tests = ["pytest"] - -[[package]] -name = "arrow" -version = "1.2.3" -description = "Better dates & times for Python" -category = "dev" -optional = false -python-versions = ">=3.6" -files = [ - {file = "arrow-1.2.3-py3-none-any.whl", hash = "sha256:5a49ab92e3b7b71d96cd6bfcc4df14efefc9dfa96ea19045815914a6ab6b1fe2"}, - {file = "arrow-1.2.3.tar.gz", hash = "sha256:3934b30ca1b9f292376d9db15b19446088d12ec58629bc3f0da28fd55fb633a1"}, -] - -[package.dependencies] -python-dateutil = ">=2.7.0" - -[[package]] -name = "asttokens" -version = "2.2.1" -description = "Annotate AST trees with source code positions" -category = "dev" -optional = false -python-versions = "*" -files = [ - {file = "asttokens-2.2.1-py2.py3-none-any.whl", hash = "sha256:6b0ac9e93fb0335014d382b8fa9b3afa7df546984258005da0b9e7095b3deb1c"}, - {file = "asttokens-2.2.1.tar.gz", hash = "sha256:4622110b2a6f30b77e1473affaa97e711bc2f07d3f10848420ff1898edbe94f3"}, -] - -[package.dependencies] -six = "*" - -[package.extras] -test = ["astroid", "pytest"] - -[[package]] -name = "attrs" -version = "22.2.0" -description = "Classes Without Boilerplate" -category = "dev" -optional = false -python-versions = ">=3.6" -files = [ - {file = "attrs-22.2.0-py3-none-any.whl", hash = "sha256:29e95c7f6778868dbd49170f98f8818f78f3dc5e0e37c0b1f474e3561b240836"}, - {file = "attrs-22.2.0.tar.gz", hash = "sha256:c9227bfc2f01993c03f68db37d1d15c9690188323c067c641f1a35ca58185f99"}, -] - -[package.extras] -cov = ["attrs[tests]", "coverage-enable-subprocess", "coverage[toml] (>=5.3)"] -dev = ["attrs[docs,tests]"] -docs = ["furo", "myst-parser", "sphinx", "sphinx-notfound-page", "sphinxcontrib-towncrier", "towncrier", "zope.interface"] -tests = ["attrs[tests-no-zope]", "zope.interface"] -tests-no-zope = ["cloudpickle", "cloudpickle", "hypothesis", "hypothesis", "mypy (>=0.971,<0.990)", "mypy (>=0.971,<0.990)", "pympler", "pympler", "pytest (>=4.3.0)", "pytest (>=4.3.0)", "pytest-mypy-plugins", "pytest-mypy-plugins", "pytest-xdist[psutil]", "pytest-xdist[psutil]"] - -[[package]] -name = "backcall" -version = "0.2.0" -description = "Specifications for callback functions passed in to an API" -category = "dev" -optional = false -python-versions = "*" -files = [ - {file = "backcall-0.2.0-py2.py3-none-any.whl", hash = "sha256:fbbce6a29f263178a1f7915c1940bde0ec2b2a967566fe1c65c1dfb7422bd255"}, - {file = "backcall-0.2.0.tar.gz", hash = "sha256:5cbdbf27be5e7cfadb448baf0aa95508f91f2bbc6c6437cd9cd06e2a4c215e1e"}, -] - -[[package]] -name = "beautifulsoup4" -version = "4.12.1" -description = "Screen-scraping library" -category = "dev" -optional = false -python-versions = ">=3.6.0" -files = [ - {file = "beautifulsoup4-4.12.1-py3-none-any.whl", hash = "sha256:e44795bb4f156d94abb5fbc56efff871c1045bfef72e9efe77558db9f9616ac3"}, - {file = "beautifulsoup4-4.12.1.tar.gz", hash = "sha256:c7bdbfb20a0dbe09518b96a809d93351b2e2bcb8046c0809466fa6632a10c257"}, -] - -[package.dependencies] -soupsieve = ">1.2" - -[package.extras] -html5lib = ["html5lib"] -lxml = ["lxml"] - -[[package]] -name = "bleach" -version = "6.0.0" -description = "An easy safelist-based HTML-sanitizing tool." -category = "dev" -optional = false -python-versions = ">=3.7" -files = [ - {file = "bleach-6.0.0-py3-none-any.whl", hash = "sha256:33c16e3353dbd13028ab4799a0f89a83f113405c766e9c122df8a06f5b85b3f4"}, - {file = "bleach-6.0.0.tar.gz", hash = "sha256:1a1a85c1595e07d8db14c5f09f09e6433502c51c595970edc090551f0db99414"}, -] - -[package.dependencies] -six = ">=1.9.0" -webencodings = "*" - -[package.extras] -css = ["tinycss2 (>=1.1.0,<1.2)"] - -[[package]] -name = "certifi" -version = "2022.12.7" -description = "Python package for providing Mozilla's CA Bundle." -category = "dev" -optional = false -python-versions = ">=3.6" -files = [ - {file = "certifi-2022.12.7-py3-none-any.whl", hash = "sha256:4ad3232f5e926d6718ec31cfc1fcadfde020920e278684144551c91769c7bc18"}, - {file = "certifi-2022.12.7.tar.gz", hash = "sha256:35824b4c3a97115964b408844d64aa14db1cc518f6562e8d7261699d1350a9e3"}, -] - -[[package]] -name = "cffi" -version = "1.15.1" -description = "Foreign Function Interface for Python calling C code." -category = "dev" -optional = false -python-versions = "*" -files = [ - {file = "cffi-1.15.1-cp27-cp27m-macosx_10_9_x86_64.whl", hash = "sha256:a66d3508133af6e8548451b25058d5812812ec3798c886bf38ed24a98216fab2"}, - {file = "cffi-1.15.1-cp27-cp27m-manylinux1_i686.whl", hash = "sha256:470c103ae716238bbe698d67ad020e1db9d9dba34fa5a899b5e21577e6d52ed2"}, - {file = "cffi-1.15.1-cp27-cp27m-manylinux1_x86_64.whl", hash = "sha256:9ad5db27f9cabae298d151c85cf2bad1d359a1b9c686a275df03385758e2f914"}, - {file = "cffi-1.15.1-cp27-cp27m-win32.whl", hash = "sha256:b3bbeb01c2b273cca1e1e0c5df57f12dce9a4dd331b4fa1635b8bec26350bde3"}, - {file = "cffi-1.15.1-cp27-cp27m-win_amd64.whl", hash = "sha256:e00b098126fd45523dd056d2efba6c5a63b71ffe9f2bbe1a4fe1716e1d0c331e"}, - {file = "cffi-1.15.1-cp27-cp27mu-manylinux1_i686.whl", hash = "sha256:d61f4695e6c866a23a21acab0509af1cdfd2c013cf256bbf5b6b5e2695827162"}, - {file = "cffi-1.15.1-cp27-cp27mu-manylinux1_x86_64.whl", hash = "sha256:ed9cb427ba5504c1dc15ede7d516b84757c3e3d7868ccc85121d9310d27eed0b"}, - {file = "cffi-1.15.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:39d39875251ca8f612b6f33e6b1195af86d1b3e60086068be9cc053aa4376e21"}, - {file = "cffi-1.15.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:285d29981935eb726a4399badae8f0ffdff4f5050eaa6d0cfc3f64b857b77185"}, - {file = "cffi-1.15.1-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3eb6971dcff08619f8d91607cfc726518b6fa2a9eba42856be181c6d0d9515fd"}, - {file = "cffi-1.15.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:21157295583fe8943475029ed5abdcf71eb3911894724e360acff1d61c1d54bc"}, - {file = "cffi-1.15.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5635bd9cb9731e6d4a1132a498dd34f764034a8ce60cef4f5319c0541159392f"}, - {file = "cffi-1.15.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2012c72d854c2d03e45d06ae57f40d78e5770d252f195b93f581acf3ba44496e"}, - {file = "cffi-1.15.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dd86c085fae2efd48ac91dd7ccffcfc0571387fe1193d33b6394db7ef31fe2a4"}, - {file = "cffi-1.15.1-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:fa6693661a4c91757f4412306191b6dc88c1703f780c8234035eac011922bc01"}, - {file = "cffi-1.15.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:59c0b02d0a6c384d453fece7566d1c7e6b7bae4fc5874ef2ef46d56776d61c9e"}, - {file = "cffi-1.15.1-cp310-cp310-win32.whl", hash = "sha256:cba9d6b9a7d64d4bd46167096fc9d2f835e25d7e4c121fb2ddfc6528fb0413b2"}, - {file = "cffi-1.15.1-cp310-cp310-win_amd64.whl", hash = "sha256:ce4bcc037df4fc5e3d184794f27bdaab018943698f4ca31630bc7f84a7b69c6d"}, - {file = "cffi-1.15.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:3d08afd128ddaa624a48cf2b859afef385b720bb4b43df214f85616922e6a5ac"}, - {file = "cffi-1.15.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:3799aecf2e17cf585d977b780ce79ff0dc9b78d799fc694221ce814c2c19db83"}, - {file = "cffi-1.15.1-cp311-cp311-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a591fe9e525846e4d154205572a029f653ada1a78b93697f3b5a8f1f2bc055b9"}, - {file = "cffi-1.15.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3548db281cd7d2561c9ad9984681c95f7b0e38881201e157833a2342c30d5e8c"}, - {file = "cffi-1.15.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:91fc98adde3d7881af9b59ed0294046f3806221863722ba7d8d120c575314325"}, - {file = "cffi-1.15.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:94411f22c3985acaec6f83c6df553f2dbe17b698cc7f8ae751ff2237d96b9e3c"}, - {file = "cffi-1.15.1-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:03425bdae262c76aad70202debd780501fabeaca237cdfddc008987c0e0f59ef"}, - {file = "cffi-1.15.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:cc4d65aeeaa04136a12677d3dd0b1c0c94dc43abac5860ab33cceb42b801c1e8"}, - {file = "cffi-1.15.1-cp311-cp311-win32.whl", hash = "sha256:a0f100c8912c114ff53e1202d0078b425bee3649ae34d7b070e9697f93c5d52d"}, - {file = "cffi-1.15.1-cp311-cp311-win_amd64.whl", hash = "sha256:04ed324bda3cda42b9b695d51bb7d54b680b9719cfab04227cdd1e04e5de3104"}, - {file = "cffi-1.15.1-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:50a74364d85fd319352182ef59c5c790484a336f6db772c1a9231f1c3ed0cbd7"}, - {file = "cffi-1.15.1-cp36-cp36m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e263d77ee3dd201c3a142934a086a4450861778baaeeb45db4591ef65550b0a6"}, - {file = "cffi-1.15.1-cp36-cp36m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:cec7d9412a9102bdc577382c3929b337320c4c4c4849f2c5cdd14d7368c5562d"}, - {file = "cffi-1.15.1-cp36-cp36m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4289fc34b2f5316fbb762d75362931e351941fa95fa18789191b33fc4cf9504a"}, - {file = "cffi-1.15.1-cp36-cp36m-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:173379135477dc8cac4bc58f45db08ab45d228b3363adb7af79436135d028405"}, - {file = "cffi-1.15.1-cp36-cp36m-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:6975a3fac6bc83c4a65c9f9fcab9e47019a11d3d2cf7f3c0d03431bf145a941e"}, - {file = "cffi-1.15.1-cp36-cp36m-win32.whl", hash = "sha256:2470043b93ff09bf8fb1d46d1cb756ce6132c54826661a32d4e4d132e1977adf"}, - {file = "cffi-1.15.1-cp36-cp36m-win_amd64.whl", hash = "sha256:30d78fbc8ebf9c92c9b7823ee18eb92f2e6ef79b45ac84db507f52fbe3ec4497"}, - {file = "cffi-1.15.1-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:198caafb44239b60e252492445da556afafc7d1e3ab7a1fb3f0584ef6d742375"}, - {file = "cffi-1.15.1-cp37-cp37m-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:5ef34d190326c3b1f822a5b7a45f6c4535e2f47ed06fec77d3d799c450b2651e"}, - {file = "cffi-1.15.1-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8102eaf27e1e448db915d08afa8b41d6c7ca7a04b7d73af6514df10a3e74bd82"}, - {file = "cffi-1.15.1-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5df2768244d19ab7f60546d0c7c63ce1581f7af8b5de3eb3004b9b6fc8a9f84b"}, - {file = "cffi-1.15.1-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a8c4917bd7ad33e8eb21e9a5bbba979b49d9a97acb3a803092cbc1133e20343c"}, - {file = "cffi-1.15.1-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0e2642fe3142e4cc4af0799748233ad6da94c62a8bec3a6648bf8ee68b1c7426"}, - {file = "cffi-1.15.1-cp37-cp37m-win32.whl", hash = "sha256:e229a521186c75c8ad9490854fd8bbdd9a0c9aa3a524326b55be83b54d4e0ad9"}, - {file = "cffi-1.15.1-cp37-cp37m-win_amd64.whl", hash = "sha256:a0b71b1b8fbf2b96e41c4d990244165e2c9be83d54962a9a1d118fd8657d2045"}, - {file = "cffi-1.15.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:320dab6e7cb2eacdf0e658569d2575c4dad258c0fcc794f46215e1e39f90f2c3"}, - {file = "cffi-1.15.1-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1e74c6b51a9ed6589199c787bf5f9875612ca4a8a0785fb2d4a84429badaf22a"}, - {file = "cffi-1.15.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a5c84c68147988265e60416b57fc83425a78058853509c1b0629c180094904a5"}, - {file = "cffi-1.15.1-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3b926aa83d1edb5aa5b427b4053dc420ec295a08e40911296b9eb1b6170f6cca"}, - {file = "cffi-1.15.1-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:87c450779d0914f2861b8526e035c5e6da0a3199d8f1add1a665e1cbc6fc6d02"}, - {file = "cffi-1.15.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4f2c9f67e9821cad2e5f480bc8d83b8742896f1242dba247911072d4fa94c192"}, - {file = "cffi-1.15.1-cp38-cp38-win32.whl", hash = "sha256:8b7ee99e510d7b66cdb6c593f21c043c248537a32e0bedf02e01e9553a172314"}, - {file = "cffi-1.15.1-cp38-cp38-win_amd64.whl", hash = "sha256:00a9ed42e88df81ffae7a8ab6d9356b371399b91dbdf0c3cb1e84c03a13aceb5"}, - {file = "cffi-1.15.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:54a2db7b78338edd780e7ef7f9f6c442500fb0d41a5a4ea24fff1c929d5af585"}, - {file = "cffi-1.15.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:fcd131dd944808b5bdb38e6f5b53013c5aa4f334c5cad0c72742f6eba4b73db0"}, - {file = "cffi-1.15.1-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7473e861101c9e72452f9bf8acb984947aa1661a7704553a9f6e4baa5ba64415"}, - {file = "cffi-1.15.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6c9a799e985904922a4d207a94eae35c78ebae90e128f0c4e521ce339396be9d"}, - {file = "cffi-1.15.1-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3bcde07039e586f91b45c88f8583ea7cf7a0770df3a1649627bf598332cb6984"}, - {file = "cffi-1.15.1-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:33ab79603146aace82c2427da5ca6e58f2b3f2fb5da893ceac0c42218a40be35"}, - {file = "cffi-1.15.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5d598b938678ebf3c67377cdd45e09d431369c3b1a5b331058c338e201f12b27"}, - {file = "cffi-1.15.1-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:db0fbb9c62743ce59a9ff687eb5f4afbe77e5e8403d6697f7446e5f609976f76"}, - {file = "cffi-1.15.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:98d85c6a2bef81588d9227dde12db8a7f47f639f4a17c9ae08e773aa9c697bf3"}, - {file = "cffi-1.15.1-cp39-cp39-win32.whl", hash = "sha256:40f4774f5a9d4f5e344f31a32b5096977b5d48560c5592e2f3d2c4374bd543ee"}, - {file = "cffi-1.15.1-cp39-cp39-win_amd64.whl", hash = "sha256:70df4e3b545a17496c9b3f41f5115e69a4f2e77e94e1d2a8e1070bc0c38c8a3c"}, - {file = "cffi-1.15.1.tar.gz", hash = "sha256:d400bfb9a37b1351253cb402671cea7e89bdecc294e8016a707f6d1d8ac934f9"}, -] - -[package.dependencies] -pycparser = "*" - -[[package]] -name = "cfgv" -version = "3.3.1" -description = "Validate configuration and produce human readable error messages." -category = "dev" -optional = false -python-versions = ">=3.6.1" -files = [ - {file = "cfgv-3.3.1-py2.py3-none-any.whl", hash = "sha256:c6a0883f3917a037485059700b9e75da2464e6c27051014ad85ba6aaa5884426"}, - {file = "cfgv-3.3.1.tar.gz", hash = "sha256:f5a830efb9ce7a445376bb66ec94c638a9787422f96264c98edc6bdeed8ab736"}, -] - -[[package]] -name = "charset-normalizer" -version = "3.1.0" -description = "The Real First Universal Charset Detector. Open, modern and actively maintained alternative to Chardet." -category = "dev" -optional = false -python-versions = ">=3.7.0" -files = [ - {file = "charset-normalizer-3.1.0.tar.gz", hash = "sha256:34e0a2f9c370eb95597aae63bf85eb5e96826d81e3dcf88b8886012906f509b5"}, - {file = "charset_normalizer-3.1.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:e0ac8959c929593fee38da1c2b64ee9778733cdf03c482c9ff1d508b6b593b2b"}, - {file = "charset_normalizer-3.1.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:d7fc3fca01da18fbabe4625d64bb612b533533ed10045a2ac3dd194bfa656b60"}, - {file = "charset_normalizer-3.1.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:04eefcee095f58eaabe6dc3cc2262f3bcd776d2c67005880894f447b3f2cb9c1"}, - {file = "charset_normalizer-3.1.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:20064ead0717cf9a73a6d1e779b23d149b53daf971169289ed2ed43a71e8d3b0"}, - {file = "charset_normalizer-3.1.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1435ae15108b1cb6fffbcea2af3d468683b7afed0169ad718451f8db5d1aff6f"}, - {file = "charset_normalizer-3.1.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c84132a54c750fda57729d1e2599bb598f5fa0344085dbde5003ba429a4798c0"}, - {file = "charset_normalizer-3.1.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:75f2568b4189dda1c567339b48cba4ac7384accb9c2a7ed655cd86b04055c795"}, - {file = "charset_normalizer-3.1.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:11d3bcb7be35e7b1bba2c23beedac81ee893ac9871d0ba79effc7fc01167db6c"}, - {file = "charset_normalizer-3.1.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:891cf9b48776b5c61c700b55a598621fdb7b1e301a550365571e9624f270c203"}, - {file = "charset_normalizer-3.1.0-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:5f008525e02908b20e04707a4f704cd286d94718f48bb33edddc7d7b584dddc1"}, - {file = "charset_normalizer-3.1.0-cp310-cp310-musllinux_1_1_ppc64le.whl", hash = "sha256:b06f0d3bf045158d2fb8837c5785fe9ff9b8c93358be64461a1089f5da983137"}, - {file = "charset_normalizer-3.1.0-cp310-cp310-musllinux_1_1_s390x.whl", hash = "sha256:49919f8400b5e49e961f320c735388ee686a62327e773fa5b3ce6721f7e785ce"}, - {file = "charset_normalizer-3.1.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:22908891a380d50738e1f978667536f6c6b526a2064156203d418f4856d6e86a"}, - {file = "charset_normalizer-3.1.0-cp310-cp310-win32.whl", hash = "sha256:12d1a39aa6b8c6f6248bb54550efcc1c38ce0d8096a146638fd4738e42284448"}, - {file = "charset_normalizer-3.1.0-cp310-cp310-win_amd64.whl", hash = "sha256:65ed923f84a6844de5fd29726b888e58c62820e0769b76565480e1fdc3d062f8"}, - {file = "charset_normalizer-3.1.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:9a3267620866c9d17b959a84dd0bd2d45719b817245e49371ead79ed4f710d19"}, - {file = "charset_normalizer-3.1.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:6734e606355834f13445b6adc38b53c0fd45f1a56a9ba06c2058f86893ae8017"}, - {file = "charset_normalizer-3.1.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:f8303414c7b03f794347ad062c0516cee0e15f7a612abd0ce1e25caf6ceb47df"}, - {file = "charset_normalizer-3.1.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:aaf53a6cebad0eae578f062c7d462155eada9c172bd8c4d250b8c1d8eb7f916a"}, - {file = "charset_normalizer-3.1.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3dc5b6a8ecfdc5748a7e429782598e4f17ef378e3e272eeb1340ea57c9109f41"}, - {file = "charset_normalizer-3.1.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e1b25e3ad6c909f398df8921780d6a3d120d8c09466720226fc621605b6f92b1"}, - {file = "charset_normalizer-3.1.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0ca564606d2caafb0abe6d1b5311c2649e8071eb241b2d64e75a0d0065107e62"}, - {file = "charset_normalizer-3.1.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b82fab78e0b1329e183a65260581de4375f619167478dddab510c6c6fb04d9b6"}, - {file = "charset_normalizer-3.1.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:bd7163182133c0c7701b25e604cf1611c0d87712e56e88e7ee5d72deab3e76b5"}, - {file = "charset_normalizer-3.1.0-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:11d117e6c63e8f495412d37e7dc2e2fff09c34b2d09dbe2bee3c6229577818be"}, - {file = "charset_normalizer-3.1.0-cp311-cp311-musllinux_1_1_ppc64le.whl", hash = "sha256:cf6511efa4801b9b38dc5546d7547d5b5c6ef4b081c60b23e4d941d0eba9cbeb"}, - {file = "charset_normalizer-3.1.0-cp311-cp311-musllinux_1_1_s390x.whl", hash = "sha256:abc1185d79f47c0a7aaf7e2412a0eb2c03b724581139193d2d82b3ad8cbb00ac"}, - {file = "charset_normalizer-3.1.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:cb7b2ab0188829593b9de646545175547a70d9a6e2b63bf2cd87a0a391599324"}, - {file = "charset_normalizer-3.1.0-cp311-cp311-win32.whl", hash = "sha256:c36bcbc0d5174a80d6cccf43a0ecaca44e81d25be4b7f90f0ed7bcfbb5a00909"}, - {file = "charset_normalizer-3.1.0-cp311-cp311-win_amd64.whl", hash = "sha256:cca4def576f47a09a943666b8f829606bcb17e2bc2d5911a46c8f8da45f56755"}, - {file = "charset_normalizer-3.1.0-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:0c95f12b74681e9ae127728f7e5409cbbef9cd914d5896ef238cc779b8152373"}, - {file = "charset_normalizer-3.1.0-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fca62a8301b605b954ad2e9c3666f9d97f63872aa4efcae5492baca2056b74ab"}, - {file = "charset_normalizer-3.1.0-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ac0aa6cd53ab9a31d397f8303f92c42f534693528fafbdb997c82bae6e477ad9"}, - {file = "charset_normalizer-3.1.0-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c3af8e0f07399d3176b179f2e2634c3ce9c1301379a6b8c9c9aeecd481da494f"}, - {file = "charset_normalizer-3.1.0-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3a5fc78f9e3f501a1614a98f7c54d3969f3ad9bba8ba3d9b438c3bc5d047dd28"}, - {file = "charset_normalizer-3.1.0-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:628c985afb2c7d27a4800bfb609e03985aaecb42f955049957814e0491d4006d"}, - {file = "charset_normalizer-3.1.0-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:74db0052d985cf37fa111828d0dd230776ac99c740e1a758ad99094be4f1803d"}, - {file = "charset_normalizer-3.1.0-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:1e8fcdd8f672a1c4fc8d0bd3a2b576b152d2a349782d1eb0f6b8e52e9954731d"}, - {file = "charset_normalizer-3.1.0-cp37-cp37m-musllinux_1_1_ppc64le.whl", hash = "sha256:04afa6387e2b282cf78ff3dbce20f0cc071c12dc8f685bd40960cc68644cfea6"}, - {file = "charset_normalizer-3.1.0-cp37-cp37m-musllinux_1_1_s390x.whl", hash = "sha256:dd5653e67b149503c68c4018bf07e42eeed6b4e956b24c00ccdf93ac79cdff84"}, - {file = "charset_normalizer-3.1.0-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:d2686f91611f9e17f4548dbf050e75b079bbc2a82be565832bc8ea9047b61c8c"}, - {file = "charset_normalizer-3.1.0-cp37-cp37m-win32.whl", hash = "sha256:4155b51ae05ed47199dc5b2a4e62abccb274cee6b01da5b895099b61b1982974"}, - {file = "charset_normalizer-3.1.0-cp37-cp37m-win_amd64.whl", hash = "sha256:322102cdf1ab682ecc7d9b1c5eed4ec59657a65e1c146a0da342b78f4112db23"}, - {file = "charset_normalizer-3.1.0-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:e633940f28c1e913615fd624fcdd72fdba807bf53ea6925d6a588e84e1151531"}, - {file = "charset_normalizer-3.1.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:3a06f32c9634a8705f4ca9946d667609f52cf130d5548881401f1eb2c39b1e2c"}, - {file = "charset_normalizer-3.1.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:7381c66e0561c5757ffe616af869b916c8b4e42b367ab29fedc98481d1e74e14"}, - {file = "charset_normalizer-3.1.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3573d376454d956553c356df45bb824262c397c6e26ce43e8203c4c540ee0acb"}, - {file = "charset_normalizer-3.1.0-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e89df2958e5159b811af9ff0f92614dabf4ff617c03a4c1c6ff53bf1c399e0e1"}, - {file = "charset_normalizer-3.1.0-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:78cacd03e79d009d95635e7d6ff12c21eb89b894c354bd2b2ed0b4763373693b"}, - {file = "charset_normalizer-3.1.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:de5695a6f1d8340b12a5d6d4484290ee74d61e467c39ff03b39e30df62cf83a0"}, - {file = "charset_normalizer-3.1.0-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1c60b9c202d00052183c9be85e5eaf18a4ada0a47d188a83c8f5c5b23252f649"}, - {file = "charset_normalizer-3.1.0-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:f645caaf0008bacf349875a974220f1f1da349c5dbe7c4ec93048cdc785a3326"}, - {file = "charset_normalizer-3.1.0-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:ea9f9c6034ea2d93d9147818f17c2a0860d41b71c38b9ce4d55f21b6f9165a11"}, - {file = "charset_normalizer-3.1.0-cp38-cp38-musllinux_1_1_ppc64le.whl", hash = "sha256:80d1543d58bd3d6c271b66abf454d437a438dff01c3e62fdbcd68f2a11310d4b"}, - {file = "charset_normalizer-3.1.0-cp38-cp38-musllinux_1_1_s390x.whl", hash = "sha256:73dc03a6a7e30b7edc5b01b601e53e7fc924b04e1835e8e407c12c037e81adbd"}, - {file = "charset_normalizer-3.1.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:6f5c2e7bc8a4bf7c426599765b1bd33217ec84023033672c1e9a8b35eaeaaaf8"}, - {file = "charset_normalizer-3.1.0-cp38-cp38-win32.whl", hash = "sha256:12a2b561af122e3d94cdb97fe6fb2bb2b82cef0cdca131646fdb940a1eda04f0"}, - {file = "charset_normalizer-3.1.0-cp38-cp38-win_amd64.whl", hash = "sha256:3160a0fd9754aab7d47f95a6b63ab355388d890163eb03b2d2b87ab0a30cfa59"}, - {file = "charset_normalizer-3.1.0-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:38e812a197bf8e71a59fe55b757a84c1f946d0ac114acafaafaf21667a7e169e"}, - {file = "charset_normalizer-3.1.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:6baf0baf0d5d265fa7944feb9f7451cc316bfe30e8df1a61b1bb08577c554f31"}, - {file = "charset_normalizer-3.1.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:8f25e17ab3039b05f762b0a55ae0b3632b2e073d9c8fc88e89aca31a6198e88f"}, - {file = "charset_normalizer-3.1.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3747443b6a904001473370d7810aa19c3a180ccd52a7157aacc264a5ac79265e"}, - {file = "charset_normalizer-3.1.0-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b116502087ce8a6b7a5f1814568ccbd0e9f6cfd99948aa59b0e241dc57cf739f"}, - {file = "charset_normalizer-3.1.0-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d16fd5252f883eb074ca55cb622bc0bee49b979ae4e8639fff6ca3ff44f9f854"}, - {file = "charset_normalizer-3.1.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:21fa558996782fc226b529fdd2ed7866c2c6ec91cee82735c98a197fae39f706"}, - {file = "charset_normalizer-3.1.0-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6f6c7a8a57e9405cad7485f4c9d3172ae486cfef1344b5ddd8e5239582d7355e"}, - {file = "charset_normalizer-3.1.0-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:ac3775e3311661d4adace3697a52ac0bab17edd166087d493b52d4f4f553f9f0"}, - {file = "charset_normalizer-3.1.0-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:10c93628d7497c81686e8e5e557aafa78f230cd9e77dd0c40032ef90c18f2230"}, - {file = "charset_normalizer-3.1.0-cp39-cp39-musllinux_1_1_ppc64le.whl", hash = "sha256:6f4f4668e1831850ebcc2fd0b1cd11721947b6dc7c00bf1c6bd3c929ae14f2c7"}, - {file = "charset_normalizer-3.1.0-cp39-cp39-musllinux_1_1_s390x.whl", hash = "sha256:0be65ccf618c1e7ac9b849c315cc2e8a8751d9cfdaa43027d4f6624bd587ab7e"}, - {file = "charset_normalizer-3.1.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:53d0a3fa5f8af98a1e261de6a3943ca631c526635eb5817a87a59d9a57ebf48f"}, - {file = "charset_normalizer-3.1.0-cp39-cp39-win32.whl", hash = "sha256:a04f86f41a8916fe45ac5024ec477f41f886b3c435da2d4e3d2709b22ab02af1"}, - {file = "charset_normalizer-3.1.0-cp39-cp39-win_amd64.whl", hash = "sha256:830d2948a5ec37c386d3170c483063798d7879037492540f10a475e3fd6f244b"}, - {file = "charset_normalizer-3.1.0-py3-none-any.whl", hash = "sha256:3d9098b479e78c85080c98e1e35ff40b4a31d8953102bb0fd7d1b6f8a2111a3d"}, -] - -[[package]] -name = "click" -version = "8.1.3" -description = "Composable command line interface toolkit" -category = "dev" -optional = false -python-versions = ">=3.7" -files = [ - {file = "click-8.1.3-py3-none-any.whl", hash = "sha256:bb4d8133cb15a609f44e8213d9b391b0809795062913b383c62be0ee95b1db48"}, - {file = "click-8.1.3.tar.gz", hash = "sha256:7682dc8afb30297001674575ea00d1814d808d6a36af415a82bd481d37ba7b8e"}, -] - -[package.dependencies] -colorama = {version = "*", markers = "platform_system == \"Windows\""} - -[[package]] -name = "cmake" -version = "3.26.1" -description = "CMake is an open-source, cross-platform family of tools designed to build, test and package software" -category = "main" -optional = false -python-versions = "*" -files = [ - {file = "cmake-3.26.1-py2.py3-none-macosx_10_10_universal2.macosx_10_10_x86_64.macosx_11_0_arm64.macosx_11_0_universal2.whl", hash = "sha256:d8a7e0cc8677677a732aff3e3fd0ad64eeff43cac772614b03c436912247d0d8"}, - {file = "cmake-3.26.1-py2.py3-none-manylinux2010_i686.manylinux_2_12_i686.whl", hash = "sha256:f2f721f5aebe304c281ee4b1d2dfbf7f4a52fca003834b2b4a3ba838aeded63c"}, - {file = "cmake-3.26.1-py2.py3-none-manylinux2010_x86_64.manylinux_2_12_x86_64.whl", hash = "sha256:63a012b72836702eadfe4fba9642aeb17337f26861f4768e837053f40e98cb46"}, - {file = "cmake-3.26.1-py2.py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:2b72be88b7bfaa6ae59566cbb9d6a5553f19b2a8d14efa6ac0cf019a29860a1b"}, - {file = "cmake-3.26.1-py2.py3-none-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:1278354f7210e22458aa9137d46a56da1f115a7b76ad2733f0bf6041fb40f1dc"}, - {file = "cmake-3.26.1-py2.py3-none-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:de96a5522917fba0ab0da2d01d9dd9462fa80f365218bf27162d539c2335758f"}, - {file = "cmake-3.26.1-py2.py3-none-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:449928ad7dfcd41e4dcff64c7d44f86557883c70577666a19e79e22d783bbbd0"}, - {file = "cmake-3.26.1-py2.py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:19fa3e457afecf2803265f71652ef17c3f1d317173c330ba46767a0853d38fa0"}, - {file = "cmake-3.26.1-py2.py3-none-musllinux_1_1_aarch64.whl", hash = "sha256:43360650d60d177d979e4ad0a5f31afa286e6d88f5350f7a38c29d94514900eb"}, - {file = "cmake-3.26.1-py2.py3-none-musllinux_1_1_i686.whl", hash = "sha256:16aac10363bc926da5109a59ef8fe46ddcd7e3d421de61f871b35524eef2f1ae"}, - {file = "cmake-3.26.1-py2.py3-none-musllinux_1_1_ppc64le.whl", hash = "sha256:e460ba5070be4dcac9613cb526a46db4e5fa19d8b909a8d8d5244c6cc3c777e1"}, - {file = "cmake-3.26.1-py2.py3-none-musllinux_1_1_s390x.whl", hash = "sha256:fd2ecc0899f7939a014bd906df85e8681bd63ce457de3ab0b5d9e369fa3bdf79"}, - {file = "cmake-3.26.1-py2.py3-none-musllinux_1_1_x86_64.whl", hash = "sha256:22781a23e274ba9bf380b970649654851c1b4b9d83b65fec12ee2e2e03b6ffc4"}, - {file = "cmake-3.26.1-py2.py3-none-win32.whl", hash = "sha256:7b4e81de30ac1fb2f1eb5287063e140b53f376fd9ed7e2060c1c7b5917bd5f83"}, - {file = "cmake-3.26.1-py2.py3-none-win_amd64.whl", hash = "sha256:90845b6c87a25be07e9220f67dd7f6c891c6ec14d764d37335218d97f9ea4520"}, - {file = "cmake-3.26.1-py2.py3-none-win_arm64.whl", hash = "sha256:43bd96327e2631183bb4829ba20cb810e20b4b0c68f852fcd7082fbb5359d57c"}, - {file = "cmake-3.26.1.tar.gz", hash = "sha256:4e0eb3c03dcf2d459f78d96cc85f7482476aeb1ae5ada65150b1db35c0f70cc7"}, -] - -[package.extras] -test = ["codecov (>=2.0.5)", "coverage (>=4.2)", "flake8 (>=3.0.4)", "path.py (>=11.5.0)", "pytest (>=3.0.3)", "pytest-cov (>=2.4.0)", "pytest-runner (>=2.9)", "pytest-virtualenv (>=1.7.0)", "scikit-build (>=0.10.0)", "setuptools (>=28.0.0)", "virtualenv (>=15.0.3)", "wheel"] - -[[package]] -name = "colorama" -version = "0.4.6" -description = "Cross-platform colored terminal text." -category = "main" -optional = false -python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,!=3.6.*,>=2.7" -files = [ - {file = "colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6"}, - {file = "colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44"}, -] - -[[package]] -name = "comm" -version = "0.1.3" -description = "Jupyter Python Comm implementation, for usage in ipykernel, xeus-python etc." -category = "dev" -optional = false -python-versions = ">=3.6" -files = [ - {file = "comm-0.1.3-py3-none-any.whl", hash = "sha256:16613c6211e20223f215fc6d3b266a247b6e2641bf4e0a3ad34cb1aff2aa3f37"}, - {file = "comm-0.1.3.tar.gz", hash = "sha256:a61efa9daffcfbe66fd643ba966f846a624e4e6d6767eda9cf6e993aadaab93e"}, -] - -[package.dependencies] -traitlets = ">=5.3" - -[package.extras] -lint = ["black (>=22.6.0)", "mdformat (>0.7)", "mdformat-gfm (>=0.3.5)", "ruff (>=0.0.156)"] -test = ["pytest"] -typing = ["mypy (>=0.990)"] - -[[package]] -name = "contourpy" -version = "1.0.7" -description = "Python library for calculating contours of 2D quadrilateral grids" -category = "main" -optional = false -python-versions = ">=3.8" -files = [ - {file = "contourpy-1.0.7-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:95c3acddf921944f241b6773b767f1cbce71d03307270e2d769fd584d5d1092d"}, - {file = "contourpy-1.0.7-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:fc1464c97579da9f3ab16763c32e5c5d5bb5fa1ec7ce509a4ca6108b61b84fab"}, - {file = "contourpy-1.0.7-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:8acf74b5d383414401926c1598ed77825cd530ac7b463ebc2e4f46638f56cce6"}, - {file = "contourpy-1.0.7-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1c71fdd8f1c0f84ffd58fca37d00ca4ebaa9e502fb49825484da075ac0b0b803"}, - {file = "contourpy-1.0.7-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f99e9486bf1bb979d95d5cffed40689cb595abb2b841f2991fc894b3452290e8"}, - {file = "contourpy-1.0.7-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:87f4d8941a9564cda3f7fa6a6cd9b32ec575830780677932abdec7bcb61717b0"}, - {file = "contourpy-1.0.7-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:9e20e5a1908e18aaa60d9077a6d8753090e3f85ca25da6e25d30dc0a9e84c2c6"}, - {file = "contourpy-1.0.7-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:a877ada905f7d69b2a31796c4b66e31a8068b37aa9b78832d41c82fc3e056ddd"}, - {file = "contourpy-1.0.7-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:6381fa66866b0ea35e15d197fc06ac3840a9b2643a6475c8fff267db8b9f1e69"}, - {file = "contourpy-1.0.7-cp310-cp310-win32.whl", hash = "sha256:3c184ad2433635f216645fdf0493011a4667e8d46b34082f5a3de702b6ec42e3"}, - {file = "contourpy-1.0.7-cp310-cp310-win_amd64.whl", hash = "sha256:3caea6365b13119626ee996711ab63e0c9d7496f65641f4459c60a009a1f3e80"}, - {file = "contourpy-1.0.7-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:ed33433fc3820263a6368e532f19ddb4c5990855e4886088ad84fd7c4e561c71"}, - {file = "contourpy-1.0.7-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:38e2e577f0f092b8e6774459317c05a69935a1755ecfb621c0a98f0e3c09c9a5"}, - {file = "contourpy-1.0.7-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:ae90d5a8590e5310c32a7630b4b8618cef7563cebf649011da80874d0aa8f414"}, - {file = "contourpy-1.0.7-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:130230b7e49825c98edf0b428b7aa1125503d91732735ef897786fe5452b1ec2"}, - {file = "contourpy-1.0.7-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:58569c491e7f7e874f11519ef46737cea1d6eda1b514e4eb5ac7dab6aa864d02"}, - {file = "contourpy-1.0.7-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:54d43960d809c4c12508a60b66cb936e7ed57d51fb5e30b513934a4a23874fae"}, - {file = "contourpy-1.0.7-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:152fd8f730c31fd67fe0ffebe1df38ab6a669403da93df218801a893645c6ccc"}, - {file = "contourpy-1.0.7-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:9056c5310eb1daa33fc234ef39ebfb8c8e2533f088bbf0bc7350f70a29bde1ac"}, - {file = "contourpy-1.0.7-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:a9d7587d2fdc820cc9177139b56795c39fb8560f540bba9ceea215f1f66e1566"}, - {file = "contourpy-1.0.7-cp311-cp311-win32.whl", hash = "sha256:4ee3ee247f795a69e53cd91d927146fb16c4e803c7ac86c84104940c7d2cabf0"}, - {file = "contourpy-1.0.7-cp311-cp311-win_amd64.whl", hash = "sha256:5caeacc68642e5f19d707471890f037a13007feba8427eb7f2a60811a1fc1350"}, - {file = "contourpy-1.0.7-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:fd7dc0e6812b799a34f6d12fcb1000539098c249c8da54f3566c6a6461d0dbad"}, - {file = "contourpy-1.0.7-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:0f9d350b639db6c2c233d92c7f213d94d2e444d8e8fc5ca44c9706cf72193772"}, - {file = "contourpy-1.0.7-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:e96a08b62bb8de960d3a6afbc5ed8421bf1a2d9c85cc4ea73f4bc81b4910500f"}, - {file = "contourpy-1.0.7-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:031154ed61f7328ad7f97662e48660a150ef84ee1bc8876b6472af88bf5a9b98"}, - {file = "contourpy-1.0.7-cp38-cp38-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:2e9ebb4425fc1b658e13bace354c48a933b842d53c458f02c86f371cecbedecc"}, - {file = "contourpy-1.0.7-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:efb8f6d08ca7998cf59eaf50c9d60717f29a1a0a09caa46460d33b2924839dbd"}, - {file = "contourpy-1.0.7-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:6c180d89a28787e4b73b07e9b0e2dac7741261dbdca95f2b489c4f8f887dd810"}, - {file = "contourpy-1.0.7-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:b8d587cc39057d0afd4166083d289bdeff221ac6d3ee5046aef2d480dc4b503c"}, - {file = "contourpy-1.0.7-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:769eef00437edf115e24d87f8926955f00f7704bede656ce605097584f9966dc"}, - {file = "contourpy-1.0.7-cp38-cp38-win32.whl", hash = "sha256:62398c80ef57589bdbe1eb8537127321c1abcfdf8c5f14f479dbbe27d0322e66"}, - {file = "contourpy-1.0.7-cp38-cp38-win_amd64.whl", hash = "sha256:57119b0116e3f408acbdccf9eb6ef19d7fe7baf0d1e9aaa5381489bc1aa56556"}, - {file = "contourpy-1.0.7-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:30676ca45084ee61e9c3da589042c24a57592e375d4b138bd84d8709893a1ba4"}, - {file = "contourpy-1.0.7-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:3e927b3868bd1e12acee7cc8f3747d815b4ab3e445a28d2e5373a7f4a6e76ba1"}, - {file = "contourpy-1.0.7-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:366a0cf0fc079af5204801786ad7a1c007714ee3909e364dbac1729f5b0849e5"}, - {file = "contourpy-1.0.7-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:89ba9bb365446a22411f0673abf6ee1fea3b2cf47b37533b970904880ceb72f3"}, - {file = "contourpy-1.0.7-cp39-cp39-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:71b0bf0c30d432278793d2141362ac853859e87de0a7dee24a1cea35231f0d50"}, - {file = "contourpy-1.0.7-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e7281244c99fd7c6f27c1c6bfafba878517b0b62925a09b586d88ce750a016d2"}, - {file = "contourpy-1.0.7-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:b6d0f9e1d39dbfb3977f9dd79f156c86eb03e57a7face96f199e02b18e58d32a"}, - {file = "contourpy-1.0.7-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:7f6979d20ee5693a1057ab53e043adffa1e7418d734c1532e2d9e915b08d8ec2"}, - {file = "contourpy-1.0.7-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:5dd34c1ae752515318224cba7fc62b53130c45ac6a1040c8b7c1a223c46e8967"}, - {file = "contourpy-1.0.7-cp39-cp39-win32.whl", hash = "sha256:c5210e5d5117e9aec8c47d9156d1d3835570dd909a899171b9535cb4a3f32693"}, - {file = "contourpy-1.0.7-cp39-cp39-win_amd64.whl", hash = "sha256:60835badb5ed5f4e194a6f21c09283dd6e007664a86101431bf870d9e86266c4"}, - {file = "contourpy-1.0.7-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:ce41676b3d0dd16dbcfabcc1dc46090aaf4688fd6e819ef343dbda5a57ef0161"}, - {file = "contourpy-1.0.7-pp38-pypy38_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5a011cf354107b47c58ea932d13b04d93c6d1d69b8b6dce885e642531f847566"}, - {file = "contourpy-1.0.7-pp38-pypy38_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:31a55dccc8426e71817e3fe09b37d6d48ae40aae4ecbc8c7ad59d6893569c436"}, - {file = "contourpy-1.0.7-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:69f8ff4db108815addd900a74df665e135dbbd6547a8a69333a68e1f6e368ac2"}, - {file = "contourpy-1.0.7-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:efe99298ba37e37787f6a2ea868265465410822f7bea163edcc1bd3903354ea9"}, - {file = "contourpy-1.0.7-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:a1e97b86f73715e8670ef45292d7cc033548266f07d54e2183ecb3c87598888f"}, - {file = "contourpy-1.0.7-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cc331c13902d0f50845099434cd936d49d7a2ca76cb654b39691974cb1e4812d"}, - {file = "contourpy-1.0.7-pp39-pypy39_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:24847601071f740837aefb730e01bd169fbcaa610209779a78db7ebb6e6a7051"}, - {file = "contourpy-1.0.7-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:abf298af1e7ad44eeb93501e40eb5a67abbf93b5d90e468d01fc0c4451971afa"}, - {file = "contourpy-1.0.7-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:64757f6460fc55d7e16ed4f1de193f362104285c667c112b50a804d482777edd"}, - {file = "contourpy-1.0.7.tar.gz", hash = "sha256:d8165a088d31798b59e91117d1f5fc3df8168d8b48c4acc10fc0df0d0bdbcc5e"}, -] - -[package.dependencies] -numpy = ">=1.16" - -[package.extras] -bokeh = ["bokeh", "chromedriver", "selenium"] -docs = ["furo", "sphinx-copybutton"] -mypy = ["contourpy[bokeh]", "docutils-stubs", "mypy (==0.991)", "types-Pillow"] -test = ["Pillow", "matplotlib", "pytest"] -test-no-images = ["pytest"] - -[[package]] -name = "cycler" -version = "0.11.0" -description = "Composable style cycles" -category = "main" -optional = false -python-versions = ">=3.6" -files = [ - {file = "cycler-0.11.0-py3-none-any.whl", hash = "sha256:3a27e95f763a428a739d2add979fa7494c912a32c17c4c38c4d5f082cad165a3"}, - {file = "cycler-0.11.0.tar.gz", hash = "sha256:9c87405839a19696e837b3b818fed3f5f69f16f1eec1a1ad77e043dcea9c772f"}, -] - -[[package]] -name = "debugpy" -version = "1.6.6" -description = "An implementation of the Debug Adapter Protocol for Python" -category = "dev" -optional = false -python-versions = ">=3.7" -files = [ - {file = "debugpy-1.6.6-cp310-cp310-macosx_11_0_x86_64.whl", hash = "sha256:0ea1011e94416e90fb3598cc3ef5e08b0a4dd6ce6b9b33ccd436c1dffc8cd664"}, - {file = "debugpy-1.6.6-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dff595686178b0e75580c24d316aa45a8f4d56e2418063865c114eef651a982e"}, - {file = "debugpy-1.6.6-cp310-cp310-win32.whl", hash = "sha256:87755e173fcf2ec45f584bb9d61aa7686bb665d861b81faa366d59808bbd3494"}, - {file = "debugpy-1.6.6-cp310-cp310-win_amd64.whl", hash = "sha256:72687b62a54d9d9e3fb85e7a37ea67f0e803aaa31be700e61d2f3742a5683917"}, - {file = "debugpy-1.6.6-cp37-cp37m-macosx_10_15_x86_64.whl", hash = "sha256:78739f77c58048ec006e2b3eb2e0cd5a06d5f48c915e2fc7911a337354508110"}, - {file = "debugpy-1.6.6-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:23c29e40e39ad7d869d408ded414f6d46d82f8a93b5857ac3ac1e915893139ca"}, - {file = "debugpy-1.6.6-cp37-cp37m-win32.whl", hash = "sha256:7aa7e103610e5867d19a7d069e02e72eb2b3045b124d051cfd1538f1d8832d1b"}, - {file = "debugpy-1.6.6-cp37-cp37m-win_amd64.whl", hash = "sha256:f6383c29e796203a0bba74a250615ad262c4279d398e89d895a69d3069498305"}, - {file = "debugpy-1.6.6-cp38-cp38-macosx_10_15_x86_64.whl", hash = "sha256:23363e6d2a04d726bbc1400bd4e9898d54419b36b2cdf7020e3e215e1dcd0f8e"}, - {file = "debugpy-1.6.6-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9b5d1b13d7c7bf5d7cf700e33c0b8ddb7baf030fcf502f76fc061ddd9405d16c"}, - {file = "debugpy-1.6.6-cp38-cp38-win32.whl", hash = "sha256:70ab53918fd907a3ade01909b3ed783287ede362c80c75f41e79596d5ccacd32"}, - {file = "debugpy-1.6.6-cp38-cp38-win_amd64.whl", hash = "sha256:c05349890804d846eca32ce0623ab66c06f8800db881af7a876dc073ac1c2225"}, - {file = "debugpy-1.6.6-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a771739902b1ae22a120dbbb6bd91b2cae6696c0e318b5007c5348519a4211c6"}, - {file = "debugpy-1.6.6-cp39-cp39-win32.whl", hash = "sha256:549ae0cb2d34fc09d1675f9b01942499751d174381b6082279cf19cdb3c47cbe"}, - {file = "debugpy-1.6.6-cp39-cp39-win_amd64.whl", hash = "sha256:de4a045fbf388e120bb6ec66501458d3134f4729faed26ff95de52a754abddb1"}, - {file = "debugpy-1.6.6-py2.py3-none-any.whl", hash = "sha256:be596b44448aac14eb3614248c91586e2bc1728e020e82ef3197189aae556115"}, - {file = "debugpy-1.6.6.zip", hash = "sha256:b9c2130e1c632540fbf9c2c88341493797ddf58016e7cba02e311de9b0a96b67"}, -] - -[[package]] -name = "decorator" -version = "5.1.1" -description = "Decorators for Humans" -category = "dev" -optional = false -python-versions = ">=3.5" -files = [ - {file = "decorator-5.1.1-py3-none-any.whl", hash = "sha256:b8c3f85900b9dc423225913c5aace94729fe1fa9763b38939a95226f02d37186"}, - {file = "decorator-5.1.1.tar.gz", hash = "sha256:637996211036b6385ef91435e4fae22989472f9d571faba8927ba8253acbc330"}, -] - -[[package]] -name = "defusedxml" -version = "0.7.1" -description = "XML bomb protection for Python stdlib modules" -category = "dev" -optional = false -python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*" -files = [ - {file = "defusedxml-0.7.1-py2.py3-none-any.whl", hash = "sha256:a352e7e428770286cc899e2542b6cdaedb2b4953ff269a210103ec58f6198a61"}, - {file = "defusedxml-0.7.1.tar.gz", hash = "sha256:1bb3032db185915b62d7c6209c5a8792be6a32ab2fedacc84e01b52c51aa3e69"}, -] - -[[package]] -name = "distlib" -version = "0.3.6" -description = "Distribution utilities" -category = "dev" -optional = false -python-versions = "*" -files = [ - {file = "distlib-0.3.6-py2.py3-none-any.whl", hash = "sha256:f35c4b692542ca110de7ef0bea44d73981caeb34ca0b9b6b2e6d7790dda8f80e"}, - {file = "distlib-0.3.6.tar.gz", hash = "sha256:14bad2d9b04d3a36127ac97f30b12a19268f211063d8f8ee4f47108896e11b46"}, -] - -[[package]] -name = "exceptiongroup" -version = "1.1.1" -description = "Backport of PEP 654 (exception groups)" -category = "dev" -optional = false -python-versions = ">=3.7" -files = [ - {file = "exceptiongroup-1.1.1-py3-none-any.whl", hash = "sha256:232c37c63e4f682982c8b6459f33a8981039e5fb8756b2074364e5055c498c9e"}, - {file = "exceptiongroup-1.1.1.tar.gz", hash = "sha256:d484c3090ba2889ae2928419117447a14daf3c1231d5e30d0aae34f354f01785"}, -] - -[package.extras] -test = ["pytest (>=6)"] - -[[package]] -name = "executing" -version = "1.2.0" -description = "Get the currently executing AST node of a frame, and other information" -category = "dev" -optional = false -python-versions = "*" -files = [ - {file = "executing-1.2.0-py2.py3-none-any.whl", hash = "sha256:0314a69e37426e3608aada02473b4161d4caf5a4b244d1d0c48072b8fee7bacc"}, - {file = "executing-1.2.0.tar.gz", hash = "sha256:19da64c18d2d851112f09c287f8d3dbbdf725ab0e569077efb6cdcbd3497c107"}, -] - -[package.extras] -tests = ["asttokens", "littleutils", "pytest", "rich"] - -[[package]] -name = "fastjsonschema" -version = "2.16.3" -description = "Fastest Python implementation of JSON schema" -category = "dev" -optional = false -python-versions = "*" -files = [ - {file = "fastjsonschema-2.16.3-py3-none-any.whl", hash = "sha256:04fbecc94300436f628517b05741b7ea009506ce8f946d40996567c669318490"}, - {file = "fastjsonschema-2.16.3.tar.gz", hash = "sha256:4a30d6315a68c253cfa8f963b9697246315aa3db89f98b97235e345dedfb0b8e"}, -] - -[package.extras] -devel = ["colorama", "json-spec", "jsonschema", "pylint", "pytest", "pytest-benchmark", "pytest-cache", "validictory"] - -[[package]] -name = "filelock" -version = "3.10.7" -description = "A platform independent file lock." -category = "main" -optional = false -python-versions = ">=3.7" -files = [ - {file = "filelock-3.10.7-py3-none-any.whl", hash = "sha256:bde48477b15fde2c7e5a0713cbe72721cb5a5ad32ee0b8f419907960b9d75536"}, - {file = "filelock-3.10.7.tar.gz", hash = "sha256:892be14aa8efc01673b5ed6589dbccb95f9a8596f0507e232626155495c18105"}, -] - -[package.extras] -docs = ["furo (>=2022.12.7)", "sphinx (>=6.1.3)", "sphinx-autodoc-typehints (>=1.22,!=1.23.4)"] -testing = ["covdefaults (>=2.3)", "coverage (>=7.2.2)", "diff-cover (>=7.5)", "pytest (>=7.2.2)", "pytest-cov (>=4)", "pytest-mock (>=3.10)", "pytest-timeout (>=2.1)"] - -[[package]] -name = "flake8" -version = "6.0.0" -description = "the modular source code checker: pep8 pyflakes and co" -category = "dev" -optional = false -python-versions = ">=3.8.1" -files = [ - {file = "flake8-6.0.0-py2.py3-none-any.whl", hash = "sha256:3833794e27ff64ea4e9cf5d410082a8b97ff1a06c16aa3d2027339cd0f1195c7"}, - {file = "flake8-6.0.0.tar.gz", hash = "sha256:c61007e76655af75e6785a931f452915b371dc48f56efd765247c8fe68f2b181"}, -] - -[package.dependencies] -mccabe = ">=0.7.0,<0.8.0" -pycodestyle = ">=2.10.0,<2.11.0" -pyflakes = ">=3.0.0,<3.1.0" - -[[package]] -name = "fonttools" -version = "4.39.3" -description = "Tools to manipulate font files" -category = "main" -optional = false -python-versions = ">=3.8" -files = [ - {file = "fonttools-4.39.3-py3-none-any.whl", hash = "sha256:64c0c05c337f826183637570ac5ab49ee220eec66cf50248e8df527edfa95aeb"}, - {file = "fonttools-4.39.3.zip", hash = "sha256:9234b9f57b74e31b192c3fc32ef1a40750a8fbc1cd9837a7b7bfc4ca4a5c51d7"}, -] - -[package.extras] -all = ["brotli (>=1.0.1)", "brotlicffi (>=0.8.0)", "fs (>=2.2.0,<3)", "lxml (>=4.0,<5)", "lz4 (>=1.7.4.2)", "matplotlib", "munkres", "scipy", "skia-pathops (>=0.5.0)", "sympy", "uharfbuzz (>=0.23.0)", "unicodedata2 (>=15.0.0)", "xattr", "zopfli (>=0.1.4)"] -graphite = ["lz4 (>=1.7.4.2)"] -interpolatable = ["munkres", "scipy"] -lxml = ["lxml (>=4.0,<5)"] -pathops = ["skia-pathops (>=0.5.0)"] -plot = ["matplotlib"] -repacker = ["uharfbuzz (>=0.23.0)"] -symfont = ["sympy"] -type1 = ["xattr"] -ufo = ["fs (>=2.2.0,<3)"] -unicode = ["unicodedata2 (>=15.0.0)"] -woff = ["brotli (>=1.0.1)", "brotlicffi (>=0.8.0)", "zopfli (>=0.1.4)"] - -[[package]] -name = "fqdn" -version = "1.5.1" -description = "Validates fully-qualified domain names against RFC 1123, so that they are acceptable to modern bowsers" -category = "dev" -optional = false -python-versions = ">=2.7, !=3.0, !=3.1, !=3.2, !=3.3, !=3.4, <4" -files = [ - {file = "fqdn-1.5.1-py3-none-any.whl", hash = "sha256:3a179af3761e4df6eb2e026ff9e1a3033d3587bf980a0b1b2e1e5d08d7358014"}, - {file = "fqdn-1.5.1.tar.gz", hash = "sha256:105ed3677e767fb5ca086a0c1f4bb66ebc3c100be518f0e0d755d9eae164d89f"}, -] - -[[package]] -name = "ghp-import" -version = "2.1.0" -description = "Copy your docs directly to the gh-pages branch." -category = "dev" -optional = false -python-versions = "*" -files = [ - {file = "ghp-import-2.1.0.tar.gz", hash = "sha256:9c535c4c61193c2df8871222567d7fd7e5014d835f97dc7b7439069e2413d343"}, - {file = "ghp_import-2.1.0-py3-none-any.whl", hash = "sha256:8337dd7b50877f163d4c0289bc1f1c7f127550241988d568c1db512c4324a619"}, -] - -[package.dependencies] -python-dateutil = ">=2.8.1" - -[package.extras] -dev = ["flake8", "markdown", "twine", "wheel"] - -[[package]] -name = "graphviz" -version = "0.20.1" -description = "Simple Python interface for Graphviz" -category = "main" -optional = false -python-versions = ">=3.7" -files = [ - {file = "graphviz-0.20.1-py3-none-any.whl", hash = "sha256:587c58a223b51611c0cf461132da386edd896a029524ca61a1462b880bf97977"}, - {file = "graphviz-0.20.1.zip", hash = "sha256:8c58f14adaa3b947daf26c19bc1e98c4e0702cdc31cf99153e6f06904d492bf8"}, -] - -[package.extras] -dev = ["flake8", "pep8-naming", "tox (>=3)", "twine", "wheel"] -docs = ["sphinx (>=5)", "sphinx-autodoc-typehints", "sphinx-rtd-theme"] -test = ["coverage", "mock (>=4)", "pytest (>=7)", "pytest-cov", "pytest-mock (>=3)"] - -[[package]] -name = "griffe" -version = "0.26.0" -description = "Signatures for entire Python programs. Extract the structure, the frame, the skeleton of your project, to generate API documentation or find breaking changes in your API." -category = "dev" -optional = false -python-versions = ">=3.7" -files = [ - {file = "griffe-0.26.0-py3-none-any.whl", hash = "sha256:38f3f6bbe834501cc199a07b7b7e0e2550aaf19a9d1ee27acf879027e47c9b9e"}, - {file = "griffe-0.26.0.tar.gz", hash = "sha256:08675ffe8c17139e7769e950dd21f8e98a2e76205cbbd2911d5dec26d2cbf1be"}, -] - -[package.dependencies] -colorama = ">=0.4" - -[package.extras] -async = ["aiofiles (>=0.7,<1.0)"] - -[[package]] -name = "identify" -version = "2.5.22" -description = "File identification library for Python" -category = "dev" -optional = false -python-versions = ">=3.7" -files = [ - {file = "identify-2.5.22-py2.py3-none-any.whl", hash = "sha256:f0faad595a4687053669c112004178149f6c326db71ee999ae4636685753ad2f"}, - {file = "identify-2.5.22.tar.gz", hash = "sha256:f7a93d6cf98e29bd07663c60728e7a4057615068d7a639d132dc883b2d54d31e"}, -] - -[package.extras] -license = ["ukkonen"] - -[[package]] -name = "idna" -version = "3.4" -description = "Internationalized Domain Names in Applications (IDNA)" -category = "dev" -optional = false -python-versions = ">=3.5" -files = [ - {file = "idna-3.4-py3-none-any.whl", hash = "sha256:90b77e79eaa3eba6de819a0c442c0b4ceefc341a7a2ab77d7562bf49f425c5c2"}, - {file = "idna-3.4.tar.gz", hash = "sha256:814f528e8dead7d329833b91c5faa87d60bf71824cd12a7530b5526063d02cb4"}, -] - -[[package]] -name = "imageio" -version = "2.30.0" -description = "Library for reading and writing a wide range of image, video, scientific, and volumetric data formats." -category = "main" -optional = false -python-versions = ">=3.7" -files = [ - {file = "imageio-2.30.0-py3-none-any.whl", hash = "sha256:e045e9593ed94af41759901d6a51d5313b1e78fc118b6befbbfbf4e9cbe7398a"}, - {file = "imageio-2.30.0.tar.gz", hash = "sha256:7fc6ad5b5677cb1e58077875a72512aa8c392b6d40885eca0a6ab250efb4b8f4"}, -] - -[package.dependencies] -numpy = "*" -pillow = ">=8.3.2" - -[package.extras] -all-plugins = ["astropy", "av", "imageio-ffmpeg", "psutil", "tifffile"] -all-plugins-pypy = ["av", "imageio-ffmpeg", "psutil", "tifffile"] -build = ["wheel"] -dev = ["black", "flake8", "fsspec[github]", "pytest", "pytest-cov"] -docs = ["numpydoc", "pydata-sphinx-theme", "sphinx (<6)"] -ffmpeg = ["imageio-ffmpeg", "psutil"] -fits = ["astropy"] -full = ["astropy", "av", "black", "flake8", "fsspec[github]", "gdal", "imageio-ffmpeg", "itk", "numpydoc", "psutil", "pydata-sphinx-theme", "pytest", "pytest-cov", "sphinx (<6)", "tifffile", "wheel"] -gdal = ["gdal"] -itk = ["itk"] -linting = ["black", "flake8"] -pyav = ["av"] -test = ["fsspec[github]", "pytest", "pytest-cov"] -tifffile = ["tifffile"] - -[[package]] -name = "importlib-metadata" -version = "6.1.0" -description = "Read metadata from Python packages" -category = "dev" -optional = false -python-versions = ">=3.7" -files = [ - {file = "importlib_metadata-6.1.0-py3-none-any.whl", hash = "sha256:ff80f3b5394912eb1b108fcfd444dc78b7f1f3e16b16188054bd01cb9cb86f09"}, - {file = "importlib_metadata-6.1.0.tar.gz", hash = "sha256:43ce9281e097583d758c2c708c4376371261a02c34682491a8e98352365aad20"}, -] - -[package.dependencies] -zipp = ">=0.5" - -[package.extras] -docs = ["furo", "jaraco.packaging (>=9)", "jaraco.tidelift (>=1.4)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-lint"] -perf = ["ipython"] -testing = ["flake8 (<5)", "flufl.flake8", "importlib-resources (>=1.3)", "packaging", "pyfakefs", "pytest (>=6)", "pytest-black (>=0.3.7)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=1.3)", "pytest-flake8", "pytest-mypy (>=0.9.1)", "pytest-perf (>=0.9.2)"] - -[[package]] -name = "importlib-resources" -version = "5.12.0" -description = "Read resources from Python packages" -category = "main" -optional = false -python-versions = ">=3.7" -files = [ - {file = "importlib_resources-5.12.0-py3-none-any.whl", hash = "sha256:7b1deeebbf351c7578e09bf2f63fa2ce8b5ffec296e0d349139d43cca061a81a"}, - {file = "importlib_resources-5.12.0.tar.gz", hash = "sha256:4be82589bf5c1d7999aedf2a45159d10cb3ca4f19b2271f8792bc8e6da7b22f6"}, -] - -[package.dependencies] -zipp = {version = ">=3.1.0", markers = "python_version < \"3.10\""} - -[package.extras] -docs = ["furo", "jaraco.packaging (>=9)", "jaraco.tidelift (>=1.4)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-lint"] -testing = ["flake8 (<5)", "pytest (>=6)", "pytest-black (>=0.3.7)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=1.3)", "pytest-flake8", "pytest-mypy (>=0.9.1)"] - -[[package]] -name = "iniconfig" -version = "2.0.0" -description = "brain-dead simple config-ini parsing" -category = "dev" -optional = false -python-versions = ">=3.7" -files = [ - {file = "iniconfig-2.0.0-py3-none-any.whl", hash = "sha256:b6a85871a79d2e3b22d2d1b94ac2824226a63c6b741c88f7ae975f18b6778374"}, - {file = "iniconfig-2.0.0.tar.gz", hash = "sha256:2d91e135bf72d31a410b17c16da610a82cb55f6b0477d1a902134b24a455b8b3"}, -] - -[[package]] -name = "ipykernel" -version = "6.22.0" -description = "IPython Kernel for Jupyter" -category = "dev" -optional = false -python-versions = ">=3.8" -files = [ - {file = "ipykernel-6.22.0-py3-none-any.whl", hash = "sha256:1ae6047c1277508933078163721bbb479c3e7292778a04b4bacf0874550977d6"}, - {file = "ipykernel-6.22.0.tar.gz", hash = "sha256:302558b81f1bc22dc259fb2a0c5c7cf2f4c0bdb21b50484348f7bafe7fb71421"}, -] - -[package.dependencies] -appnope = {version = "*", markers = "platform_system == \"Darwin\""} -comm = ">=0.1.1" -debugpy = ">=1.6.5" -ipython = ">=7.23.1" -jupyter-client = ">=6.1.12" -jupyter-core = ">=4.12,<5.0.0 || >=5.1.0" -matplotlib-inline = ">=0.1" -nest-asyncio = "*" -packaging = "*" -psutil = "*" -pyzmq = ">=20" -tornado = ">=6.1" -traitlets = ">=5.4.0" - -[package.extras] -cov = ["coverage[toml]", "curio", "matplotlib", "pytest-cov", "trio"] -docs = ["myst-parser", "pydata-sphinx-theme", "sphinx", "sphinx-autodoc-typehints", "sphinxcontrib-github-alt", "sphinxcontrib-spelling", "trio"] -pyqt5 = ["pyqt5"] -pyside6 = ["pyside6"] -test = ["flaky", "ipyparallel", "pre-commit", "pytest (>=7.0)", "pytest-asyncio", "pytest-cov", "pytest-timeout"] - -[[package]] -name = "ipython" -version = "8.12.2" -description = "IPython: Productive Interactive Computing" -category = "dev" -optional = false -python-versions = ">=3.8" -files = [ - {file = "ipython-8.12.2-py3-none-any.whl", hash = "sha256:ea8801f15dfe4ffb76dea1b09b847430ffd70d827b41735c64a0638a04103bfc"}, - {file = "ipython-8.12.2.tar.gz", hash = "sha256:c7b80eb7f5a855a88efc971fda506ff7a91c280b42cdae26643e0f601ea281ea"}, -] - -[package.dependencies] -appnope = {version = "*", markers = "sys_platform == \"darwin\""} -backcall = "*" -colorama = {version = "*", markers = "sys_platform == \"win32\""} -decorator = "*" -jedi = ">=0.16" -matplotlib-inline = "*" -pexpect = {version = ">4.3", markers = "sys_platform != \"win32\""} -pickleshare = "*" -prompt-toolkit = ">=3.0.30,<3.0.37 || >3.0.37,<3.1.0" -pygments = ">=2.4.0" -stack-data = "*" -traitlets = ">=5" -typing-extensions = {version = "*", markers = "python_version < \"3.10\""} - -[package.extras] -all = ["black", "curio", "docrepr", "ipykernel", "ipyparallel", "ipywidgets", "matplotlib", "matplotlib (!=3.2.0)", "nbconvert", "nbformat", "notebook", "numpy (>=1.21)", "pandas", "pytest (<7)", "pytest (<7.1)", "pytest-asyncio", "qtconsole", "setuptools (>=18.5)", "sphinx (>=1.3)", "sphinx-rtd-theme", "stack-data", "testpath", "trio", "typing-extensions"] -black = ["black"] -doc = ["docrepr", "ipykernel", "matplotlib", "pytest (<7)", "pytest (<7.1)", "pytest-asyncio", "setuptools (>=18.5)", "sphinx (>=1.3)", "sphinx-rtd-theme", "stack-data", "testpath", "typing-extensions"] -kernel = ["ipykernel"] -nbconvert = ["nbconvert"] -nbformat = ["nbformat"] -notebook = ["ipywidgets", "notebook"] -parallel = ["ipyparallel"] -qtconsole = ["qtconsole"] -test = ["pytest (<7.1)", "pytest-asyncio", "testpath"] -test-extra = ["curio", "matplotlib (!=3.2.0)", "nbformat", "numpy (>=1.21)", "pandas", "pytest (<7.1)", "pytest-asyncio", "testpath", "trio"] - -[[package]] -name = "ipython-genutils" -version = "0.2.0" -description = "Vestigial utilities from IPython" -category = "dev" -optional = false -python-versions = "*" -files = [ - {file = "ipython_genutils-0.2.0-py2.py3-none-any.whl", hash = "sha256:72dd37233799e619666c9f639a9da83c34013a73e8bbc79a7a6348d93c61fab8"}, - {file = "ipython_genutils-0.2.0.tar.gz", hash = "sha256:eb2e116e75ecef9d4d228fdc66af54269afa26ab4463042e33785b887c628ba8"}, -] - -[[package]] -name = "ipywidgets" -version = "8.0.6" -description = "Jupyter interactive widgets" -category = "dev" -optional = false -python-versions = ">=3.7" -files = [ - {file = "ipywidgets-8.0.6-py3-none-any.whl", hash = "sha256:a60bf8d2528997e05ac83fd19ea2fbe65f2e79fbe1b2b35779bdfc46c2941dcc"}, - {file = "ipywidgets-8.0.6.tar.gz", hash = "sha256:de7d779f2045d60de9f6c25f653fdae2dba57898e6a1284494b3ba20b6893bb8"}, -] - -[package.dependencies] -ipykernel = ">=4.5.1" -ipython = ">=6.1.0" -jupyterlab-widgets = ">=3.0.7,<3.1.0" -traitlets = ">=4.3.1" -widgetsnbextension = ">=4.0.7,<4.1.0" - -[package.extras] -test = ["ipykernel", "jsonschema", "pytest (>=3.6.0)", "pytest-cov", "pytz"] - -[[package]] -name = "isoduration" -version = "20.11.0" -description = "Operations with ISO 8601 durations" -category = "dev" -optional = false -python-versions = ">=3.7" -files = [ - {file = "isoduration-20.11.0-py3-none-any.whl", hash = "sha256:b2904c2a4228c3d44f409c8ae8e2370eb21a26f7ac2ec5446df141dde3452042"}, - {file = "isoduration-20.11.0.tar.gz", hash = "sha256:ac2f9015137935279eac671f94f89eb00584f940f5dc49462a0c4ee692ba1bd9"}, -] - -[package.dependencies] -arrow = ">=0.15.0" - -[[package]] -name = "jedi" -version = "0.18.2" -description = "An autocompletion tool for Python that can be used for text editors." -category = "dev" -optional = false -python-versions = ">=3.6" -files = [ - {file = "jedi-0.18.2-py2.py3-none-any.whl", hash = "sha256:203c1fd9d969ab8f2119ec0a3342e0b49910045abe6af0a3ae83a5764d54639e"}, - {file = "jedi-0.18.2.tar.gz", hash = "sha256:bae794c30d07f6d910d32a7048af09b5a39ed740918da923c6b780790ebac612"}, -] - -[package.dependencies] -parso = ">=0.8.0,<0.9.0" - -[package.extras] -docs = ["Jinja2 (==2.11.3)", "MarkupSafe (==1.1.1)", "Pygments (==2.8.1)", "alabaster (==0.7.12)", "babel (==2.9.1)", "chardet (==4.0.0)", "commonmark (==0.8.1)", "docutils (==0.17.1)", "future (==0.18.2)", "idna (==2.10)", "imagesize (==1.2.0)", "mock (==1.0.1)", "packaging (==20.9)", "pyparsing (==2.4.7)", "pytz (==2021.1)", "readthedocs-sphinx-ext (==2.1.4)", "recommonmark (==0.5.0)", "requests (==2.25.1)", "six (==1.15.0)", "snowballstemmer (==2.1.0)", "sphinx (==1.8.5)", "sphinx-rtd-theme (==0.4.3)", "sphinxcontrib-serializinghtml (==1.1.4)", "sphinxcontrib-websupport (==1.2.4)", "urllib3 (==1.26.4)"] -qa = ["flake8 (==3.8.3)", "mypy (==0.782)"] -testing = ["Django (<3.1)", "attrs", "colorama", "docopt", "pytest (<7.0.0)"] - -[[package]] -name = "jinja2" -version = "3.1.2" -description = "A very fast and expressive template engine." -category = "main" -optional = false -python-versions = ">=3.7" -files = [ - {file = "Jinja2-3.1.2-py3-none-any.whl", hash = "sha256:6088930bfe239f0e6710546ab9c19c9ef35e29792895fed6e6e31a023a182a61"}, - {file = "Jinja2-3.1.2.tar.gz", hash = "sha256:31351a702a408a9e7595a8fc6150fc3f43bb6bf7e319770cbc0db9df9437e852"}, -] - -[package.dependencies] -MarkupSafe = ">=2.0" - -[package.extras] -i18n = ["Babel (>=2.7)"] - -[[package]] -name = "joblib" -version = "1.2.0" -description = "Lightweight pipelining with Python functions" -category = "main" -optional = false -python-versions = ">=3.7" -files = [ - {file = "joblib-1.2.0-py3-none-any.whl", hash = "sha256:091138ed78f800342968c523bdde947e7a305b8594b910a0fea2ab83c3c6d385"}, - {file = "joblib-1.2.0.tar.gz", hash = "sha256:e1cee4a79e4af22881164f218d4311f60074197fb707e082e803b61f6d137018"}, -] - -[[package]] -name = "jsonpointer" -version = "2.3" -description = "Identify specific nodes in a JSON document (RFC 6901)" -category = "dev" -optional = false -python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" -files = [ - {file = "jsonpointer-2.3-py2.py3-none-any.whl", hash = "sha256:51801e558539b4e9cd268638c078c6c5746c9ac96bc38152d443400e4f3793e9"}, - {file = "jsonpointer-2.3.tar.gz", hash = "sha256:97cba51526c829282218feb99dab1b1e6bdf8efd1c43dc9d57be093c0d69c99a"}, -] - -[[package]] -name = "jsonschema" -version = "4.17.3" -description = "An implementation of JSON Schema validation for Python" -category = "dev" -optional = false -python-versions = ">=3.7" -files = [ - {file = "jsonschema-4.17.3-py3-none-any.whl", hash = "sha256:a870ad254da1a8ca84b6a2905cac29d265f805acc57af304784962a2aa6508f6"}, - {file = "jsonschema-4.17.3.tar.gz", hash = "sha256:0f864437ab8b6076ba6707453ef8f98a6a0d512a80e93f8abdb676f737ecb60d"}, -] - -[package.dependencies] -attrs = ">=17.4.0" -fqdn = {version = "*", optional = true, markers = "extra == \"format-nongpl\""} -idna = {version = "*", optional = true, markers = "extra == \"format-nongpl\""} -importlib-resources = {version = ">=1.4.0", markers = "python_version < \"3.9\""} -isoduration = {version = "*", optional = true, markers = "extra == \"format-nongpl\""} -jsonpointer = {version = ">1.13", optional = true, markers = "extra == \"format-nongpl\""} -pkgutil-resolve-name = {version = ">=1.3.10", markers = "python_version < \"3.9\""} -pyrsistent = ">=0.14.0,<0.17.0 || >0.17.0,<0.17.1 || >0.17.1,<0.17.2 || >0.17.2" -rfc3339-validator = {version = "*", optional = true, markers = "extra == \"format-nongpl\""} -rfc3986-validator = {version = ">0.1.0", optional = true, markers = "extra == \"format-nongpl\""} -uri-template = {version = "*", optional = true, markers = "extra == \"format-nongpl\""} -webcolors = {version = ">=1.11", optional = true, markers = "extra == \"format-nongpl\""} - -[package.extras] -format = ["fqdn", "idna", "isoduration", "jsonpointer (>1.13)", "rfc3339-validator", "rfc3987", "uri-template", "webcolors (>=1.11)"] -format-nongpl = ["fqdn", "idna", "isoduration", "jsonpointer (>1.13)", "rfc3339-validator", "rfc3986-validator (>0.1.0)", "uri-template", "webcolors (>=1.11)"] - -[[package]] -name = "jupyter" -version = "1.0.0" -description = "Jupyter metapackage. Install all the Jupyter components in one go." -category = "dev" -optional = false -python-versions = "*" -files = [ - {file = "jupyter-1.0.0-py2.py3-none-any.whl", hash = "sha256:5b290f93b98ffbc21c0c7e749f054b3267782166d72fa5e3ed1ed4eaf34a2b78"}, - {file = "jupyter-1.0.0.tar.gz", hash = "sha256:d9dc4b3318f310e34c82951ea5d6683f67bed7def4b259fafbfe4f1beb1d8e5f"}, - {file = "jupyter-1.0.0.zip", hash = "sha256:3e1f86076bbb7c8c207829390305a2b1fe836d471ed54be66a3b8c41e7f46cc7"}, -] - -[package.dependencies] -ipykernel = "*" -ipywidgets = "*" -jupyter-console = "*" -nbconvert = "*" -notebook = "*" -qtconsole = "*" - -[[package]] -name = "jupyter-client" -version = "8.1.0" -description = "Jupyter protocol implementation and client libraries" -category = "dev" -optional = false -python-versions = ">=3.8" -files = [ - {file = "jupyter_client-8.1.0-py3-none-any.whl", hash = "sha256:d5b8e739d7816944be50f81121a109788a3d92732ecf1ad1e4dadebc948818fe"}, - {file = "jupyter_client-8.1.0.tar.gz", hash = "sha256:3fbab64100a0dcac7701b1e0f1a4412f1ccb45546ff2ad9bc4fcbe4e19804811"}, -] - -[package.dependencies] -importlib-metadata = {version = ">=4.8.3", markers = "python_version < \"3.10\""} -jupyter-core = ">=4.12,<5.0.0 || >=5.1.0" -python-dateutil = ">=2.8.2" -pyzmq = ">=23.0" -tornado = ">=6.2" -traitlets = ">=5.3" - -[package.extras] -docs = ["ipykernel", "myst-parser", "pydata-sphinx-theme", "sphinx (>=4)", "sphinx-autodoc-typehints", "sphinxcontrib-github-alt", "sphinxcontrib-spelling"] -test = ["codecov", "coverage", "ipykernel (>=6.14)", "mypy", "paramiko", "pre-commit", "pytest", "pytest-cov", "pytest-jupyter[client] (>=0.4.1)", "pytest-timeout"] - -[[package]] -name = "jupyter-console" -version = "6.6.3" -description = "Jupyter terminal console" -category = "dev" -optional = false -python-versions = ">=3.7" -files = [ - {file = "jupyter_console-6.6.3-py3-none-any.whl", hash = "sha256:309d33409fcc92ffdad25f0bcdf9a4a9daa61b6f341177570fdac03de5352485"}, - {file = "jupyter_console-6.6.3.tar.gz", hash = "sha256:566a4bf31c87adbfadf22cdf846e3069b59a71ed5da71d6ba4d8aaad14a53539"}, -] - -[package.dependencies] -ipykernel = ">=6.14" -ipython = "*" -jupyter-client = ">=7.0.0" -jupyter-core = ">=4.12,<5.0.0 || >=5.1.0" -prompt-toolkit = ">=3.0.30" -pygments = "*" -pyzmq = ">=17" -traitlets = ">=5.4" - -[package.extras] -test = ["flaky", "pexpect", "pytest"] - -[[package]] -name = "jupyter-core" -version = "5.3.0" -description = "Jupyter core package. A base package on which Jupyter projects rely." -category = "dev" -optional = false -python-versions = ">=3.8" -files = [ - {file = "jupyter_core-5.3.0-py3-none-any.whl", hash = "sha256:d4201af84559bc8c70cead287e1ab94aeef3c512848dde077b7684b54d67730d"}, - {file = "jupyter_core-5.3.0.tar.gz", hash = "sha256:6db75be0c83edbf1b7c9f91ec266a9a24ef945da630f3120e1a0046dc13713fc"}, -] - -[package.dependencies] -platformdirs = ">=2.5" -pywin32 = {version = ">=300", markers = "sys_platform == \"win32\" and platform_python_implementation != \"PyPy\""} -traitlets = ">=5.3" - -[package.extras] -docs = ["myst-parser", "sphinx-autodoc-typehints", "sphinxcontrib-github-alt", "sphinxcontrib-spelling", "traitlets"] -test = ["ipykernel", "pre-commit", "pytest", "pytest-cov", "pytest-timeout"] - -[[package]] -name = "jupyter-events" -version = "0.6.3" -description = "Jupyter Event System library" -category = "dev" -optional = false -python-versions = ">=3.7" -files = [ - {file = "jupyter_events-0.6.3-py3-none-any.whl", hash = "sha256:57a2749f87ba387cd1bfd9b22a0875b889237dbf2edc2121ebb22bde47036c17"}, - {file = "jupyter_events-0.6.3.tar.gz", hash = "sha256:9a6e9995f75d1b7146b436ea24d696ce3a35bfa8bfe45e0c33c334c79464d0b3"}, -] - -[package.dependencies] -jsonschema = {version = ">=3.2.0", extras = ["format-nongpl"]} -python-json-logger = ">=2.0.4" -pyyaml = ">=5.3" -rfc3339-validator = "*" -rfc3986-validator = ">=0.1.1" -traitlets = ">=5.3" - -[package.extras] -cli = ["click", "rich"] -docs = ["jupyterlite-sphinx", "myst-parser", "pydata-sphinx-theme", "sphinxcontrib-spelling"] -test = ["click", "coverage", "pre-commit", "pytest (>=7.0)", "pytest-asyncio (>=0.19.0)", "pytest-console-scripts", "pytest-cov", "rich"] - -[[package]] -name = "jupyter-server" -version = "2.5.0" -description = "The backend—i.e. core services, APIs, and REST endpoints—to Jupyter web applications." -category = "dev" -optional = false -python-versions = ">=3.8" -files = [ - {file = "jupyter_server-2.5.0-py3-none-any.whl", hash = "sha256:e6bc1e9e96d7c55b9ce9699ff6cb9a910581fe7349e27c40389acb67632e24c0"}, - {file = "jupyter_server-2.5.0.tar.gz", hash = "sha256:9fde612791f716fd34d610cd939704a9639643744751ba66e7ee8fdc9cead07e"}, -] - -[package.dependencies] -anyio = ">=3.1.0" -argon2-cffi = "*" -jinja2 = "*" -jupyter-client = ">=7.4.4" -jupyter-core = ">=4.12,<5.0.0 || >=5.1.0" -jupyter-events = ">=0.4.0" -jupyter-server-terminals = "*" -nbconvert = ">=6.4.4" -nbformat = ">=5.3.0" -packaging = "*" -prometheus-client = "*" -pywinpty = {version = "*", markers = "os_name == \"nt\""} -pyzmq = ">=24" -send2trash = "*" -terminado = ">=0.8.3" -tornado = ">=6.2.0" -traitlets = ">=5.6.0" -websocket-client = "*" - -[package.extras] -docs = ["docutils (<0.20)", "ipykernel", "jinja2", "jupyter-client", "jupyter-server", "mistune (<1.0.0)", "myst-parser", "nbformat", "prometheus-client", "pydata-sphinx-theme", "send2trash", "sphinx-autodoc-typehints", "sphinxcontrib-github-alt", "sphinxcontrib-openapi", "sphinxcontrib-spelling", "sphinxemoji", "tornado", "typing-extensions"] -test = ["ipykernel", "pre-commit", "pytest (>=7.0)", "pytest-console-scripts", "pytest-jupyter[server] (>=0.4)", "pytest-timeout", "requests"] - -[[package]] -name = "jupyter-server-terminals" -version = "0.4.4" -description = "A Jupyter Server Extension Providing Terminals." -category = "dev" -optional = false -python-versions = ">=3.8" -files = [ - {file = "jupyter_server_terminals-0.4.4-py3-none-any.whl", hash = "sha256:75779164661cec02a8758a5311e18bb8eb70c4e86c6b699403100f1585a12a36"}, - {file = "jupyter_server_terminals-0.4.4.tar.gz", hash = "sha256:57ab779797c25a7ba68e97bcfb5d7740f2b5e8a83b5e8102b10438041a7eac5d"}, -] - -[package.dependencies] -pywinpty = {version = ">=2.0.3", markers = "os_name == \"nt\""} -terminado = ">=0.8.3" - -[package.extras] -docs = ["jinja2", "jupyter-server", "mistune (<3.0)", "myst-parser", "nbformat", "packaging", "pydata-sphinx-theme", "sphinxcontrib-github-alt", "sphinxcontrib-openapi", "sphinxcontrib-spelling", "sphinxemoji", "tornado"] -test = ["coverage", "jupyter-server (>=2.0.0)", "pytest (>=7.0)", "pytest-cov", "pytest-jupyter[server] (>=0.5.3)", "pytest-timeout"] - -[[package]] -name = "jupyterlab-pygments" -version = "0.2.2" -description = "Pygments theme using JupyterLab CSS variables" -category = "dev" -optional = false -python-versions = ">=3.7" -files = [ - {file = "jupyterlab_pygments-0.2.2-py2.py3-none-any.whl", hash = "sha256:2405800db07c9f770863bcf8049a529c3dd4d3e28536638bd7c1c01d2748309f"}, - {file = "jupyterlab_pygments-0.2.2.tar.gz", hash = "sha256:7405d7fde60819d905a9fa8ce89e4cd830e318cdad22a0030f7a901da705585d"}, -] - -[[package]] -name = "jupyterlab-widgets" -version = "3.0.7" -description = "Jupyter interactive widgets for JupyterLab" -category = "dev" -optional = false -python-versions = ">=3.7" -files = [ - {file = "jupyterlab_widgets-3.0.7-py3-none-any.whl", hash = "sha256:c73f8370338ec19f1bec47254752d6505b03601cbd5a67e6a0b184532f73a459"}, - {file = "jupyterlab_widgets-3.0.7.tar.gz", hash = "sha256:c3a50ed5bf528a0c7a869096503af54702f86dda1db469aee1c92dc0c01b43ca"}, -] - -[[package]] -name = "jupytext" -version = "1.14.5" -description = "Jupyter notebooks as Markdown documents, Julia, Python or R scripts" -category = "dev" -optional = false -python-versions = "~=3.6" -files = [ - {file = "jupytext-1.14.5-py3-none-any.whl", hash = "sha256:a5dbe60d0ea158bbf82c2bce74aba8d0c220ad7edcda09e017c5eba229b34dc8"}, - {file = "jupytext-1.14.5.tar.gz", hash = "sha256:976e66be8056459a2067e0ec3ff68cc31e00c31895faf9eb893022d319e8f5b4"}, -] - -[package.dependencies] -markdown-it-py = ">=1.0.0,<3.0.0" -mdit-py-plugins = "*" -nbformat = "*" -pyyaml = "*" -toml = "*" - -[package.extras] -rst2md = ["sphinx-gallery (>=0.7.0,<0.8.0)"] -toml = ["toml"] - -[[package]] -name = "kiwisolver" -version = "1.4.4" -description = "A fast implementation of the Cassowary constraint solver" -category = "main" -optional = false -python-versions = ">=3.7" -files = [ - {file = "kiwisolver-1.4.4-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:2f5e60fabb7343a836360c4f0919b8cd0d6dbf08ad2ca6b9cf90bf0c76a3c4f6"}, - {file = "kiwisolver-1.4.4-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:10ee06759482c78bdb864f4109886dff7b8a56529bc1609d4f1112b93fe6423c"}, - {file = "kiwisolver-1.4.4-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:c79ebe8f3676a4c6630fd3f777f3cfecf9289666c84e775a67d1d358578dc2e3"}, - {file = "kiwisolver-1.4.4-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:abbe9fa13da955feb8202e215c4018f4bb57469b1b78c7a4c5c7b93001699938"}, - {file = "kiwisolver-1.4.4-cp310-cp310-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:7577c1987baa3adc4b3c62c33bd1118c3ef5c8ddef36f0f2c950ae0b199e100d"}, - {file = "kiwisolver-1.4.4-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f8ad8285b01b0d4695102546b342b493b3ccc6781fc28c8c6a1bb63e95d22f09"}, - {file = "kiwisolver-1.4.4-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8ed58b8acf29798b036d347791141767ccf65eee7f26bde03a71c944449e53de"}, - {file = "kiwisolver-1.4.4-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a68b62a02953b9841730db7797422f983935aeefceb1679f0fc85cbfbd311c32"}, - {file = "kiwisolver-1.4.4-cp310-cp310-win32.whl", hash = "sha256:e92a513161077b53447160b9bd8f522edfbed4bd9759e4c18ab05d7ef7e49408"}, - {file = "kiwisolver-1.4.4-cp310-cp310-win_amd64.whl", hash = "sha256:3fe20f63c9ecee44560d0e7f116b3a747a5d7203376abeea292ab3152334d004"}, - {file = "kiwisolver-1.4.4-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:e0ea21f66820452a3f5d1655f8704a60d66ba1191359b96541eaf457710a5fc6"}, - {file = "kiwisolver-1.4.4-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:bc9db8a3efb3e403e4ecc6cd9489ea2bac94244f80c78e27c31dcc00d2790ac2"}, - {file = "kiwisolver-1.4.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:d5b61785a9ce44e5a4b880272baa7cf6c8f48a5180c3e81c59553ba0cb0821ca"}, - {file = "kiwisolver-1.4.4-cp311-cp311-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c2dbb44c3f7e6c4d3487b31037b1bdbf424d97687c1747ce4ff2895795c9bf69"}, - {file = "kiwisolver-1.4.4-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6295ecd49304dcf3bfbfa45d9a081c96509e95f4b9d0eb7ee4ec0530c4a96514"}, - {file = "kiwisolver-1.4.4-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4bd472dbe5e136f96a4b18f295d159d7f26fd399136f5b17b08c4e5f498cd494"}, - {file = "kiwisolver-1.4.4-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:bf7d9fce9bcc4752ca4a1b80aabd38f6d19009ea5cbda0e0856983cf6d0023f5"}, - {file = "kiwisolver-1.4.4-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:78d6601aed50c74e0ef02f4204da1816147a6d3fbdc8b3872d263338a9052c51"}, - {file = "kiwisolver-1.4.4-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:877272cf6b4b7e94c9614f9b10140e198d2186363728ed0f701c6eee1baec1da"}, - {file = "kiwisolver-1.4.4-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:db608a6757adabb32f1cfe6066e39b3706d8c3aa69bbc353a5b61edad36a5cb4"}, - {file = "kiwisolver-1.4.4-cp311-cp311-musllinux_1_1_ppc64le.whl", hash = "sha256:5853eb494c71e267912275e5586fe281444eb5e722de4e131cddf9d442615626"}, - {file = "kiwisolver-1.4.4-cp311-cp311-musllinux_1_1_s390x.whl", hash = "sha256:f0a1dbdb5ecbef0d34eb77e56fcb3e95bbd7e50835d9782a45df81cc46949750"}, - {file = "kiwisolver-1.4.4-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:283dffbf061a4ec60391d51e6155e372a1f7a4f5b15d59c8505339454f8989e4"}, - {file = "kiwisolver-1.4.4-cp311-cp311-win32.whl", hash = "sha256:d06adcfa62a4431d404c31216f0f8ac97397d799cd53800e9d3efc2fbb3cf14e"}, - {file = "kiwisolver-1.4.4-cp311-cp311-win_amd64.whl", hash = "sha256:e7da3fec7408813a7cebc9e4ec55afed2d0fd65c4754bc376bf03498d4e92686"}, - {file = "kiwisolver-1.4.4-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:62ac9cc684da4cf1778d07a89bf5f81b35834cb96ca523d3a7fb32509380cbf6"}, - {file = "kiwisolver-1.4.4-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:41dae968a94b1ef1897cb322b39360a0812661dba7c682aa45098eb8e193dbdf"}, - {file = "kiwisolver-1.4.4-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:02f79693ec433cb4b5f51694e8477ae83b3205768a6fb48ffba60549080e295b"}, - {file = "kiwisolver-1.4.4-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d0611a0a2a518464c05ddd5a3a1a0e856ccc10e67079bb17f265ad19ab3c7597"}, - {file = "kiwisolver-1.4.4-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:db5283d90da4174865d520e7366801a93777201e91e79bacbac6e6927cbceede"}, - {file = "kiwisolver-1.4.4-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:1041feb4cda8708ce73bb4dcb9ce1ccf49d553bf87c3954bdfa46f0c3f77252c"}, - {file = "kiwisolver-1.4.4-cp37-cp37m-win32.whl", hash = "sha256:a553dadda40fef6bfa1456dc4be49b113aa92c2a9a9e8711e955618cd69622e3"}, - {file = "kiwisolver-1.4.4-cp37-cp37m-win_amd64.whl", hash = "sha256:03baab2d6b4a54ddbb43bba1a3a2d1627e82d205c5cf8f4c924dc49284b87166"}, - {file = "kiwisolver-1.4.4-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:841293b17ad704d70c578f1f0013c890e219952169ce8a24ebc063eecf775454"}, - {file = "kiwisolver-1.4.4-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:f4f270de01dd3e129a72efad823da90cc4d6aafb64c410c9033aba70db9f1ff0"}, - {file = "kiwisolver-1.4.4-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:f9f39e2f049db33a908319cf46624a569b36983c7c78318e9726a4cb8923b26c"}, - {file = "kiwisolver-1.4.4-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c97528e64cb9ebeff9701e7938653a9951922f2a38bd847787d4a8e498cc83ae"}, - {file = "kiwisolver-1.4.4-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1d1573129aa0fd901076e2bfb4275a35f5b7aa60fbfb984499d661ec950320b0"}, - {file = "kiwisolver-1.4.4-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ad881edc7ccb9d65b0224f4e4d05a1e85cf62d73aab798943df6d48ab0cd79a1"}, - {file = "kiwisolver-1.4.4-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:b428ef021242344340460fa4c9185d0b1f66fbdbfecc6c63eff4b7c29fad429d"}, - {file = "kiwisolver-1.4.4-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:2e407cb4bd5a13984a6c2c0fe1845e4e41e96f183e5e5cd4d77a857d9693494c"}, - {file = "kiwisolver-1.4.4-cp38-cp38-win32.whl", hash = "sha256:75facbe9606748f43428fc91a43edb46c7ff68889b91fa31f53b58894503a191"}, - {file = "kiwisolver-1.4.4-cp38-cp38-win_amd64.whl", hash = "sha256:5bce61af018b0cb2055e0e72e7d65290d822d3feee430b7b8203d8a855e78766"}, - {file = "kiwisolver-1.4.4-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:8c808594c88a025d4e322d5bb549282c93c8e1ba71b790f539567932722d7bd8"}, - {file = "kiwisolver-1.4.4-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:f0a71d85ecdd570ded8ac3d1c0f480842f49a40beb423bb8014539a9f32a5897"}, - {file = "kiwisolver-1.4.4-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:b533558eae785e33e8c148a8d9921692a9fe5aa516efbdff8606e7d87b9d5824"}, - {file = "kiwisolver-1.4.4-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:efda5fc8cc1c61e4f639b8067d118e742b812c930f708e6667a5ce0d13499e29"}, - {file = "kiwisolver-1.4.4-cp39-cp39-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:7c43e1e1206cd421cd92e6b3280d4385d41d7166b3ed577ac20444b6995a445f"}, - {file = "kiwisolver-1.4.4-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bc8d3bd6c72b2dd9decf16ce70e20abcb3274ba01b4e1c96031e0c4067d1e7cd"}, - {file = "kiwisolver-1.4.4-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4ea39b0ccc4f5d803e3337dd46bcce60b702be4d86fd0b3d7531ef10fd99a1ac"}, - {file = "kiwisolver-1.4.4-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:968f44fdbf6dd757d12920d63b566eeb4d5b395fd2d00d29d7ef00a00582aac9"}, - {file = "kiwisolver-1.4.4-cp39-cp39-win32.whl", hash = "sha256:da7e547706e69e45d95e116e6939488d62174e033b763ab1496b4c29b76fabea"}, - {file = "kiwisolver-1.4.4-cp39-cp39-win_amd64.whl", hash = "sha256:ba59c92039ec0a66103b1d5fe588fa546373587a7d68f5c96f743c3396afc04b"}, - {file = "kiwisolver-1.4.4-pp37-pypy37_pp73-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:91672bacaa030f92fc2f43b620d7b337fd9a5af28b0d6ed3f77afc43c4a64b5a"}, - {file = "kiwisolver-1.4.4-pp37-pypy37_pp73-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:787518a6789009c159453da4d6b683f468ef7a65bbde796bcea803ccf191058d"}, - {file = "kiwisolver-1.4.4-pp37-pypy37_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:da152d8cdcab0e56e4f45eb08b9aea6455845ec83172092f09b0e077ece2cf7a"}, - {file = "kiwisolver-1.4.4-pp37-pypy37_pp73-win_amd64.whl", hash = "sha256:ecb1fa0db7bf4cff9dac752abb19505a233c7f16684c5826d1f11ebd9472b871"}, - {file = "kiwisolver-1.4.4-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:28bc5b299f48150b5f822ce68624e445040595a4ac3d59251703779836eceff9"}, - {file = "kiwisolver-1.4.4-pp38-pypy38_pp73-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:81e38381b782cc7e1e46c4e14cd997ee6040768101aefc8fa3c24a4cc58e98f8"}, - {file = "kiwisolver-1.4.4-pp38-pypy38_pp73-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:2a66fdfb34e05b705620dd567f5a03f239a088d5a3f321e7b6ac3239d22aa286"}, - {file = "kiwisolver-1.4.4-pp38-pypy38_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:872b8ca05c40d309ed13eb2e582cab0c5a05e81e987ab9c521bf05ad1d5cf5cb"}, - {file = "kiwisolver-1.4.4-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:70e7c2e7b750585569564e2e5ca9845acfaa5da56ac46df68414f29fea97be9f"}, - {file = "kiwisolver-1.4.4-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:9f85003f5dfa867e86d53fac6f7e6f30c045673fa27b603c397753bebadc3008"}, - {file = "kiwisolver-1.4.4-pp39-pypy39_pp73-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:2e307eb9bd99801f82789b44bb45e9f541961831c7311521b13a6c85afc09767"}, - {file = "kiwisolver-1.4.4-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b1792d939ec70abe76f5054d3f36ed5656021dcad1322d1cc996d4e54165cef9"}, - {file = "kiwisolver-1.4.4-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f6cb459eea32a4e2cf18ba5fcece2dbdf496384413bc1bae15583f19e567f3b2"}, - {file = "kiwisolver-1.4.4-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:36dafec3d6d6088d34e2de6b85f9d8e2324eb734162fba59d2ba9ed7a2043d5b"}, - {file = "kiwisolver-1.4.4.tar.gz", hash = "sha256:d41997519fcba4a1e46eb4a2fe31bc12f0ff957b2b81bac28db24744f333e955"}, -] - -[[package]] -name = "lit" -version = "16.0.0" -description = "A Software Testing Tool" -category = "main" -optional = false -python-versions = "*" -files = [ - {file = "lit-16.0.0.tar.gz", hash = "sha256:3c4ac372122a1de4a88deb277b956f91b7209420a0bef683b1ab2d2b16dabe11"}, -] - -[[package]] -name = "markdown" -version = "3.3.7" -description = "Python implementation of Markdown." -category = "dev" -optional = false -python-versions = ">=3.6" -files = [ - {file = "Markdown-3.3.7-py3-none-any.whl", hash = "sha256:f5da449a6e1c989a4cea2631aa8ee67caa5a2ef855d551c88f9e309f4634c621"}, - {file = "Markdown-3.3.7.tar.gz", hash = "sha256:cbb516f16218e643d8e0a95b309f77eb118cb138d39a4f27851e6a63581db874"}, -] - -[package.dependencies] -importlib-metadata = {version = ">=4.4", markers = "python_version < \"3.10\""} - -[package.extras] -testing = ["coverage", "pyyaml"] - -[[package]] -name = "markdown-it-py" -version = "2.2.0" -description = "Python port of markdown-it. Markdown parsing, done right!" -category = "dev" -optional = false -python-versions = ">=3.7" -files = [ - {file = "markdown-it-py-2.2.0.tar.gz", hash = "sha256:7c9a5e412688bc771c67432cbfebcdd686c93ce6484913dccf06cb5a0bea35a1"}, - {file = "markdown_it_py-2.2.0-py3-none-any.whl", hash = "sha256:5a35f8d1870171d9acc47b99612dc146129b631baf04970128b568f190d0cc30"}, -] - -[package.dependencies] -mdurl = ">=0.1,<1.0" - -[package.extras] -benchmarking = ["psutil", "pytest", "pytest-benchmark"] -code-style = ["pre-commit (>=3.0,<4.0)"] -compare = ["commonmark (>=0.9,<1.0)", "markdown (>=3.4,<4.0)", "mistletoe (>=1.0,<2.0)", "mistune (>=2.0,<3.0)", "panflute (>=2.3,<3.0)"] -linkify = ["linkify-it-py (>=1,<3)"] -plugins = ["mdit-py-plugins"] -profiling = ["gprof2dot"] -rtd = ["attrs", "myst-parser", "pyyaml", "sphinx", "sphinx-copybutton", "sphinx-design", "sphinx_book_theme"] -testing = ["coverage", "pytest", "pytest-cov", "pytest-regressions"] - -[[package]] -name = "markupsafe" -version = "2.1.2" -description = "Safely add untrusted strings to HTML/XML markup." -category = "main" -optional = false -python-versions = ">=3.7" -files = [ - {file = "MarkupSafe-2.1.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:665a36ae6f8f20a4676b53224e33d456a6f5a72657d9c83c2aa00765072f31f7"}, - {file = "MarkupSafe-2.1.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:340bea174e9761308703ae988e982005aedf427de816d1afe98147668cc03036"}, - {file = "MarkupSafe-2.1.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:22152d00bf4a9c7c83960521fc558f55a1adbc0631fbb00a9471e097b19d72e1"}, - {file = "MarkupSafe-2.1.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:28057e985dace2f478e042eaa15606c7efccb700797660629da387eb289b9323"}, - {file = "MarkupSafe-2.1.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ca244fa73f50a800cf8c3ebf7fd93149ec37f5cb9596aa8873ae2c1d23498601"}, - {file = "MarkupSafe-2.1.2-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:d9d971ec1e79906046aa3ca266de79eac42f1dbf3612a05dc9368125952bd1a1"}, - {file = "MarkupSafe-2.1.2-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:7e007132af78ea9df29495dbf7b5824cb71648d7133cf7848a2a5dd00d36f9ff"}, - {file = "MarkupSafe-2.1.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:7313ce6a199651c4ed9d7e4cfb4aa56fe923b1adf9af3b420ee14e6d9a73df65"}, - {file = "MarkupSafe-2.1.2-cp310-cp310-win32.whl", hash = "sha256:c4a549890a45f57f1ebf99c067a4ad0cb423a05544accaf2b065246827ed9603"}, - {file = "MarkupSafe-2.1.2-cp310-cp310-win_amd64.whl", hash = "sha256:835fb5e38fd89328e9c81067fd642b3593c33e1e17e2fdbf77f5676abb14a156"}, - {file = "MarkupSafe-2.1.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:2ec4f2d48ae59bbb9d1f9d7efb9236ab81429a764dedca114f5fdabbc3788013"}, - {file = "MarkupSafe-2.1.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:608e7073dfa9e38a85d38474c082d4281f4ce276ac0010224eaba11e929dd53a"}, - {file = "MarkupSafe-2.1.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:65608c35bfb8a76763f37036547f7adfd09270fbdbf96608be2bead319728fcd"}, - {file = "MarkupSafe-2.1.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f2bfb563d0211ce16b63c7cb9395d2c682a23187f54c3d79bfec33e6705473c6"}, - {file = "MarkupSafe-2.1.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:da25303d91526aac3672ee6d49a2f3db2d9502a4a60b55519feb1a4c7714e07d"}, - {file = "MarkupSafe-2.1.2-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:9cad97ab29dfc3f0249b483412c85c8ef4766d96cdf9dcf5a1e3caa3f3661cf1"}, - {file = "MarkupSafe-2.1.2-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:085fd3201e7b12809f9e6e9bc1e5c96a368c8523fad5afb02afe3c051ae4afcc"}, - {file = "MarkupSafe-2.1.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:1bea30e9bf331f3fef67e0a3877b2288593c98a21ccb2cf29b74c581a4eb3af0"}, - {file = "MarkupSafe-2.1.2-cp311-cp311-win32.whl", hash = "sha256:7df70907e00c970c60b9ef2938d894a9381f38e6b9db73c5be35e59d92e06625"}, - {file = "MarkupSafe-2.1.2-cp311-cp311-win_amd64.whl", hash = "sha256:e55e40ff0cc8cc5c07996915ad367fa47da6b3fc091fdadca7f5403239c5fec3"}, - {file = "MarkupSafe-2.1.2-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:a6e40afa7f45939ca356f348c8e23048e02cb109ced1eb8420961b2f40fb373a"}, - {file = "MarkupSafe-2.1.2-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cf877ab4ed6e302ec1d04952ca358b381a882fbd9d1b07cccbfd61783561f98a"}, - {file = "MarkupSafe-2.1.2-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:63ba06c9941e46fa389d389644e2d8225e0e3e5ebcc4ff1ea8506dce646f8c8a"}, - {file = "MarkupSafe-2.1.2-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f1cd098434e83e656abf198f103a8207a8187c0fc110306691a2e94a78d0abb2"}, - {file = "MarkupSafe-2.1.2-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:55f44b440d491028addb3b88f72207d71eeebfb7b5dbf0643f7c023ae1fba619"}, - {file = "MarkupSafe-2.1.2-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:a6f2fcca746e8d5910e18782f976489939d54a91f9411c32051b4aab2bd7c513"}, - {file = "MarkupSafe-2.1.2-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:0b462104ba25f1ac006fdab8b6a01ebbfbce9ed37fd37fd4acd70c67c973e460"}, - {file = "MarkupSafe-2.1.2-cp37-cp37m-win32.whl", hash = "sha256:7668b52e102d0ed87cb082380a7e2e1e78737ddecdde129acadb0eccc5423859"}, - {file = "MarkupSafe-2.1.2-cp37-cp37m-win_amd64.whl", hash = "sha256:6d6607f98fcf17e534162f0709aaad3ab7a96032723d8ac8750ffe17ae5a0666"}, - {file = "MarkupSafe-2.1.2-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:a806db027852538d2ad7555b203300173dd1b77ba116de92da9afbc3a3be3eed"}, - {file = "MarkupSafe-2.1.2-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:a4abaec6ca3ad8660690236d11bfe28dfd707778e2442b45addd2f086d6ef094"}, - {file = "MarkupSafe-2.1.2-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f03a532d7dee1bed20bc4884194a16160a2de9ffc6354b3878ec9682bb623c54"}, - {file = "MarkupSafe-2.1.2-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4cf06cdc1dda95223e9d2d3c58d3b178aa5dacb35ee7e3bbac10e4e1faacb419"}, - {file = "MarkupSafe-2.1.2-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:22731d79ed2eb25059ae3df1dfc9cb1546691cc41f4e3130fe6bfbc3ecbbecfa"}, - {file = "MarkupSafe-2.1.2-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:f8ffb705ffcf5ddd0e80b65ddf7bed7ee4f5a441ea7d3419e861a12eaf41af58"}, - {file = "MarkupSafe-2.1.2-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:8db032bf0ce9022a8e41a22598eefc802314e81b879ae093f36ce9ddf39ab1ba"}, - {file = "MarkupSafe-2.1.2-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:2298c859cfc5463f1b64bd55cb3e602528db6fa0f3cfd568d3605c50678f8f03"}, - {file = "MarkupSafe-2.1.2-cp38-cp38-win32.whl", hash = "sha256:50c42830a633fa0cf9e7d27664637532791bfc31c731a87b202d2d8ac40c3ea2"}, - {file = "MarkupSafe-2.1.2-cp38-cp38-win_amd64.whl", hash = "sha256:bb06feb762bade6bf3c8b844462274db0c76acc95c52abe8dbed28ae3d44a147"}, - {file = "MarkupSafe-2.1.2-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:99625a92da8229df6d44335e6fcc558a5037dd0a760e11d84be2260e6f37002f"}, - {file = "MarkupSafe-2.1.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:8bca7e26c1dd751236cfb0c6c72d4ad61d986e9a41bbf76cb445f69488b2a2bd"}, - {file = "MarkupSafe-2.1.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:40627dcf047dadb22cd25ea7ecfe9cbf3bbbad0482ee5920b582f3809c97654f"}, - {file = "MarkupSafe-2.1.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:40dfd3fefbef579ee058f139733ac336312663c6706d1163b82b3003fb1925c4"}, - {file = "MarkupSafe-2.1.2-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:090376d812fb6ac5f171e5938e82e7f2d7adc2b629101cec0db8b267815c85e2"}, - {file = "MarkupSafe-2.1.2-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:2e7821bffe00aa6bd07a23913b7f4e01328c3d5cc0b40b36c0bd81d362faeb65"}, - {file = "MarkupSafe-2.1.2-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:c0a33bc9f02c2b17c3ea382f91b4db0e6cde90b63b296422a939886a7a80de1c"}, - {file = "MarkupSafe-2.1.2-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:b8526c6d437855442cdd3d87eede9c425c4445ea011ca38d937db299382e6fa3"}, - {file = "MarkupSafe-2.1.2-cp39-cp39-win32.whl", hash = "sha256:137678c63c977754abe9086a3ec011e8fd985ab90631145dfb9294ad09c102a7"}, - {file = "MarkupSafe-2.1.2-cp39-cp39-win_amd64.whl", hash = "sha256:0576fe974b40a400449768941d5d0858cc624e3249dfd1e0c33674e5c7ca7aed"}, - {file = "MarkupSafe-2.1.2.tar.gz", hash = "sha256:abcabc8c2b26036d62d4c746381a6f7cf60aafcc653198ad678306986b09450d"}, -] - -[[package]] -name = "matplotlib" -version = "3.7.1" -description = "Python plotting package" -category = "main" -optional = false -python-versions = ">=3.8" -files = [ - {file = "matplotlib-3.7.1-cp310-cp310-macosx_10_12_universal2.whl", hash = "sha256:95cbc13c1fc6844ab8812a525bbc237fa1470863ff3dace7352e910519e194b1"}, - {file = "matplotlib-3.7.1-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:08308bae9e91aca1ec6fd6dda66237eef9f6294ddb17f0d0b3c863169bf82353"}, - {file = "matplotlib-3.7.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:544764ba51900da4639c0f983b323d288f94f65f4024dc40ecb1542d74dc0500"}, - {file = "matplotlib-3.7.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:56d94989191de3fcc4e002f93f7f1be5da476385dde410ddafbb70686acf00ea"}, - {file = "matplotlib-3.7.1-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e99bc9e65901bb9a7ce5e7bb24af03675cbd7c70b30ac670aa263240635999a4"}, - {file = "matplotlib-3.7.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eb7d248c34a341cd4c31a06fd34d64306624c8cd8d0def7abb08792a5abfd556"}, - {file = "matplotlib-3.7.1-cp310-cp310-win32.whl", hash = "sha256:ce463ce590f3825b52e9fe5c19a3c6a69fd7675a39d589e8b5fbe772272b3a24"}, - {file = "matplotlib-3.7.1-cp310-cp310-win_amd64.whl", hash = "sha256:3d7bc90727351fb841e4d8ae620d2d86d8ed92b50473cd2b42ce9186104ecbba"}, - {file = "matplotlib-3.7.1-cp311-cp311-macosx_10_12_universal2.whl", hash = "sha256:770a205966d641627fd5cf9d3cb4b6280a716522cd36b8b284a8eb1581310f61"}, - {file = "matplotlib-3.7.1-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:f67bfdb83a8232cb7a92b869f9355d677bce24485c460b19d01970b64b2ed476"}, - {file = "matplotlib-3.7.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:2bf092f9210e105f414a043b92af583c98f50050559616930d884387d0772aba"}, - {file = "matplotlib-3.7.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:89768d84187f31717349c6bfadc0e0d8c321e8eb34522acec8a67b1236a66332"}, - {file = "matplotlib-3.7.1-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:83111e6388dec67822e2534e13b243cc644c7494a4bb60584edbff91585a83c6"}, - {file = "matplotlib-3.7.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a867bf73a7eb808ef2afbca03bcdb785dae09595fbe550e1bab0cd023eba3de0"}, - {file = "matplotlib-3.7.1-cp311-cp311-win32.whl", hash = "sha256:fbdeeb58c0cf0595efe89c05c224e0a502d1aa6a8696e68a73c3efc6bc354304"}, - {file = "matplotlib-3.7.1-cp311-cp311-win_amd64.whl", hash = "sha256:c0bd19c72ae53e6ab979f0ac6a3fafceb02d2ecafa023c5cca47acd934d10be7"}, - {file = "matplotlib-3.7.1-cp38-cp38-macosx_10_12_universal2.whl", hash = "sha256:6eb88d87cb2c49af00d3bbc33a003f89fd9f78d318848da029383bfc08ecfbfb"}, - {file = "matplotlib-3.7.1-cp38-cp38-macosx_10_12_x86_64.whl", hash = "sha256:cf0e4f727534b7b1457898c4f4ae838af1ef87c359b76dcd5330fa31893a3ac7"}, - {file = "matplotlib-3.7.1-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:46a561d23b91f30bccfd25429c3c706afe7d73a5cc64ef2dfaf2b2ac47c1a5dc"}, - {file = "matplotlib-3.7.1-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:8704726d33e9aa8a6d5215044b8d00804561971163563e6e6591f9dcf64340cc"}, - {file = "matplotlib-3.7.1-cp38-cp38-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:4cf327e98ecf08fcbb82685acaf1939d3338548620ab8dfa02828706402c34de"}, - {file = "matplotlib-3.7.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:617f14ae9d53292ece33f45cba8503494ee199a75b44de7717964f70637a36aa"}, - {file = "matplotlib-3.7.1-cp38-cp38-win32.whl", hash = "sha256:7c9a4b2da6fac77bcc41b1ea95fadb314e92508bf5493ceff058e727e7ecf5b0"}, - {file = "matplotlib-3.7.1-cp38-cp38-win_amd64.whl", hash = "sha256:14645aad967684e92fc349493fa10c08a6da514b3d03a5931a1bac26e6792bd1"}, - {file = "matplotlib-3.7.1-cp39-cp39-macosx_10_12_universal2.whl", hash = "sha256:81a6b377ea444336538638d31fdb39af6be1a043ca5e343fe18d0f17e098770b"}, - {file = "matplotlib-3.7.1-cp39-cp39-macosx_10_12_x86_64.whl", hash = "sha256:28506a03bd7f3fe59cd3cd4ceb2a8d8a2b1db41afede01f66c42561b9be7b4b7"}, - {file = "matplotlib-3.7.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:8c587963b85ce41e0a8af53b9b2de8dddbf5ece4c34553f7bd9d066148dc719c"}, - {file = "matplotlib-3.7.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8bf26ade3ff0f27668989d98c8435ce9327d24cffb7f07d24ef609e33d582439"}, - {file = "matplotlib-3.7.1-cp39-cp39-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:def58098f96a05f90af7e92fd127d21a287068202aa43b2a93476170ebd99e87"}, - {file = "matplotlib-3.7.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f883a22a56a84dba3b588696a2b8a1ab0d2c3d41be53264115c71b0a942d8fdb"}, - {file = "matplotlib-3.7.1-cp39-cp39-win32.whl", hash = "sha256:4f99e1b234c30c1e9714610eb0c6d2f11809c9c78c984a613ae539ea2ad2eb4b"}, - {file = "matplotlib-3.7.1-cp39-cp39-win_amd64.whl", hash = "sha256:3ba2af245e36990facf67fde840a760128ddd71210b2ab6406e640188d69d136"}, - {file = "matplotlib-3.7.1-pp38-pypy38_pp73-macosx_10_12_x86_64.whl", hash = "sha256:3032884084f541163f295db8a6536e0abb0db464008fadca6c98aaf84ccf4717"}, - {file = "matplotlib-3.7.1-pp38-pypy38_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3a2cb34336110e0ed8bb4f650e817eed61fa064acbefeb3591f1b33e3a84fd96"}, - {file = "matplotlib-3.7.1-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b867e2f952ed592237a1828f027d332d8ee219ad722345b79a001f49df0936eb"}, - {file = "matplotlib-3.7.1-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:57bfb8c8ea253be947ccb2bc2d1bb3862c2bccc662ad1b4626e1f5e004557042"}, - {file = "matplotlib-3.7.1-pp39-pypy39_pp73-macosx_10_12_x86_64.whl", hash = "sha256:438196cdf5dc8d39b50a45cb6e3f6274edbcf2254f85fa9b895bf85851c3a613"}, - {file = "matplotlib-3.7.1-pp39-pypy39_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:21e9cff1a58d42e74d01153360de92b326708fb205250150018a52c70f43c290"}, - {file = "matplotlib-3.7.1-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:75d4725d70b7c03e082bbb8a34639ede17f333d7247f56caceb3801cb6ff703d"}, - {file = "matplotlib-3.7.1-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:97cc368a7268141afb5690760921765ed34867ffb9655dd325ed207af85c7529"}, - {file = "matplotlib-3.7.1.tar.gz", hash = "sha256:7b73305f25eab4541bd7ee0b96d87e53ae9c9f1823be5659b806cd85786fe882"}, -] - -[package.dependencies] -contourpy = ">=1.0.1" -cycler = ">=0.10" -fonttools = ">=4.22.0" -importlib-resources = {version = ">=3.2.0", markers = "python_version < \"3.10\""} -kiwisolver = ">=1.0.1" -numpy = ">=1.20" -packaging = ">=20.0" -pillow = ">=6.2.0" -pyparsing = ">=2.3.1" -python-dateutil = ">=2.7" - -[[package]] -name = "matplotlib-inline" -version = "0.1.6" -description = "Inline Matplotlib backend for Jupyter" -category = "dev" -optional = false -python-versions = ">=3.5" -files = [ - {file = "matplotlib-inline-0.1.6.tar.gz", hash = "sha256:f887e5f10ba98e8d2b150ddcf4702c1e5f8b3a20005eb0f74bfdbd360ee6f304"}, - {file = "matplotlib_inline-0.1.6-py3-none-any.whl", hash = "sha256:f1f41aab5328aa5aaea9b16d083b128102f8712542f819fe7e6a420ff581b311"}, -] - -[package.dependencies] -traitlets = "*" - -[[package]] -name = "mccabe" -version = "0.7.0" -description = "McCabe checker, plugin for flake8" -category = "dev" -optional = false -python-versions = ">=3.6" -files = [ - {file = "mccabe-0.7.0-py2.py3-none-any.whl", hash = "sha256:6c2d30ab6be0e4a46919781807b4f0d834ebdd6c6e3dca0bda5a15f863427b6e"}, - {file = "mccabe-0.7.0.tar.gz", hash = "sha256:348e0240c33b60bbdf4e523192ef919f28cb2c3d7d5c7794f74009290f236325"}, -] - -[[package]] -name = "mdit-py-plugins" -version = "0.3.5" -description = "Collection of plugins for markdown-it-py" -category = "dev" -optional = false -python-versions = ">=3.7" -files = [ - {file = "mdit-py-plugins-0.3.5.tar.gz", hash = "sha256:eee0adc7195e5827e17e02d2a258a2ba159944a0748f59c5099a4a27f78fcf6a"}, - {file = "mdit_py_plugins-0.3.5-py3-none-any.whl", hash = "sha256:ca9a0714ea59a24b2b044a1831f48d817dd0c817e84339f20e7889f392d77c4e"}, -] - -[package.dependencies] -markdown-it-py = ">=1.0.0,<3.0.0" - -[package.extras] -code-style = ["pre-commit"] -rtd = ["attrs", "myst-parser (>=0.16.1,<0.17.0)", "sphinx-book-theme (>=0.1.0,<0.2.0)"] -testing = ["coverage", "pytest", "pytest-cov", "pytest-regressions"] - -[[package]] -name = "mdurl" -version = "0.1.2" -description = "Markdown URL utilities" -category = "dev" -optional = false -python-versions = ">=3.7" -files = [ - {file = "mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8"}, - {file = "mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba"}, -] - -[[package]] -name = "mergedeep" -version = "1.3.4" -description = "A deep merge function for 🐍." -category = "dev" -optional = false -python-versions = ">=3.6" -files = [ - {file = "mergedeep-1.3.4-py3-none-any.whl", hash = "sha256:70775750742b25c0d8f36c55aed03d24c3384d17c951b3175d898bd778ef0307"}, - {file = "mergedeep-1.3.4.tar.gz", hash = "sha256:0096d52e9dad9939c3d975a774666af186eda617e6ca84df4c94dec30004f2a8"}, -] - -[[package]] -name = "mistune" -version = "2.0.5" -description = "A sane Markdown parser with useful plugins and renderers" -category = "dev" -optional = false -python-versions = "*" -files = [ - {file = "mistune-2.0.5-py2.py3-none-any.whl", hash = "sha256:bad7f5d431886fcbaf5f758118ecff70d31f75231b34024a1341120340a65ce8"}, - {file = "mistune-2.0.5.tar.gz", hash = "sha256:0246113cb2492db875c6be56974a7c893333bf26cd92891c85f63151cee09d34"}, -] - -[[package]] -name = "mkdocs" -version = "1.4.2" -description = "Project documentation with Markdown." -category = "dev" -optional = false -python-versions = ">=3.7" -files = [ - {file = "mkdocs-1.4.2-py3-none-any.whl", hash = "sha256:c8856a832c1e56702577023cd64cc5f84948280c1c0fcc6af4cd39006ea6aa8c"}, - {file = "mkdocs-1.4.2.tar.gz", hash = "sha256:8947af423a6d0facf41ea1195b8e1e8c85ad94ac95ae307fe11232e0424b11c5"}, -] - -[package.dependencies] -click = ">=7.0" -colorama = {version = ">=0.4", markers = "platform_system == \"Windows\""} -ghp-import = ">=1.0" -importlib-metadata = {version = ">=4.3", markers = "python_version < \"3.10\""} -jinja2 = ">=2.11.1" -markdown = ">=3.2.1,<3.4" -mergedeep = ">=1.3.4" -packaging = ">=20.5" -pyyaml = ">=5.1" -pyyaml-env-tag = ">=0.1" -watchdog = ">=2.0" - -[package.extras] -i18n = ["babel (>=2.9.0)"] -min-versions = ["babel (==2.9.0)", "click (==7.0)", "colorama (==0.4)", "ghp-import (==1.0)", "importlib-metadata (==4.3)", "jinja2 (==2.11.1)", "markdown (==3.2.1)", "markupsafe (==2.0.1)", "mergedeep (==1.3.4)", "packaging (==20.5)", "pyyaml (==5.1)", "pyyaml-env-tag (==0.1)", "typing-extensions (==3.10)", "watchdog (==2.0)"] - -[[package]] -name = "mkdocs-autorefs" -version = "0.4.1" -description = "Automatically link across pages in MkDocs." -category = "dev" -optional = false -python-versions = ">=3.7" -files = [ - {file = "mkdocs-autorefs-0.4.1.tar.gz", hash = "sha256:70748a7bd025f9ecd6d6feeba8ba63f8e891a1af55f48e366d6d6e78493aba84"}, - {file = "mkdocs_autorefs-0.4.1-py3-none-any.whl", hash = "sha256:a2248a9501b29dc0cc8ba4c09f4f47ff121945f6ce33d760f145d6f89d313f5b"}, -] - -[package.dependencies] -Markdown = ">=3.3" -mkdocs = ">=1.1" - -[[package]] -name = "mkdocs-gen-files" -version = "0.5.0" -description = "MkDocs plugin to programmatically generate documentation pages during the build" -category = "dev" -optional = false -python-versions = ">=3.7" -files = [ - {file = "mkdocs_gen_files-0.5.0-py3-none-any.whl", hash = "sha256:7ac060096f3f40bd19039e7277dd3050be9a453c8ac578645844d4d91d7978ea"}, - {file = "mkdocs_gen_files-0.5.0.tar.gz", hash = "sha256:4c7cf256b5d67062a788f6b1d035e157fc1a9498c2399be9af5257d4ff4d19bc"}, -] - -[package.dependencies] -mkdocs = ">=1.0.3" - -[[package]] -name = "mkdocs-jupyter" -version = "0.24.1" -description = "Use Jupyter in mkdocs websites" -category = "dev" -optional = false -python-versions = ">=3.7" -files = [ - {file = "mkdocs_jupyter-0.24.1-py3-none-any.whl", hash = "sha256:759833c7d1528ae2d6337342786be7bc1e2235b0b98e9326427d4cf8d4eebee0"}, - {file = "mkdocs_jupyter-0.24.1.tar.gz", hash = "sha256:9677037fb7e931268f3df7599fc0828c261247df3d1575bced320ba8b7d1d46d"}, -] - -[package.dependencies] -jupytext = ">1.13.8,<2" -mkdocs = ">=1.4.0,<2" -mkdocs-material = ">9.0.0" -nbconvert = ">=7.2.9,<8" -pygments = ">2.12.0" - -[package.extras] -test = ["pytest", "pytest-cov"] - -[[package]] -name = "mkdocs-literate-nav" -version = "0.6.0" -description = "MkDocs plugin to specify the navigation in Markdown instead of YAML" -category = "dev" -optional = false -python-versions = ">=3.7" -files = [ - {file = "mkdocs_literate_nav-0.6.0-py3-none-any.whl", hash = "sha256:8c1b84714e5974da5e44e011ec0069275ae7647270c13a679662cf6ffce675a4"}, - {file = "mkdocs_literate_nav-0.6.0.tar.gz", hash = "sha256:81ccbea18163ae8e10bd0bd39237fe70c32a1f2dff6c170779f5d52dd98a0470"}, -] - -[package.dependencies] -mkdocs = ">=1.0.3" - -[[package]] -name = "mkdocs-material" -version = "9.1.14" -description = "Documentation that simply works" -category = "dev" -optional = false -python-versions = ">=3.7" -files = [ - {file = "mkdocs_material-9.1.14-py3-none-any.whl", hash = "sha256:b56a9f955ed32d38333715cbbf68ce38f683bf38610c65094fa4ef2db9f08bcd"}, - {file = "mkdocs_material-9.1.14.tar.gz", hash = "sha256:1ae74cc5464ef2f64574d4884512efed7f4db386fb9bc6af20fd427d7a702f49"}, -] - -[package.dependencies] -colorama = ">=0.4" -jinja2 = ">=3.0" -markdown = ">=3.2" -mkdocs = ">=1.4.2" -mkdocs-material-extensions = ">=1.1" -pygments = ">=2.14" -pymdown-extensions = ">=9.9.1" -regex = ">=2022.4.24" -requests = ">=2.26" - -[[package]] -name = "mkdocs-material-extensions" -version = "1.1.1" -description = "Extension pack for Python Markdown and MkDocs Material." -category = "dev" -optional = false -python-versions = ">=3.7" -files = [ - {file = "mkdocs_material_extensions-1.1.1-py3-none-any.whl", hash = "sha256:e41d9f38e4798b6617ad98ca8f7f1157b1e4385ac1459ca1e4ea219b556df945"}, - {file = "mkdocs_material_extensions-1.1.1.tar.gz", hash = "sha256:9c003da71e2cc2493d910237448c672e00cefc800d3d6ae93d2fc69979e3bd93"}, -] - -[[package]] -name = "mkdocs-section-index" -version = "0.3.5" -description = "MkDocs plugin to allow clickable sections that lead to an index page" -category = "dev" -optional = false -python-versions = ">=3.7" -files = [ - {file = "mkdocs_section_index-0.3.5-py3-none-any.whl", hash = "sha256:1f6359287b0a823d6297cf1cb6c0a49ed75851d0d1cea8b425b207a45ce10141"}, - {file = "mkdocs_section_index-0.3.5.tar.gz", hash = "sha256:fa8b1ce0649326b1873c6460c1df2bb0c4825fd21e3dd416f13ec212d31edf12"}, -] - -[package.dependencies] -mkdocs = ">=1.0.3" - -[[package]] -name = "mkdocstrings" -version = "0.21.0" -description = "Automatic documentation from sources, for MkDocs." -category = "dev" -optional = false -python-versions = ">=3.7" -files = [ - {file = "mkdocstrings-0.21.0-py3-none-any.whl", hash = "sha256:05c52573366f0a32536f7bf0258f2a8ad180836058bb024b252b8a61a25452b3"}, - {file = "mkdocstrings-0.21.0.tar.gz", hash = "sha256:df7399cec11bdc12ece9a370a6c37bac70ea0a07f479c051d0c82b07a38a3220"}, -] - -[package.dependencies] -Jinja2 = ">=2.11.1" -Markdown = ">=3.3" -MarkupSafe = ">=1.1" -mkdocs = ">=1.2" -mkdocs-autorefs = ">=0.3.1" -pymdown-extensions = ">=6.3" - -[package.extras] -crystal = ["mkdocstrings-crystal (>=0.3.4)"] -python = ["mkdocstrings-python (>=0.5.2)"] -python-legacy = ["mkdocstrings-python-legacy (>=0.2.1)"] - -[[package]] -name = "mkdocstrings-python" -version = "1.1.0" -description = "A Python handler for mkdocstrings." -category = "dev" -optional = false -python-versions = ">=3.7" -files = [ - {file = "mkdocstrings_python-1.1.0-py3-none-any.whl", hash = "sha256:4e9a9d728e6ba742ecbd7379f5091f3a32b16d723881963bb457b2149656e167"}, - {file = "mkdocstrings_python-1.1.0.tar.gz", hash = "sha256:00cca5e47bf63eb2aece08b9887421b6828bdb939a13a481e4e8b495569e8101"}, -] - -[package.dependencies] -griffe = ">=0.24" -mkdocstrings = ">=0.20" - -[[package]] -name = "mpmath" -version = "1.3.0" -description = "Python library for arbitrary-precision floating-point arithmetic" -category = "main" -optional = false -python-versions = "*" -files = [ - {file = "mpmath-1.3.0-py3-none-any.whl", hash = "sha256:a0b2b9fe80bbcd81a6647ff13108738cfb482d481d826cc0e02f5b35e5c88d2c"}, - {file = "mpmath-1.3.0.tar.gz", hash = "sha256:7a28eb2a9774d00c7bc92411c19a89209d5da7c4c9a9e227be8330a23a25b91f"}, -] - -[package.extras] -develop = ["codecov", "pycodestyle", "pytest (>=4.6)", "pytest-cov", "wheel"] -docs = ["sphinx"] -gmpy = ["gmpy2 (>=2.1.0a4)"] -tests = ["pytest (>=4.6)"] - -[[package]] -name = "nbclassic" -version = "0.5.5" -description = "Jupyter Notebook as a Jupyter Server extension." -category = "dev" -optional = false -python-versions = ">=3.7" -files = [ - {file = "nbclassic-0.5.5-py3-none-any.whl", hash = "sha256:47791b04dbcb89bf7fde910a3d848fd4793a4248a8936202453631a87da37d51"}, - {file = "nbclassic-0.5.5.tar.gz", hash = "sha256:d2c91adc7909b0270c73e3e253d3687a6704b4f0a94bc156a37c85eba09f4d37"}, -] - -[package.dependencies] -argon2-cffi = "*" -ipykernel = "*" -ipython-genutils = "*" -jinja2 = "*" -jupyter-client = ">=6.1.1" -jupyter-core = ">=4.6.1" -jupyter-server = ">=1.8" -nbconvert = ">=5" -nbformat = "*" -nest-asyncio = ">=1.5" -notebook-shim = ">=0.1.0" -prometheus-client = "*" -pyzmq = ">=17" -Send2Trash = ">=1.8.0" -terminado = ">=0.8.3" -tornado = ">=6.1" -traitlets = ">=4.2.1" - -[package.extras] -docs = ["myst-parser", "nbsphinx", "sphinx", "sphinx-rtd-theme", "sphinxcontrib-github-alt"] -json-logging = ["json-logging"] -test = ["coverage", "nbval", "pytest", "pytest-cov", "pytest-jupyter", "pytest-playwright", "pytest-tornasync", "requests", "requests-unixsocket", "testpath"] - -[[package]] -name = "nbclient" -version = "0.7.3" -description = "A client library for executing notebooks. Formerly nbconvert's ExecutePreprocessor." -category = "dev" -optional = false -python-versions = ">=3.7.0" -files = [ - {file = "nbclient-0.7.3-py3-none-any.whl", hash = "sha256:8fa96f7e36693d5e83408f5e840f113c14a45c279befe609904dbe05dad646d1"}, - {file = "nbclient-0.7.3.tar.gz", hash = "sha256:26e41c6dca4d76701988bc34f64e1bfc2413ae6d368f13d7b5ac407efb08c755"}, -] - -[package.dependencies] -jupyter-client = ">=6.1.12" -jupyter-core = ">=4.12,<5.0.0 || >=5.1.0" -nbformat = ">=5.1" -traitlets = ">=5.3" - -[package.extras] -dev = ["pre-commit"] -docs = ["autodoc-traits", "mock", "moto", "myst-parser", "nbclient[test]", "sphinx (>=1.7)", "sphinx-book-theme", "sphinxcontrib-spelling"] -test = ["flaky", "ipykernel", "ipython", "ipywidgets", "nbconvert (>=7.0.0)", "pytest (>=7.0)", "pytest-asyncio", "pytest-cov (>=4.0)", "testpath", "xmltodict"] - -[[package]] -name = "nbconvert" -version = "7.3.0" -description = "Converting Jupyter Notebooks" -category = "dev" -optional = false -python-versions = ">=3.7" -files = [ - {file = "nbconvert-7.3.0-py3-none-any.whl", hash = "sha256:8983a83d0b083d56b076019f0a319f63bc16af70c9372892b86a0aab0a264b1d"}, - {file = "nbconvert-7.3.0.tar.gz", hash = "sha256:b970a13aba97529c223d805dd0706c2fe04dfc05e250ad4e6f7ae33daf6fede1"}, -] - -[package.dependencies] -beautifulsoup4 = "*" -bleach = "*" -defusedxml = "*" -importlib-metadata = {version = ">=3.6", markers = "python_version < \"3.10\""} -jinja2 = ">=3.0" -jupyter-core = ">=4.7" -jupyterlab-pygments = "*" -markupsafe = ">=2.0" -mistune = ">=2.0.3,<3" -nbclient = ">=0.5.0" -nbformat = ">=5.1" -packaging = "*" -pandocfilters = ">=1.4.1" -pygments = ">=2.4.1" -tinycss2 = "*" -traitlets = ">=5.0" - -[package.extras] -all = ["nbconvert[docs,qtpdf,serve,test,webpdf]"] -docs = ["ipykernel", "ipython", "myst-parser", "nbsphinx (>=0.2.12)", "pydata-sphinx-theme", "sphinx (==5.0.2)", "sphinxcontrib-spelling"] -qtpdf = ["nbconvert[qtpng]"] -qtpng = ["pyqtwebengine (>=5.15)"] -serve = ["tornado (>=6.1)"] -test = ["ipykernel", "ipywidgets (>=7)", "pre-commit", "pytest", "pytest-dependency"] -webpdf = ["pyppeteer (>=1,<1.1)"] - -[[package]] -name = "nbformat" -version = "5.8.0" -description = "The Jupyter Notebook format" -category = "dev" -optional = false -python-versions = ">=3.7" -files = [ - {file = "nbformat-5.8.0-py3-none-any.whl", hash = "sha256:d910082bd3e0bffcf07eabf3683ed7dda0727a326c446eeb2922abe102e65162"}, - {file = "nbformat-5.8.0.tar.gz", hash = "sha256:46dac64c781f1c34dfd8acba16547024110348f9fc7eab0f31981c2a3dc48d1f"}, -] - -[package.dependencies] -fastjsonschema = "*" -jsonschema = ">=2.6" -jupyter-core = "*" -traitlets = ">=5.1" - -[package.extras] -docs = ["myst-parser", "pydata-sphinx-theme", "sphinx", "sphinxcontrib-github-alt", "sphinxcontrib-spelling"] -test = ["pep440", "pre-commit", "pytest", "testpath"] - -[[package]] -name = "nest-asyncio" -version = "1.5.6" -description = "Patch asyncio to allow nested event loops" -category = "dev" -optional = false -python-versions = ">=3.5" -files = [ - {file = "nest_asyncio-1.5.6-py3-none-any.whl", hash = "sha256:b9a953fb40dceaa587d109609098db21900182b16440652454a146cffb06e8b8"}, - {file = "nest_asyncio-1.5.6.tar.gz", hash = "sha256:d267cc1ff794403f7df692964d1d2a3fa9418ffea2a3f6859a439ff482fef290"}, -] - -[[package]] -name = "networkx" -version = "3.1" -description = "Python package for creating and manipulating graphs and networks" -category = "main" -optional = false -python-versions = ">=3.8" -files = [ - {file = "networkx-3.1-py3-none-any.whl", hash = "sha256:4f33f68cb2afcf86f28a45f43efc27a9386b535d567d2127f8f61d51dec58d36"}, - {file = "networkx-3.1.tar.gz", hash = "sha256:de346335408f84de0eada6ff9fafafff9bcda11f0a0dfaa931133debb146ab61"}, -] - -[package.extras] -default = ["matplotlib (>=3.4)", "numpy (>=1.20)", "pandas (>=1.3)", "scipy (>=1.8)"] -developer = ["mypy (>=1.1)", "pre-commit (>=3.2)"] -doc = ["nb2plots (>=0.6)", "numpydoc (>=1.5)", "pillow (>=9.4)", "pydata-sphinx-theme (>=0.13)", "sphinx (>=6.1)", "sphinx-gallery (>=0.12)", "texext (>=0.6.7)"] -extra = ["lxml (>=4.6)", "pydot (>=1.4.2)", "pygraphviz (>=1.10)", "sympy (>=1.10)"] -test = ["codecov (>=2.1)", "pytest (>=7.2)", "pytest-cov (>=4.0)"] - -[[package]] -name = "nodeenv" -version = "1.7.0" -description = "Node.js virtual environment builder" -category = "dev" -optional = false -python-versions = ">=2.7,!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,!=3.6.*" -files = [ - {file = "nodeenv-1.7.0-py2.py3-none-any.whl", hash = "sha256:27083a7b96a25f2f5e1d8cb4b6317ee8aeda3bdd121394e5ac54e498028a042e"}, - {file = "nodeenv-1.7.0.tar.gz", hash = "sha256:e0e7f7dfb85fc5394c6fe1e8fa98131a2473e04311a45afb6508f7cf1836fa2b"}, -] - -[package.dependencies] -setuptools = "*" - -[[package]] -name = "notebook" -version = "6.5.3" -description = "A web-based notebook environment for interactive computing" -category = "dev" -optional = false -python-versions = ">=3.7" -files = [ - {file = "notebook-6.5.3-py3-none-any.whl", hash = "sha256:50a334ad9d60b30cb759405168ef6fc3d60350ab5439fb1631544bb09dcb2cce"}, - {file = "notebook-6.5.3.tar.gz", hash = "sha256:b12bee3292211d85dd7e588a790ddce30cb3e8fbcfa1e803522a207f60819e05"}, -] - -[package.dependencies] -argon2-cffi = "*" -ipykernel = "*" -ipython-genutils = "*" -jinja2 = "*" -jupyter-client = ">=5.3.4" -jupyter-core = ">=4.6.1" -nbclassic = ">=0.4.7" -nbconvert = ">=5" -nbformat = "*" -nest-asyncio = ">=1.5" -prometheus-client = "*" -pyzmq = ">=17" -Send2Trash = ">=1.8.0" -terminado = ">=0.8.3" -tornado = ">=6.1" -traitlets = ">=4.2.1" - -[package.extras] -docs = ["myst-parser", "nbsphinx", "sphinx", "sphinx-rtd-theme", "sphinxcontrib-github-alt"] -json-logging = ["json-logging"] -test = ["coverage", "nbval", "pytest", "pytest-cov", "requests", "requests-unixsocket", "selenium (==4.1.5)", "testpath"] - -[[package]] -name = "notebook-shim" -version = "0.2.2" -description = "A shim layer for notebook traits and config" -category = "dev" -optional = false -python-versions = ">=3.7" -files = [ - {file = "notebook_shim-0.2.2-py3-none-any.whl", hash = "sha256:9c6c30f74c4fbea6fce55c1be58e7fd0409b1c681b075dcedceb005db5026949"}, - {file = "notebook_shim-0.2.2.tar.gz", hash = "sha256:090e0baf9a5582ff59b607af523ca2db68ff216da0c69956b62cab2ef4fc9c3f"}, -] - -[package.dependencies] -jupyter-server = ">=1.8,<3" - -[package.extras] -test = ["pytest", "pytest-console-scripts", "pytest-tornasync"] - -[[package]] -name = "numpy" -version = "1.24.3" -description = "Fundamental package for array computing in Python" -category = "main" -optional = false -python-versions = ">=3.8" -files = [ - {file = "numpy-1.24.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:3c1104d3c036fb81ab923f507536daedc718d0ad5a8707c6061cdfd6d184e570"}, - {file = "numpy-1.24.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:202de8f38fc4a45a3eea4b63e2f376e5f2dc64ef0fa692838e31a808520efaf7"}, - {file = "numpy-1.24.3-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8535303847b89aa6b0f00aa1dc62867b5a32923e4d1681a35b5eef2d9591a463"}, - {file = "numpy-1.24.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2d926b52ba1367f9acb76b0df6ed21f0b16a1ad87c6720a1121674e5cf63e2b6"}, - {file = "numpy-1.24.3-cp310-cp310-win32.whl", hash = "sha256:f21c442fdd2805e91799fbe044a7b999b8571bb0ab0f7850d0cb9641a687092b"}, - {file = "numpy-1.24.3-cp310-cp310-win_amd64.whl", hash = "sha256:ab5f23af8c16022663a652d3b25dcdc272ac3f83c3af4c02eb8b824e6b3ab9d7"}, - {file = "numpy-1.24.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:9a7721ec204d3a237225db3e194c25268faf92e19338a35f3a224469cb6039a3"}, - {file = "numpy-1.24.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:d6cc757de514c00b24ae8cf5c876af2a7c3df189028d68c0cb4eaa9cd5afc2bf"}, - {file = "numpy-1.24.3-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:76e3f4e85fc5d4fd311f6e9b794d0c00e7002ec122be271f2019d63376f1d385"}, - {file = "numpy-1.24.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a1d3c026f57ceaad42f8231305d4653d5f05dc6332a730ae5c0bea3513de0950"}, - {file = "numpy-1.24.3-cp311-cp311-win32.whl", hash = "sha256:c91c4afd8abc3908e00a44b2672718905b8611503f7ff87390cc0ac3423fb096"}, - {file = "numpy-1.24.3-cp311-cp311-win_amd64.whl", hash = "sha256:5342cf6aad47943286afa6f1609cad9b4266a05e7f2ec408e2cf7aea7ff69d80"}, - {file = "numpy-1.24.3-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:7776ea65423ca6a15255ba1872d82d207bd1e09f6d0894ee4a64678dd2204078"}, - {file = "numpy-1.24.3-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:ae8d0be48d1b6ed82588934aaaa179875e7dc4f3d84da18d7eae6eb3f06c242c"}, - {file = "numpy-1.24.3-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ecde0f8adef7dfdec993fd54b0f78183051b6580f606111a6d789cd14c61ea0c"}, - {file = "numpy-1.24.3-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4749e053a29364d3452c034827102ee100986903263e89884922ef01a0a6fd2f"}, - {file = "numpy-1.24.3-cp38-cp38-win32.whl", hash = "sha256:d933fabd8f6a319e8530d0de4fcc2e6a61917e0b0c271fded460032db42a0fe4"}, - {file = "numpy-1.24.3-cp38-cp38-win_amd64.whl", hash = "sha256:56e48aec79ae238f6e4395886b5eaed058abb7231fb3361ddd7bfdf4eed54289"}, - {file = "numpy-1.24.3-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:4719d5aefb5189f50887773699eaf94e7d1e02bf36c1a9d353d9f46703758ca4"}, - {file = "numpy-1.24.3-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:0ec87a7084caa559c36e0a2309e4ecb1baa03b687201d0a847c8b0ed476a7187"}, - {file = "numpy-1.24.3-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ea8282b9bcfe2b5e7d491d0bf7f3e2da29700cec05b49e64d6246923329f2b02"}, - {file = "numpy-1.24.3-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:210461d87fb02a84ef243cac5e814aad2b7f4be953b32cb53327bb49fd77fbb4"}, - {file = "numpy-1.24.3-cp39-cp39-win32.whl", hash = "sha256:784c6da1a07818491b0ffd63c6bbe5a33deaa0e25a20e1b3ea20cf0e43f8046c"}, - {file = "numpy-1.24.3-cp39-cp39-win_amd64.whl", hash = "sha256:d5036197ecae68d7f491fcdb4df90082b0d4960ca6599ba2659957aafced7c17"}, - {file = "numpy-1.24.3-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:352ee00c7f8387b44d19f4cada524586f07379c0d49270f87233983bc5087ca0"}, - {file = "numpy-1.24.3-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1a7d6acc2e7524c9955e5c903160aa4ea083736fde7e91276b0e5d98e6332812"}, - {file = "numpy-1.24.3-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:35400e6a8d102fd07c71ed7dcadd9eb62ee9a6e84ec159bd48c28235bbb0f8e4"}, - {file = "numpy-1.24.3.tar.gz", hash = "sha256:ab344f1bf21f140adab8e47fdbc7c35a477dc01408791f8ba00d018dd0bc5155"}, -] - -[[package]] -name = "nvidia-cublas-cu11" -version = "11.10.3.66" -description = "CUBLAS native runtime libraries" -category = "main" -optional = false -python-versions = ">=3" -files = [ - {file = "nvidia_cublas_cu11-11.10.3.66-py3-none-manylinux1_x86_64.whl", hash = "sha256:d32e4d75f94ddfb93ea0a5dda08389bcc65d8916a25cb9f37ac89edaeed3bded"}, - {file = "nvidia_cublas_cu11-11.10.3.66-py3-none-win_amd64.whl", hash = "sha256:8ac17ba6ade3ed56ab898a036f9ae0756f1e81052a317bf98f8c6d18dc3ae49e"}, -] - -[package.dependencies] -setuptools = "*" -wheel = "*" - -[[package]] -name = "nvidia-cuda-cupti-cu11" -version = "11.7.101" -description = "CUDA profiling tools runtime libs." -category = "main" -optional = false -python-versions = ">=3" -files = [ - {file = "nvidia_cuda_cupti_cu11-11.7.101-py3-none-manylinux1_x86_64.whl", hash = "sha256:e0cfd9854e1f2edaa36ca20d21cd0bdd5dcfca4e3b9e130a082e05b33b6c5895"}, - {file = "nvidia_cuda_cupti_cu11-11.7.101-py3-none-win_amd64.whl", hash = "sha256:7cc5b8f91ae5e1389c3c0ad8866b3b016a175e827ea8f162a672990a402ab2b0"}, -] - -[package.dependencies] -setuptools = "*" -wheel = "*" - -[[package]] -name = "nvidia-cuda-nvrtc-cu11" -version = "11.7.99" -description = "NVRTC native runtime libraries" -category = "main" -optional = false -python-versions = ">=3" -files = [ - {file = "nvidia_cuda_nvrtc_cu11-11.7.99-2-py3-none-manylinux1_x86_64.whl", hash = "sha256:9f1562822ea264b7e34ed5930567e89242d266448e936b85bc97a3370feabb03"}, - {file = "nvidia_cuda_nvrtc_cu11-11.7.99-py3-none-manylinux1_x86_64.whl", hash = "sha256:f7d9610d9b7c331fa0da2d1b2858a4a8315e6d49765091d28711c8946e7425e7"}, - {file = "nvidia_cuda_nvrtc_cu11-11.7.99-py3-none-win_amd64.whl", hash = "sha256:f2effeb1309bdd1b3854fc9b17eaf997808f8b25968ce0c7070945c4265d64a3"}, -] - -[package.dependencies] -setuptools = "*" -wheel = "*" - -[[package]] -name = "nvidia-cuda-runtime-cu11" -version = "11.7.99" -description = "CUDA Runtime native Libraries" -category = "main" -optional = false -python-versions = ">=3" -files = [ - {file = "nvidia_cuda_runtime_cu11-11.7.99-py3-none-manylinux1_x86_64.whl", hash = "sha256:cc768314ae58d2641f07eac350f40f99dcb35719c4faff4bc458a7cd2b119e31"}, - {file = "nvidia_cuda_runtime_cu11-11.7.99-py3-none-win_amd64.whl", hash = "sha256:bc77fa59a7679310df9d5c70ab13c4e34c64ae2124dd1efd7e5474b71be125c7"}, -] - -[package.dependencies] -setuptools = "*" -wheel = "*" - -[[package]] -name = "nvidia-cudnn-cu11" -version = "8.5.0.96" -description = "cuDNN runtime libraries" -category = "main" -optional = false -python-versions = ">=3" -files = [ - {file = "nvidia_cudnn_cu11-8.5.0.96-2-py3-none-manylinux1_x86_64.whl", hash = "sha256:402f40adfc6f418f9dae9ab402e773cfed9beae52333f6d86ae3107a1b9527e7"}, - {file = "nvidia_cudnn_cu11-8.5.0.96-py3-none-manylinux1_x86_64.whl", hash = "sha256:71f8111eb830879ff2836db3cccf03bbd735df9b0d17cd93761732ac50a8a108"}, -] - -[package.dependencies] -setuptools = "*" -wheel = "*" - -[[package]] -name = "nvidia-cufft-cu11" -version = "10.9.0.58" -description = "CUFFT native runtime libraries" -category = "main" -optional = false -python-versions = ">=3" -files = [ - {file = "nvidia_cufft_cu11-10.9.0.58-py3-none-manylinux1_x86_64.whl", hash = "sha256:222f9da70c80384632fd6035e4c3f16762d64ea7a843829cb278f98b3cb7dd81"}, - {file = "nvidia_cufft_cu11-10.9.0.58-py3-none-win_amd64.whl", hash = "sha256:c4d316f17c745ec9c728e30409612eaf77a8404c3733cdf6c9c1569634d1ca03"}, -] - -[[package]] -name = "nvidia-curand-cu11" -version = "10.2.10.91" -description = "CURAND native runtime libraries" -category = "main" -optional = false -python-versions = ">=3" -files = [ - {file = "nvidia_curand_cu11-10.2.10.91-py3-none-manylinux1_x86_64.whl", hash = "sha256:eecb269c970fa599a2660c9232fa46aaccbf90d9170b96c462e13bcb4d129e2c"}, - {file = "nvidia_curand_cu11-10.2.10.91-py3-none-win_amd64.whl", hash = "sha256:f742052af0e1e75523bde18895a9ed016ecf1e5aa0ecddfcc3658fd11a1ff417"}, -] - -[package.dependencies] -setuptools = "*" -wheel = "*" - -[[package]] -name = "nvidia-cusolver-cu11" -version = "11.4.0.1" -description = "CUDA solver native runtime libraries" -category = "main" -optional = false -python-versions = ">=3" -files = [ - {file = "nvidia_cusolver_cu11-11.4.0.1-2-py3-none-manylinux1_x86_64.whl", hash = "sha256:72fa7261d755ed55c0074960df5904b65e2326f7adce364cbe4945063c1be412"}, - {file = "nvidia_cusolver_cu11-11.4.0.1-py3-none-manylinux1_x86_64.whl", hash = "sha256:700b781bfefd57d161443aff9ace1878584b93e0b2cfef3d6e9296d96febbf99"}, - {file = "nvidia_cusolver_cu11-11.4.0.1-py3-none-win_amd64.whl", hash = "sha256:00f70b256add65f8c1eb3b6a65308795a93e7740f6df9e273eccbba770d370c4"}, -] - -[package.dependencies] -setuptools = "*" -wheel = "*" - -[[package]] -name = "nvidia-cusparse-cu11" -version = "11.7.4.91" -description = "CUSPARSE native runtime libraries" -category = "main" -optional = false -python-versions = ">=3" -files = [ - {file = "nvidia_cusparse_cu11-11.7.4.91-py3-none-manylinux1_x86_64.whl", hash = "sha256:a3389de714db63321aa11fbec3919271f415ef19fda58aed7f2ede488c32733d"}, - {file = "nvidia_cusparse_cu11-11.7.4.91-py3-none-win_amd64.whl", hash = "sha256:304a01599534f5186a8ed1c3756879282c72c118bc77dd890dc1ff868cad25b9"}, -] - -[package.dependencies] -setuptools = "*" -wheel = "*" - -[[package]] -name = "nvidia-nccl-cu11" -version = "2.14.3" -description = "NVIDIA Collective Communication Library (NCCL) Runtime" -category = "main" -optional = false -python-versions = ">=3" -files = [ - {file = "nvidia_nccl_cu11-2.14.3-py3-none-manylinux1_x86_64.whl", hash = "sha256:5e5534257d1284b8e825bc3a182c6f06acd6eb405e9f89d49340e98cd8f136eb"}, -] - -[[package]] -name = "nvidia-nvtx-cu11" -version = "11.7.91" -description = "NVIDIA Tools Extension" -category = "main" -optional = false -python-versions = ">=3" -files = [ - {file = "nvidia_nvtx_cu11-11.7.91-py3-none-manylinux1_x86_64.whl", hash = "sha256:b22c64eee426a62fc00952b507d6d29cf62b4c9df7a480fcc417e540e05fd5ac"}, - {file = "nvidia_nvtx_cu11-11.7.91-py3-none-win_amd64.whl", hash = "sha256:dfd7fcb2a91742513027d63a26b757f38dd8b07fecac282c4d132a9d373ff064"}, -] - -[package.dependencies] -setuptools = "*" -wheel = "*" - -[[package]] -name = "packaging" -version = "23.0" -description = "Core utilities for Python packages" -category = "main" -optional = false -python-versions = ">=3.7" -files = [ - {file = "packaging-23.0-py3-none-any.whl", hash = "sha256:714ac14496c3e68c99c29b00845f7a2b85f3bb6f1078fd9f72fd20f0570002b2"}, - {file = "packaging-23.0.tar.gz", hash = "sha256:b6ad297f8907de0fa2fe1ccbd26fdaf387f5f47c7275fedf8cce89f99446cf97"}, -] - -[[package]] -name = "pandas" -version = "2.0.2" -description = "Powerful data structures for data analysis, time series, and statistics" -category = "main" -optional = false -python-versions = ">=3.8" -files = [ - {file = "pandas-2.0.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:9ebb9f1c22ddb828e7fd017ea265a59d80461d5a79154b49a4207bd17514d122"}, - {file = "pandas-2.0.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:1eb09a242184092f424b2edd06eb2b99d06dc07eeddff9929e8667d4ed44e181"}, - {file = "pandas-2.0.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c7319b6e68de14e6209460f72a8d1ef13c09fb3d3ef6c37c1e65b35d50b5c145"}, - {file = "pandas-2.0.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dd46bde7309088481b1cf9c58e3f0e204b9ff9e3244f441accd220dd3365ce7c"}, - {file = "pandas-2.0.2-cp310-cp310-win32.whl", hash = "sha256:51a93d422fbb1bd04b67639ba4b5368dffc26923f3ea32a275d2cc450f1d1c86"}, - {file = "pandas-2.0.2-cp310-cp310-win_amd64.whl", hash = "sha256:66d00300f188fa5de73f92d5725ced162488f6dc6ad4cecfe4144ca29debe3b8"}, - {file = "pandas-2.0.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:02755de164da6827764ceb3bbc5f64b35cb12394b1024fdf88704d0fa06e0e2f"}, - {file = "pandas-2.0.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:0a1e0576611641acde15c2322228d138258f236d14b749ad9af498ab69089e2d"}, - {file = "pandas-2.0.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a6b5f14cd24a2ed06e14255ff40fe2ea0cfaef79a8dd68069b7ace74bd6acbba"}, - {file = "pandas-2.0.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:50e451932b3011b61d2961b4185382c92cc8c6ee4658dcd4f320687bb2d000ee"}, - {file = "pandas-2.0.2-cp311-cp311-win32.whl", hash = "sha256:7b21cb72958fc49ad757685db1919021d99650d7aaba676576c9e88d3889d456"}, - {file = "pandas-2.0.2-cp311-cp311-win_amd64.whl", hash = "sha256:c4af689352c4fe3d75b2834933ee9d0ccdbf5d7a8a7264f0ce9524e877820c08"}, - {file = "pandas-2.0.2-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:69167693cb8f9b3fc060956a5d0a0a8dbfed5f980d9fd2c306fb5b9c855c814c"}, - {file = "pandas-2.0.2-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:30a89d0fec4263ccbf96f68592fd668939481854d2ff9da709d32a047689393b"}, - {file = "pandas-2.0.2-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a18e5c72b989ff0f7197707ceddc99828320d0ca22ab50dd1b9e37db45b010c0"}, - {file = "pandas-2.0.2-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7376e13d28eb16752c398ca1d36ccfe52bf7e887067af9a0474de6331dd948d2"}, - {file = "pandas-2.0.2-cp38-cp38-win32.whl", hash = "sha256:6d6d10c2142d11d40d6e6c0a190b1f89f525bcf85564707e31b0a39e3b398e08"}, - {file = "pandas-2.0.2-cp38-cp38-win_amd64.whl", hash = "sha256:e69140bc2d29a8556f55445c15f5794490852af3de0f609a24003ef174528b79"}, - {file = "pandas-2.0.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:b42b120458636a981077cfcfa8568c031b3e8709701315e2bfa866324a83efa8"}, - {file = "pandas-2.0.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:f908a77cbeef9bbd646bd4b81214cbef9ac3dda4181d5092a4aa9797d1bc7774"}, - {file = "pandas-2.0.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:713f2f70abcdade1ddd68fc91577cb090b3544b07ceba78a12f799355a13ee44"}, - {file = "pandas-2.0.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cf3f0c361a4270185baa89ec7ab92ecaa355fe783791457077473f974f654df5"}, - {file = "pandas-2.0.2-cp39-cp39-win32.whl", hash = "sha256:598e9020d85a8cdbaa1815eb325a91cfff2bb2b23c1442549b8a3668e36f0f77"}, - {file = "pandas-2.0.2-cp39-cp39-win_amd64.whl", hash = "sha256:77550c8909ebc23e56a89f91b40ad01b50c42cfbfab49b3393694a50549295ea"}, - {file = "pandas-2.0.2.tar.gz", hash = "sha256:dd5476b6c3fe410ee95926873f377b856dbc4e81a9c605a0dc05aaccc6a7c6c6"}, -] - -[package.dependencies] -numpy = [ - {version = ">=1.20.3", markers = "python_version < \"3.10\""}, - {version = ">=1.21.0", markers = "python_version >= \"3.10\""}, -] -python-dateutil = ">=2.8.2" -pytz = ">=2020.1" -tzdata = ">=2022.1" - -[package.extras] -all = ["PyQt5 (>=5.15.1)", "SQLAlchemy (>=1.4.16)", "beautifulsoup4 (>=4.9.3)", "bottleneck (>=1.3.2)", "brotlipy (>=0.7.0)", "fastparquet (>=0.6.3)", "fsspec (>=2021.07.0)", "gcsfs (>=2021.07.0)", "html5lib (>=1.1)", "hypothesis (>=6.34.2)", "jinja2 (>=3.0.0)", "lxml (>=4.6.3)", "matplotlib (>=3.6.1)", "numba (>=0.53.1)", "numexpr (>=2.7.3)", "odfpy (>=1.4.1)", "openpyxl (>=3.0.7)", "pandas-gbq (>=0.15.0)", "psycopg2 (>=2.8.6)", "pyarrow (>=7.0.0)", "pymysql (>=1.0.2)", "pyreadstat (>=1.1.2)", "pytest (>=7.0.0)", "pytest-asyncio (>=0.17.0)", "pytest-xdist (>=2.2.0)", "python-snappy (>=0.6.0)", "pyxlsb (>=1.0.8)", "qtpy (>=2.2.0)", "s3fs (>=2021.08.0)", "scipy (>=1.7.1)", "tables (>=3.6.1)", "tabulate (>=0.8.9)", "xarray (>=0.21.0)", "xlrd (>=2.0.1)", "xlsxwriter (>=1.4.3)", "zstandard (>=0.15.2)"] -aws = ["s3fs (>=2021.08.0)"] -clipboard = ["PyQt5 (>=5.15.1)", "qtpy (>=2.2.0)"] -compression = ["brotlipy (>=0.7.0)", "python-snappy (>=0.6.0)", "zstandard (>=0.15.2)"] -computation = ["scipy (>=1.7.1)", "xarray (>=0.21.0)"] -excel = ["odfpy (>=1.4.1)", "openpyxl (>=3.0.7)", "pyxlsb (>=1.0.8)", "xlrd (>=2.0.1)", "xlsxwriter (>=1.4.3)"] -feather = ["pyarrow (>=7.0.0)"] -fss = ["fsspec (>=2021.07.0)"] -gcp = ["gcsfs (>=2021.07.0)", "pandas-gbq (>=0.15.0)"] -hdf5 = ["tables (>=3.6.1)"] -html = ["beautifulsoup4 (>=4.9.3)", "html5lib (>=1.1)", "lxml (>=4.6.3)"] -mysql = ["SQLAlchemy (>=1.4.16)", "pymysql (>=1.0.2)"] -output-formatting = ["jinja2 (>=3.0.0)", "tabulate (>=0.8.9)"] -parquet = ["pyarrow (>=7.0.0)"] -performance = ["bottleneck (>=1.3.2)", "numba (>=0.53.1)", "numexpr (>=2.7.1)"] -plot = ["matplotlib (>=3.6.1)"] -postgresql = ["SQLAlchemy (>=1.4.16)", "psycopg2 (>=2.8.6)"] -spss = ["pyreadstat (>=1.1.2)"] -sql-other = ["SQLAlchemy (>=1.4.16)"] -test = ["hypothesis (>=6.34.2)", "pytest (>=7.0.0)", "pytest-asyncio (>=0.17.0)", "pytest-xdist (>=2.2.0)"] -xml = ["lxml (>=4.6.3)"] - -[[package]] -name = "pandocfilters" -version = "1.5.0" -description = "Utilities for writing pandoc filters in python" -category = "dev" -optional = false -python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" -files = [ - {file = "pandocfilters-1.5.0-py2.py3-none-any.whl", hash = "sha256:33aae3f25fd1a026079f5d27bdd52496f0e0803b3469282162bafdcbdf6ef14f"}, - {file = "pandocfilters-1.5.0.tar.gz", hash = "sha256:0b679503337d233b4339a817bfc8c50064e2eff681314376a47cb582305a7a38"}, -] - -[[package]] -name = "parso" -version = "0.8.3" -description = "A Python Parser" -category = "dev" -optional = false -python-versions = ">=3.6" -files = [ - {file = "parso-0.8.3-py2.py3-none-any.whl", hash = "sha256:c001d4636cd3aecdaf33cbb40aebb59b094be2a74c556778ef5576c175e19e75"}, - {file = "parso-0.8.3.tar.gz", hash = "sha256:8c07be290bb59f03588915921e29e8a50002acaf2cdc5fa0e0114f91709fafa0"}, -] - -[package.extras] -qa = ["flake8 (==3.8.3)", "mypy (==0.782)"] -testing = ["docopt", "pytest (<6.0.0)"] - -[[package]] -name = "pexpect" -version = "4.8.0" -description = "Pexpect allows easy control of interactive console applications." -category = "dev" -optional = false -python-versions = "*" -files = [ - {file = "pexpect-4.8.0-py2.py3-none-any.whl", hash = "sha256:0b48a55dcb3c05f3329815901ea4fc1537514d6ba867a152b581d69ae3710937"}, - {file = "pexpect-4.8.0.tar.gz", hash = "sha256:fc65a43959d153d0114afe13997d439c22823a27cefceb5ff35c2178c6784c0c"}, -] - -[package.dependencies] -ptyprocess = ">=0.5" - -[[package]] -name = "pickleshare" -version = "0.7.5" -description = "Tiny 'shelve'-like database with concurrency support" -category = "dev" -optional = false -python-versions = "*" -files = [ - {file = "pickleshare-0.7.5-py2.py3-none-any.whl", hash = "sha256:9649af414d74d4df115d5d718f82acb59c9d418196b7b4290ed47a12ce62df56"}, - {file = "pickleshare-0.7.5.tar.gz", hash = "sha256:87683d47965c1da65cdacaf31c8441d12b8044cdec9aca500cd78fc2c683afca"}, -] - -[[package]] -name = "pillow" -version = "9.5.0" -description = "Python Imaging Library (Fork)" -category = "main" -optional = false -python-versions = ">=3.7" -files = [ - {file = "Pillow-9.5.0-cp310-cp310-macosx_10_10_x86_64.whl", hash = "sha256:ace6ca218308447b9077c14ea4ef381ba0b67ee78d64046b3f19cf4e1139ad16"}, - {file = "Pillow-9.5.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:d3d403753c9d5adc04d4694d35cf0391f0f3d57c8e0030aac09d7678fa8030aa"}, - {file = "Pillow-9.5.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5ba1b81ee69573fe7124881762bb4cd2e4b6ed9dd28c9c60a632902fe8db8b38"}, - {file = "Pillow-9.5.0-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:fe7e1c262d3392afcf5071df9afa574544f28eac825284596ac6db56e6d11062"}, - {file = "Pillow-9.5.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8f36397bf3f7d7c6a3abdea815ecf6fd14e7fcd4418ab24bae01008d8d8ca15e"}, - {file = "Pillow-9.5.0-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:252a03f1bdddce077eff2354c3861bf437c892fb1832f75ce813ee94347aa9b5"}, - {file = "Pillow-9.5.0-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:85ec677246533e27770b0de5cf0f9d6e4ec0c212a1f89dfc941b64b21226009d"}, - {file = "Pillow-9.5.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:b416f03d37d27290cb93597335a2f85ed446731200705b22bb927405320de903"}, - {file = "Pillow-9.5.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:1781a624c229cb35a2ac31cc4a77e28cafc8900733a864870c49bfeedacd106a"}, - {file = "Pillow-9.5.0-cp310-cp310-win32.whl", hash = "sha256:8507eda3cd0608a1f94f58c64817e83ec12fa93a9436938b191b80d9e4c0fc44"}, - {file = "Pillow-9.5.0-cp310-cp310-win_amd64.whl", hash = "sha256:d3c6b54e304c60c4181da1c9dadf83e4a54fd266a99c70ba646a9baa626819eb"}, - {file = "Pillow-9.5.0-cp311-cp311-macosx_10_10_x86_64.whl", hash = "sha256:7ec6f6ce99dab90b52da21cf0dc519e21095e332ff3b399a357c187b1a5eee32"}, - {file = "Pillow-9.5.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:560737e70cb9c6255d6dcba3de6578a9e2ec4b573659943a5e7e4af13f298f5c"}, - {file = "Pillow-9.5.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:96e88745a55b88a7c64fa49bceff363a1a27d9a64e04019c2281049444a571e3"}, - {file = "Pillow-9.5.0-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d9c206c29b46cfd343ea7cdfe1232443072bbb270d6a46f59c259460db76779a"}, - {file = "Pillow-9.5.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cfcc2c53c06f2ccb8976fb5c71d448bdd0a07d26d8e07e321c103416444c7ad1"}, - {file = "Pillow-9.5.0-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:a0f9bb6c80e6efcde93ffc51256d5cfb2155ff8f78292f074f60f9e70b942d99"}, - {file = "Pillow-9.5.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:8d935f924bbab8f0a9a28404422da8af4904e36d5c33fc6f677e4c4485515625"}, - {file = "Pillow-9.5.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:fed1e1cf6a42577953abbe8e6cf2fe2f566daebde7c34724ec8803c4c0cda579"}, - {file = "Pillow-9.5.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:c1170d6b195555644f0616fd6ed929dfcf6333b8675fcca044ae5ab110ded296"}, - {file = "Pillow-9.5.0-cp311-cp311-win32.whl", hash = "sha256:54f7102ad31a3de5666827526e248c3530b3a33539dbda27c6843d19d72644ec"}, - {file = "Pillow-9.5.0-cp311-cp311-win_amd64.whl", hash = "sha256:cfa4561277f677ecf651e2b22dc43e8f5368b74a25a8f7d1d4a3a243e573f2d4"}, - {file = "Pillow-9.5.0-cp311-cp311-win_arm64.whl", hash = "sha256:965e4a05ef364e7b973dd17fc765f42233415974d773e82144c9bbaaaea5d089"}, - {file = "Pillow-9.5.0-cp312-cp312-win32.whl", hash = "sha256:22baf0c3cf0c7f26e82d6e1adf118027afb325e703922c8dfc1d5d0156bb2eeb"}, - {file = "Pillow-9.5.0-cp312-cp312-win_amd64.whl", hash = "sha256:432b975c009cf649420615388561c0ce7cc31ce9b2e374db659ee4f7d57a1f8b"}, - {file = "Pillow-9.5.0-cp37-cp37m-macosx_10_10_x86_64.whl", hash = "sha256:5d4ebf8e1db4441a55c509c4baa7a0587a0210f7cd25fcfe74dbbce7a4bd1906"}, - {file = "Pillow-9.5.0-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:375f6e5ee9620a271acb6820b3d1e94ffa8e741c0601db4c0c4d3cb0a9c224bf"}, - {file = "Pillow-9.5.0-cp37-cp37m-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:99eb6cafb6ba90e436684e08dad8be1637efb71c4f2180ee6b8f940739406e78"}, - {file = "Pillow-9.5.0-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2dfaaf10b6172697b9bceb9a3bd7b951819d1ca339a5ef294d1f1ac6d7f63270"}, - {file = "Pillow-9.5.0-cp37-cp37m-manylinux_2_28_aarch64.whl", hash = "sha256:763782b2e03e45e2c77d7779875f4432e25121ef002a41829d8868700d119392"}, - {file = "Pillow-9.5.0-cp37-cp37m-manylinux_2_28_x86_64.whl", hash = "sha256:35f6e77122a0c0762268216315bf239cf52b88865bba522999dc38f1c52b9b47"}, - {file = "Pillow-9.5.0-cp37-cp37m-win32.whl", hash = "sha256:aca1c196f407ec7cf04dcbb15d19a43c507a81f7ffc45b690899d6a76ac9fda7"}, - {file = "Pillow-9.5.0-cp37-cp37m-win_amd64.whl", hash = "sha256:322724c0032af6692456cd6ed554bb85f8149214d97398bb80613b04e33769f6"}, - {file = "Pillow-9.5.0-cp38-cp38-macosx_10_10_x86_64.whl", hash = "sha256:a0aa9417994d91301056f3d0038af1199eb7adc86e646a36b9e050b06f526597"}, - {file = "Pillow-9.5.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:f8286396b351785801a976b1e85ea88e937712ee2c3ac653710a4a57a8da5d9c"}, - {file = "Pillow-9.5.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c830a02caeb789633863b466b9de10c015bded434deb3ec87c768e53752ad22a"}, - {file = "Pillow-9.5.0-cp38-cp38-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:fbd359831c1657d69bb81f0db962905ee05e5e9451913b18b831febfe0519082"}, - {file = "Pillow-9.5.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f8fc330c3370a81bbf3f88557097d1ea26cd8b019d6433aa59f71195f5ddebbf"}, - {file = "Pillow-9.5.0-cp38-cp38-manylinux_2_28_aarch64.whl", hash = "sha256:7002d0797a3e4193c7cdee3198d7c14f92c0836d6b4a3f3046a64bd1ce8df2bf"}, - {file = "Pillow-9.5.0-cp38-cp38-manylinux_2_28_x86_64.whl", hash = "sha256:229e2c79c00e85989a34b5981a2b67aa079fd08c903f0aaead522a1d68d79e51"}, - {file = "Pillow-9.5.0-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:9adf58f5d64e474bed00d69bcd86ec4bcaa4123bfa70a65ce72e424bfb88ed96"}, - {file = "Pillow-9.5.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:662da1f3f89a302cc22faa9f14a262c2e3951f9dbc9617609a47521c69dd9f8f"}, - {file = "Pillow-9.5.0-cp38-cp38-win32.whl", hash = "sha256:6608ff3bf781eee0cd14d0901a2b9cc3d3834516532e3bd673a0a204dc8615fc"}, - {file = "Pillow-9.5.0-cp38-cp38-win_amd64.whl", hash = "sha256:e49eb4e95ff6fd7c0c402508894b1ef0e01b99a44320ba7d8ecbabefddcc5569"}, - {file = "Pillow-9.5.0-cp39-cp39-macosx_10_10_x86_64.whl", hash = "sha256:482877592e927fd263028c105b36272398e3e1be3269efda09f6ba21fd83ec66"}, - {file = "Pillow-9.5.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:3ded42b9ad70e5f1754fb7c2e2d6465a9c842e41d178f262e08b8c85ed8a1d8e"}, - {file = "Pillow-9.5.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c446d2245ba29820d405315083d55299a796695d747efceb5717a8b450324115"}, - {file = "Pillow-9.5.0-cp39-cp39-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:8aca1152d93dcc27dc55395604dcfc55bed5f25ef4c98716a928bacba90d33a3"}, - {file = "Pillow-9.5.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:608488bdcbdb4ba7837461442b90ea6f3079397ddc968c31265c1e056964f1ef"}, - {file = "Pillow-9.5.0-cp39-cp39-manylinux_2_28_aarch64.whl", hash = "sha256:60037a8db8750e474af7ffc9faa9b5859e6c6d0a50e55c45576bf28be7419705"}, - {file = "Pillow-9.5.0-cp39-cp39-manylinux_2_28_x86_64.whl", hash = "sha256:07999f5834bdc404c442146942a2ecadd1cb6292f5229f4ed3b31e0a108746b1"}, - {file = "Pillow-9.5.0-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:a127ae76092974abfbfa38ca2d12cbeddcdeac0fb71f9627cc1135bedaf9d51a"}, - {file = "Pillow-9.5.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:489f8389261e5ed43ac8ff7b453162af39c3e8abd730af8363587ba64bb2e865"}, - {file = "Pillow-9.5.0-cp39-cp39-win32.whl", hash = "sha256:9b1af95c3a967bf1da94f253e56b6286b50af23392a886720f563c547e48e964"}, - {file = "Pillow-9.5.0-cp39-cp39-win_amd64.whl", hash = "sha256:77165c4a5e7d5a284f10a6efaa39a0ae8ba839da344f20b111d62cc932fa4e5d"}, - {file = "Pillow-9.5.0-pp38-pypy38_pp73-macosx_10_10_x86_64.whl", hash = "sha256:833b86a98e0ede388fa29363159c9b1a294b0905b5128baf01db683672f230f5"}, - {file = "Pillow-9.5.0-pp38-pypy38_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:aaf305d6d40bd9632198c766fb64f0c1a83ca5b667f16c1e79e1661ab5060140"}, - {file = "Pillow-9.5.0-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0852ddb76d85f127c135b6dd1f0bb88dbb9ee990d2cd9aa9e28526c93e794fba"}, - {file = "Pillow-9.5.0-pp38-pypy38_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:91ec6fe47b5eb5a9968c79ad9ed78c342b1f97a091677ba0e012701add857829"}, - {file = "Pillow-9.5.0-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:cb841572862f629b99725ebaec3287fc6d275be9b14443ea746c1dd325053cbd"}, - {file = "Pillow-9.5.0-pp39-pypy39_pp73-macosx_10_10_x86_64.whl", hash = "sha256:c380b27d041209b849ed246b111b7c166ba36d7933ec6e41175fd15ab9eb1572"}, - {file = "Pillow-9.5.0-pp39-pypy39_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7c9af5a3b406a50e313467e3565fc99929717f780164fe6fbb7704edba0cebbe"}, - {file = "Pillow-9.5.0-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5671583eab84af046a397d6d0ba25343c00cd50bce03787948e0fff01d4fd9b1"}, - {file = "Pillow-9.5.0-pp39-pypy39_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:84a6f19ce086c1bf894644b43cd129702f781ba5751ca8572f08aa40ef0ab7b7"}, - {file = "Pillow-9.5.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:1e7723bd90ef94eda669a3c2c19d549874dd5badaeefabefd26053304abe5799"}, - {file = "Pillow-9.5.0.tar.gz", hash = "sha256:bf548479d336726d7a0eceb6e767e179fbde37833ae42794602631a070d630f1"}, -] - -[package.extras] -docs = ["furo", "olefile", "sphinx (>=2.4)", "sphinx-copybutton", "sphinx-inline-tabs", "sphinx-removed-in", "sphinxext-opengraph"] -tests = ["check-manifest", "coverage", "defusedxml", "markdown2", "olefile", "packaging", "pyroma", "pytest", "pytest-cov", "pytest-timeout"] - -[[package]] -name = "pkgutil-resolve-name" -version = "1.3.10" -description = "Resolve a name to an object." -category = "dev" -optional = false -python-versions = ">=3.6" -files = [ - {file = "pkgutil_resolve_name-1.3.10-py3-none-any.whl", hash = "sha256:ca27cc078d25c5ad71a9de0a7a330146c4e014c2462d9af19c6b828280649c5e"}, - {file = "pkgutil_resolve_name-1.3.10.tar.gz", hash = "sha256:357d6c9e6a755653cfd78893817c0853af365dd51ec97f3d358a819373bbd174"}, -] - -[[package]] -name = "platformdirs" -version = "3.2.0" -description = "A small Python package for determining appropriate platform-specific dirs, e.g. a \"user data dir\"." -category = "dev" -optional = false -python-versions = ">=3.7" -files = [ - {file = "platformdirs-3.2.0-py3-none-any.whl", hash = "sha256:ebe11c0d7a805086e99506aa331612429a72ca7cd52a1f0d277dc4adc20cb10e"}, - {file = "platformdirs-3.2.0.tar.gz", hash = "sha256:d5b638ca397f25f979350ff789db335903d7ea010ab28903f57b27e1b16c2b08"}, -] - -[package.extras] -docs = ["furo (>=2022.12.7)", "proselint (>=0.13)", "sphinx (>=6.1.3)", "sphinx-autodoc-typehints (>=1.22,!=1.23.4)"] -test = ["appdirs (==1.4.4)", "covdefaults (>=2.3)", "pytest (>=7.2.2)", "pytest-cov (>=4)", "pytest-mock (>=3.10)"] - -[[package]] -name = "pluggy" -version = "1.0.0" -description = "plugin and hook calling mechanisms for python" -category = "dev" -optional = false -python-versions = ">=3.6" -files = [ - {file = "pluggy-1.0.0-py2.py3-none-any.whl", hash = "sha256:74134bbf457f031a36d68416e1509f34bd5ccc019f0bcc952c7b909d06b37bd3"}, - {file = "pluggy-1.0.0.tar.gz", hash = "sha256:4224373bacce55f955a878bf9cfa763c1e360858e330072059e10bad68531159"}, -] - -[package.extras] -dev = ["pre-commit", "tox"] -testing = ["pytest", "pytest-benchmark"] - -[[package]] -name = "pre-commit" -version = "3.3.2" -description = "A framework for managing and maintaining multi-language pre-commit hooks." -category = "dev" -optional = false -python-versions = ">=3.8" -files = [ - {file = "pre_commit-3.3.2-py2.py3-none-any.whl", hash = "sha256:8056bc52181efadf4aac792b1f4f255dfd2fb5a350ded7335d251a68561e8cb6"}, - {file = "pre_commit-3.3.2.tar.gz", hash = "sha256:66e37bec2d882de1f17f88075047ef8962581f83c234ac08da21a0c58953d1f0"}, -] - -[package.dependencies] -cfgv = ">=2.0.0" -identify = ">=1.0.0" -nodeenv = ">=0.11.1" -pyyaml = ">=5.1" -virtualenv = ">=20.10.0" - -[[package]] -name = "prometheus-client" -version = "0.16.0" -description = "Python client for the Prometheus monitoring system." -category = "dev" -optional = false -python-versions = ">=3.6" -files = [ - {file = "prometheus_client-0.16.0-py3-none-any.whl", hash = "sha256:0836af6eb2c8f4fed712b2f279f6c0a8bbab29f9f4aa15276b91c7cb0d1616ab"}, - {file = "prometheus_client-0.16.0.tar.gz", hash = "sha256:a03e35b359f14dd1630898543e2120addfdeacd1a6069c1367ae90fd93ad3f48"}, -] - -[package.extras] -twisted = ["twisted"] - -[[package]] -name = "prompt-toolkit" -version = "3.0.38" -description = "Library for building powerful interactive command lines in Python" -category = "dev" -optional = false -python-versions = ">=3.7.0" -files = [ - {file = "prompt_toolkit-3.0.38-py3-none-any.whl", hash = "sha256:45ea77a2f7c60418850331366c81cf6b5b9cf4c7fd34616f733c5427e6abbb1f"}, - {file = "prompt_toolkit-3.0.38.tar.gz", hash = "sha256:23ac5d50538a9a38c8bde05fecb47d0b403ecd0662857a86f886f798563d5b9b"}, -] - -[package.dependencies] -wcwidth = "*" - -[[package]] -name = "psutil" -version = "5.9.4" -description = "Cross-platform lib for process and system monitoring in Python." -category = "dev" -optional = false -python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" -files = [ - {file = "psutil-5.9.4-cp27-cp27m-macosx_10_9_x86_64.whl", hash = "sha256:c1ca331af862803a42677c120aff8a814a804e09832f166f226bfd22b56feee8"}, - {file = "psutil-5.9.4-cp27-cp27m-manylinux2010_i686.whl", hash = "sha256:68908971daf802203f3d37e78d3f8831b6d1014864d7a85937941bb35f09aefe"}, - {file = "psutil-5.9.4-cp27-cp27m-manylinux2010_x86_64.whl", hash = "sha256:3ff89f9b835100a825b14c2808a106b6fdcc4b15483141482a12c725e7f78549"}, - {file = "psutil-5.9.4-cp27-cp27m-win32.whl", hash = "sha256:852dd5d9f8a47169fe62fd4a971aa07859476c2ba22c2254d4a1baa4e10b95ad"}, - {file = "psutil-5.9.4-cp27-cp27m-win_amd64.whl", hash = "sha256:9120cd39dca5c5e1c54b59a41d205023d436799b1c8c4d3ff71af18535728e94"}, - {file = "psutil-5.9.4-cp27-cp27mu-manylinux2010_i686.whl", hash = "sha256:6b92c532979bafc2df23ddc785ed116fced1f492ad90a6830cf24f4d1ea27d24"}, - {file = "psutil-5.9.4-cp27-cp27mu-manylinux2010_x86_64.whl", hash = "sha256:efeae04f9516907be44904cc7ce08defb6b665128992a56957abc9b61dca94b7"}, - {file = "psutil-5.9.4-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:54d5b184728298f2ca8567bf83c422b706200bcbbfafdc06718264f9393cfeb7"}, - {file = "psutil-5.9.4-cp36-abi3-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:16653106f3b59386ffe10e0bad3bb6299e169d5327d3f187614b1cb8f24cf2e1"}, - {file = "psutil-5.9.4-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:54c0d3d8e0078b7666984e11b12b88af2db11d11249a8ac8920dd5ef68a66e08"}, - {file = "psutil-5.9.4-cp36-abi3-win32.whl", hash = "sha256:149555f59a69b33f056ba1c4eb22bb7bf24332ce631c44a319cec09f876aaeff"}, - {file = "psutil-5.9.4-cp36-abi3-win_amd64.whl", hash = "sha256:fd8522436a6ada7b4aad6638662966de0d61d241cb821239b2ae7013d41a43d4"}, - {file = "psutil-5.9.4-cp38-abi3-macosx_11_0_arm64.whl", hash = "sha256:6001c809253a29599bc0dfd5179d9f8a5779f9dffea1da0f13c53ee568115e1e"}, - {file = "psutil-5.9.4.tar.gz", hash = "sha256:3d7f9739eb435d4b1338944abe23f49584bde5395f27487d2ee25ad9a8774a62"}, -] - -[package.extras] -test = ["enum34", "ipaddress", "mock", "pywin32", "wmi"] - -[[package]] -name = "ptyprocess" -version = "0.7.0" -description = "Run a subprocess in a pseudo terminal" -category = "dev" -optional = false -python-versions = "*" -files = [ - {file = "ptyprocess-0.7.0-py2.py3-none-any.whl", hash = "sha256:4b41f3967fce3af57cc7e94b888626c18bf37a083e3651ca8feeb66d492fef35"}, - {file = "ptyprocess-0.7.0.tar.gz", hash = "sha256:5c5d0a3b48ceee0b48485e0c26037c0acd7d29765ca3fbb5cb3831d347423220"}, -] - -[[package]] -name = "pure-eval" -version = "0.2.2" -description = "Safely evaluate AST nodes without side effects" -category = "dev" -optional = false -python-versions = "*" -files = [ - {file = "pure_eval-0.2.2-py3-none-any.whl", hash = "sha256:01eaab343580944bc56080ebe0a674b39ec44a945e6d09ba7db3cb8cec289350"}, - {file = "pure_eval-0.2.2.tar.gz", hash = "sha256:2b45320af6dfaa1750f543d714b6d1c520a1688dec6fd24d339063ce0aaa9ac3"}, -] - -[package.extras] -tests = ["pytest"] - -[[package]] -name = "pycodestyle" -version = "2.10.0" -description = "Python style guide checker" -category = "dev" -optional = false -python-versions = ">=3.6" -files = [ - {file = "pycodestyle-2.10.0-py2.py3-none-any.whl", hash = "sha256:8a4eaf0d0495c7395bdab3589ac2db602797d76207242c17d470186815706610"}, - {file = "pycodestyle-2.10.0.tar.gz", hash = "sha256:347187bdb476329d98f695c213d7295a846d1152ff4fe9bacb8a9590b8ee7053"}, -] - -[[package]] -name = "pycparser" -version = "2.21" -description = "C parser in Python" -category = "dev" -optional = false -python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" -files = [ - {file = "pycparser-2.21-py2.py3-none-any.whl", hash = "sha256:8ee45429555515e1f6b185e78100aea234072576aa43ab53aefcae078162fca9"}, - {file = "pycparser-2.21.tar.gz", hash = "sha256:e644fdec12f7872f86c58ff790da456218b10f863970249516d60a5eaca77206"}, -] - -[[package]] -name = "pyflakes" -version = "3.0.1" -description = "passive checker of Python programs" -category = "dev" -optional = false -python-versions = ">=3.6" -files = [ - {file = "pyflakes-3.0.1-py2.py3-none-any.whl", hash = "sha256:ec55bf7fe21fff7f1ad2f7da62363d749e2a470500eab1b555334b67aa1ef8cf"}, - {file = "pyflakes-3.0.1.tar.gz", hash = "sha256:ec8b276a6b60bd80defed25add7e439881c19e64850afd9b346283d4165fd0fd"}, -] - -[[package]] -name = "pygments" -version = "2.14.0" -description = "Pygments is a syntax highlighting package written in Python." -category = "dev" -optional = false -python-versions = ">=3.6" -files = [ - {file = "Pygments-2.14.0-py3-none-any.whl", hash = "sha256:fa7bd7bd2771287c0de303af8bfdfc731f51bd2c6a47ab69d117138893b82717"}, - {file = "Pygments-2.14.0.tar.gz", hash = "sha256:b3ed06a9e8ac9a9aae5a6f5dbe78a8a58655d17b43b93c078f094ddc476ae297"}, -] - -[package.extras] -plugins = ["importlib-metadata"] - -[[package]] -name = "pymdown-extensions" -version = "10.0" -description = "Extension pack for Python Markdown." -category = "dev" -optional = false -python-versions = ">=3.7" -files = [ - {file = "pymdown_extensions-10.0-py3-none-any.whl", hash = "sha256:e6cbe8ace7d8feda30bc4fd6a21a073893a9a0e90c373e92d69ce5b653051f55"}, - {file = "pymdown_extensions-10.0.tar.gz", hash = "sha256:9a77955e63528c2ee98073a1fb3207c1a45607bc74a34ef21acd098f46c3aa8a"}, -] - -[package.dependencies] -markdown = ">=3.2" -pyyaml = "*" - -[[package]] -name = "pyparsing" -version = "3.0.9" -description = "pyparsing module - Classes and methods to define and execute parsing grammars" -category = "main" -optional = false -python-versions = ">=3.6.8" -files = [ - {file = "pyparsing-3.0.9-py3-none-any.whl", hash = "sha256:5026bae9a10eeaefb61dab2f09052b9f4307d44aee4eda64b309723d8d206bbc"}, - {file = "pyparsing-3.0.9.tar.gz", hash = "sha256:2b020ecf7d21b687f219b71ecad3631f644a47f01403fa1d1036b0c6416d70fb"}, -] - -[package.extras] -diagrams = ["jinja2", "railroad-diagrams"] - -[[package]] -name = "pyrsistent" -version = "0.19.3" -description = "Persistent/Functional/Immutable data structures" -category = "dev" -optional = false -python-versions = ">=3.7" -files = [ - {file = "pyrsistent-0.19.3-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:20460ac0ea439a3e79caa1dbd560344b64ed75e85d8703943e0b66c2a6150e4a"}, - {file = "pyrsistent-0.19.3-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4c18264cb84b5e68e7085a43723f9e4c1fd1d935ab240ce02c0324a8e01ccb64"}, - {file = "pyrsistent-0.19.3-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4b774f9288dda8d425adb6544e5903f1fb6c273ab3128a355c6b972b7df39dcf"}, - {file = "pyrsistent-0.19.3-cp310-cp310-win32.whl", hash = "sha256:5a474fb80f5e0d6c9394d8db0fc19e90fa540b82ee52dba7d246a7791712f74a"}, - {file = "pyrsistent-0.19.3-cp310-cp310-win_amd64.whl", hash = "sha256:49c32f216c17148695ca0e02a5c521e28a4ee6c5089f97e34fe24163113722da"}, - {file = "pyrsistent-0.19.3-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:f0774bf48631f3a20471dd7c5989657b639fd2d285b861237ea9e82c36a415a9"}, - {file = "pyrsistent-0.19.3-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3ab2204234c0ecd8b9368dbd6a53e83c3d4f3cab10ecaf6d0e772f456c442393"}, - {file = "pyrsistent-0.19.3-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e42296a09e83028b3476f7073fcb69ffebac0e66dbbfd1bd847d61f74db30f19"}, - {file = "pyrsistent-0.19.3-cp311-cp311-win32.whl", hash = "sha256:64220c429e42a7150f4bfd280f6f4bb2850f95956bde93c6fda1b70507af6ef3"}, - {file = "pyrsistent-0.19.3-cp311-cp311-win_amd64.whl", hash = "sha256:016ad1afadf318eb7911baa24b049909f7f3bb2c5b1ed7b6a8f21db21ea3faa8"}, - {file = "pyrsistent-0.19.3-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:c4db1bd596fefd66b296a3d5d943c94f4fac5bcd13e99bffe2ba6a759d959a28"}, - {file = "pyrsistent-0.19.3-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:aeda827381f5e5d65cced3024126529ddc4289d944f75e090572c77ceb19adbf"}, - {file = "pyrsistent-0.19.3-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:42ac0b2f44607eb92ae88609eda931a4f0dfa03038c44c772e07f43e738bcac9"}, - {file = "pyrsistent-0.19.3-cp37-cp37m-win32.whl", hash = "sha256:e8f2b814a3dc6225964fa03d8582c6e0b6650d68a232df41e3cc1b66a5d2f8d1"}, - {file = "pyrsistent-0.19.3-cp37-cp37m-win_amd64.whl", hash = "sha256:c9bb60a40a0ab9aba40a59f68214eed5a29c6274c83b2cc206a359c4a89fa41b"}, - {file = "pyrsistent-0.19.3-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:a2471f3f8693101975b1ff85ffd19bb7ca7dd7c38f8a81701f67d6b4f97b87d8"}, - {file = "pyrsistent-0.19.3-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cc5d149f31706762c1f8bda2e8c4f8fead6e80312e3692619a75301d3dbb819a"}, - {file = "pyrsistent-0.19.3-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3311cb4237a341aa52ab8448c27e3a9931e2ee09561ad150ba94e4cfd3fc888c"}, - {file = "pyrsistent-0.19.3-cp38-cp38-win32.whl", hash = "sha256:f0e7c4b2f77593871e918be000b96c8107da48444d57005b6a6bc61fb4331b2c"}, - {file = "pyrsistent-0.19.3-cp38-cp38-win_amd64.whl", hash = "sha256:c147257a92374fde8498491f53ffa8f4822cd70c0d85037e09028e478cababb7"}, - {file = "pyrsistent-0.19.3-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:b735e538f74ec31378f5a1e3886a26d2ca6351106b4dfde376a26fc32a044edc"}, - {file = "pyrsistent-0.19.3-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:99abb85579e2165bd8522f0c0138864da97847875ecbd45f3e7e2af569bfc6f2"}, - {file = "pyrsistent-0.19.3-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3a8cb235fa6d3fd7aae6a4f1429bbb1fec1577d978098da1252f0489937786f3"}, - {file = "pyrsistent-0.19.3-cp39-cp39-win32.whl", hash = "sha256:c74bed51f9b41c48366a286395c67f4e894374306b197e62810e0fdaf2364da2"}, - {file = "pyrsistent-0.19.3-cp39-cp39-win_amd64.whl", hash = "sha256:878433581fc23e906d947a6814336eee031a00e6defba224234169ae3d3d6a98"}, - {file = "pyrsistent-0.19.3-py3-none-any.whl", hash = "sha256:ccf0d6bd208f8111179f0c26fdf84ed7c3891982f2edaeae7422575f47e66b64"}, - {file = "pyrsistent-0.19.3.tar.gz", hash = "sha256:1a2994773706bbb4995c31a97bc94f1418314923bd1048c6d964837040376440"}, -] - -[[package]] -name = "pytest" -version = "7.3.1" -description = "pytest: simple powerful testing with Python" -category = "dev" -optional = false -python-versions = ">=3.7" -files = [ - {file = "pytest-7.3.1-py3-none-any.whl", hash = "sha256:3799fa815351fea3a5e96ac7e503a96fa51cc9942c3753cda7651b93c1cfa362"}, - {file = "pytest-7.3.1.tar.gz", hash = "sha256:434afafd78b1d78ed0addf160ad2b77a30d35d4bdf8af234fe621919d9ed15e3"}, -] - -[package.dependencies] -colorama = {version = "*", markers = "sys_platform == \"win32\""} -exceptiongroup = {version = ">=1.0.0rc8", markers = "python_version < \"3.11\""} -iniconfig = "*" -packaging = "*" -pluggy = ">=0.12,<2.0" -tomli = {version = ">=1.0.0", markers = "python_version < \"3.11\""} - -[package.extras] -testing = ["argcomplete", "attrs (>=19.2.0)", "hypothesis (>=3.56)", "mock", "nose", "pygments (>=2.7.2)", "requests", "xmlschema"] - -[[package]] -name = "python-dateutil" -version = "2.8.2" -description = "Extensions to the standard Python datetime module" -category = "main" -optional = false -python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,>=2.7" -files = [ - {file = "python-dateutil-2.8.2.tar.gz", hash = "sha256:0123cacc1627ae19ddf3c27a5de5bd67ee4586fbdd6440d9748f8abb483d3e86"}, - {file = "python_dateutil-2.8.2-py2.py3-none-any.whl", hash = "sha256:961d03dc3453ebbc59dbdea9e4e11c5651520a876d0f4db161e8674aae935da9"}, -] - -[package.dependencies] -six = ">=1.5" - -[[package]] -name = "python-json-logger" -version = "2.0.7" -description = "A python library adding a json log formatter" -category = "dev" -optional = false -python-versions = ">=3.6" -files = [ - {file = "python-json-logger-2.0.7.tar.gz", hash = "sha256:23e7ec02d34237c5aa1e29a070193a4ea87583bb4e7f8fd06d3de8264c4b2e1c"}, - {file = "python_json_logger-2.0.7-py3-none-any.whl", hash = "sha256:f380b826a991ebbe3de4d897aeec42760035ac760345e57b812938dc8b35e2bd"}, -] - -[[package]] -name = "pytz" -version = "2023.3" -description = "World timezone definitions, modern and historical" -category = "main" -optional = false -python-versions = "*" -files = [ - {file = "pytz-2023.3-py2.py3-none-any.whl", hash = "sha256:a151b3abb88eda1d4e34a9814df37de2a80e301e68ba0fd856fb9b46bfbbbffb"}, - {file = "pytz-2023.3.tar.gz", hash = "sha256:1d8ce29db189191fb55338ee6d0387d82ab59f3d00eac103412d64e0ebd0c588"}, -] - -[[package]] -name = "pywin32" -version = "306" -description = "Python for Window Extensions" -category = "dev" -optional = false -python-versions = "*" -files = [ - {file = "pywin32-306-cp310-cp310-win32.whl", hash = "sha256:06d3420a5155ba65f0b72f2699b5bacf3109f36acbe8923765c22938a69dfc8d"}, - {file = "pywin32-306-cp310-cp310-win_amd64.whl", hash = "sha256:84f4471dbca1887ea3803d8848a1616429ac94a4a8d05f4bc9c5dcfd42ca99c8"}, - {file = "pywin32-306-cp311-cp311-win32.whl", hash = "sha256:e65028133d15b64d2ed8f06dd9fbc268352478d4f9289e69c190ecd6818b6407"}, - {file = "pywin32-306-cp311-cp311-win_amd64.whl", hash = "sha256:a7639f51c184c0272e93f244eb24dafca9b1855707d94c192d4a0b4c01e1100e"}, - {file = "pywin32-306-cp311-cp311-win_arm64.whl", hash = "sha256:70dba0c913d19f942a2db25217d9a1b726c278f483a919f1abfed79c9cf64d3a"}, - {file = "pywin32-306-cp312-cp312-win32.whl", hash = "sha256:383229d515657f4e3ed1343da8be101000562bf514591ff383ae940cad65458b"}, - {file = "pywin32-306-cp312-cp312-win_amd64.whl", hash = "sha256:37257794c1ad39ee9be652da0462dc2e394c8159dfd913a8a4e8eb6fd346da0e"}, - {file = "pywin32-306-cp312-cp312-win_arm64.whl", hash = "sha256:5821ec52f6d321aa59e2db7e0a35b997de60c201943557d108af9d4ae1ec7040"}, - {file = "pywin32-306-cp37-cp37m-win32.whl", hash = "sha256:1c73ea9a0d2283d889001998059f5eaaba3b6238f767c9cf2833b13e6a685f65"}, - {file = "pywin32-306-cp37-cp37m-win_amd64.whl", hash = "sha256:72c5f621542d7bdd4fdb716227be0dd3f8565c11b280be6315b06ace35487d36"}, - {file = "pywin32-306-cp38-cp38-win32.whl", hash = "sha256:e4c092e2589b5cf0d365849e73e02c391c1349958c5ac3e9d5ccb9a28e017b3a"}, - {file = "pywin32-306-cp38-cp38-win_amd64.whl", hash = "sha256:e8ac1ae3601bee6ca9f7cb4b5363bf1c0badb935ef243c4733ff9a393b1690c0"}, - {file = "pywin32-306-cp39-cp39-win32.whl", hash = "sha256:e25fd5b485b55ac9c057f67d94bc203f3f6595078d1fb3b458c9c28b7153a802"}, - {file = "pywin32-306-cp39-cp39-win_amd64.whl", hash = "sha256:39b61c15272833b5c329a2989999dcae836b1eed650252ab1b7bfbe1d59f30f4"}, -] - -[[package]] -name = "pywinpty" -version = "2.0.10" -description = "Pseudo terminal support for Windows from Python." -category = "dev" -optional = false -python-versions = ">=3.7" -files = [ - {file = "pywinpty-2.0.10-cp310-none-win_amd64.whl", hash = "sha256:4c7d06ad10f6e92bc850a467f26d98f4f30e73d2fe5926536308c6ae0566bc16"}, - {file = "pywinpty-2.0.10-cp311-none-win_amd64.whl", hash = "sha256:7ffbd66310b83e42028fc9df7746118978d94fba8c1ebf15a7c1275fdd80b28a"}, - {file = "pywinpty-2.0.10-cp37-none-win_amd64.whl", hash = "sha256:38cb924f2778b5751ef91a75febd114776b3af0ae411bc667be45dd84fc881d3"}, - {file = "pywinpty-2.0.10-cp38-none-win_amd64.whl", hash = "sha256:902d79444b29ad1833b8d5c3c9aabdfd428f4f068504430df18074007c8c0de8"}, - {file = "pywinpty-2.0.10-cp39-none-win_amd64.whl", hash = "sha256:3c46aef80dd50979aff93de199e4a00a8ee033ba7a03cadf0a91fed45f0c39d7"}, - {file = "pywinpty-2.0.10.tar.gz", hash = "sha256:cdbb5694cf8c7242c2ecfaca35c545d31fa5d5814c3d67a4e628f803f680ebea"}, -] - -[[package]] -name = "pyyaml" -version = "6.0" -description = "YAML parser and emitter for Python" -category = "dev" -optional = false -python-versions = ">=3.6" -files = [ - {file = "PyYAML-6.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:d4db7c7aef085872ef65a8fd7d6d09a14ae91f691dec3e87ee5ee0539d516f53"}, - {file = "PyYAML-6.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:9df7ed3b3d2e0ecfe09e14741b857df43adb5a3ddadc919a2d94fbdf78fea53c"}, - {file = "PyYAML-6.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:77f396e6ef4c73fdc33a9157446466f1cff553d979bd00ecb64385760c6babdc"}, - {file = "PyYAML-6.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a80a78046a72361de73f8f395f1f1e49f956c6be882eed58505a15f3e430962b"}, - {file = "PyYAML-6.0-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:f84fbc98b019fef2ee9a1cb3ce93e3187a6df0b2538a651bfb890254ba9f90b5"}, - {file = "PyYAML-6.0-cp310-cp310-win32.whl", hash = "sha256:2cd5df3de48857ed0544b34e2d40e9fac445930039f3cfe4bcc592a1f836d513"}, - {file = "PyYAML-6.0-cp310-cp310-win_amd64.whl", hash = "sha256:daf496c58a8c52083df09b80c860005194014c3698698d1a57cbcfa182142a3a"}, - {file = "PyYAML-6.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:d4b0ba9512519522b118090257be113b9468d804b19d63c71dbcf4a48fa32358"}, - {file = "PyYAML-6.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:81957921f441d50af23654aa6c5e5eaf9b06aba7f0a19c18a538dc7ef291c5a1"}, - {file = "PyYAML-6.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:afa17f5bc4d1b10afd4466fd3a44dc0e245382deca5b3c353d8b757f9e3ecb8d"}, - {file = "PyYAML-6.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:dbad0e9d368bb989f4515da330b88a057617d16b6a8245084f1b05400f24609f"}, - {file = "PyYAML-6.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:432557aa2c09802be39460360ddffd48156e30721f5e8d917f01d31694216782"}, - {file = "PyYAML-6.0-cp311-cp311-win32.whl", hash = "sha256:bfaef573a63ba8923503d27530362590ff4f576c626d86a9fed95822a8255fd7"}, - {file = "PyYAML-6.0-cp311-cp311-win_amd64.whl", hash = "sha256:01b45c0191e6d66c470b6cf1b9531a771a83c1c4208272ead47a3ae4f2f603bf"}, - {file = "PyYAML-6.0-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:897b80890765f037df3403d22bab41627ca8811ae55e9a722fd0392850ec4d86"}, - {file = "PyYAML-6.0-cp36-cp36m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:50602afada6d6cbfad699b0c7bb50d5ccffa7e46a3d738092afddc1f9758427f"}, - {file = "PyYAML-6.0-cp36-cp36m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:48c346915c114f5fdb3ead70312bd042a953a8ce5c7106d5bfb1a5254e47da92"}, - {file = "PyYAML-6.0-cp36-cp36m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:98c4d36e99714e55cfbaaee6dd5badbc9a1ec339ebfc3b1f52e293aee6bb71a4"}, - {file = "PyYAML-6.0-cp36-cp36m-win32.whl", hash = "sha256:0283c35a6a9fbf047493e3a0ce8d79ef5030852c51e9d911a27badfde0605293"}, - {file = "PyYAML-6.0-cp36-cp36m-win_amd64.whl", hash = "sha256:07751360502caac1c067a8132d150cf3d61339af5691fe9e87803040dbc5db57"}, - {file = "PyYAML-6.0-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:819b3830a1543db06c4d4b865e70ded25be52a2e0631ccd2f6a47a2822f2fd7c"}, - {file = "PyYAML-6.0-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:473f9edb243cb1935ab5a084eb238d842fb8f404ed2193a915d1784b5a6b5fc0"}, - {file = "PyYAML-6.0-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:0ce82d761c532fe4ec3f87fc45688bdd3a4c1dc5e0b4a19814b9009a29baefd4"}, - {file = "PyYAML-6.0-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:231710d57adfd809ef5d34183b8ed1eeae3f76459c18fb4a0b373ad56bedcdd9"}, - {file = "PyYAML-6.0-cp37-cp37m-win32.whl", hash = "sha256:c5687b8d43cf58545ade1fe3e055f70eac7a5a1a0bf42824308d868289a95737"}, - {file = "PyYAML-6.0-cp37-cp37m-win_amd64.whl", hash = "sha256:d15a181d1ecd0d4270dc32edb46f7cb7733c7c508857278d3d378d14d606db2d"}, - {file = "PyYAML-6.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:0b4624f379dab24d3725ffde76559cff63d9ec94e1736b556dacdfebe5ab6d4b"}, - {file = "PyYAML-6.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:213c60cd50106436cc818accf5baa1aba61c0189ff610f64f4a3e8c6726218ba"}, - {file = "PyYAML-6.0-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9fa600030013c4de8165339db93d182b9431076eb98eb40ee068700c9c813e34"}, - {file = "PyYAML-6.0-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:277a0ef2981ca40581a47093e9e2d13b3f1fbbeffae064c1d21bfceba2030287"}, - {file = "PyYAML-6.0-cp38-cp38-win32.whl", hash = "sha256:d4eccecf9adf6fbcc6861a38015c2a64f38b9d94838ac1810a9023a0609e1b78"}, - {file = "PyYAML-6.0-cp38-cp38-win_amd64.whl", hash = "sha256:1e4747bc279b4f613a09eb64bba2ba602d8a6664c6ce6396a4d0cd413a50ce07"}, - {file = "PyYAML-6.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:055d937d65826939cb044fc8c9b08889e8c743fdc6a32b33e2390f66013e449b"}, - {file = "PyYAML-6.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:e61ceaab6f49fb8bdfaa0f92c4b57bcfbea54c09277b1b4f7ac376bfb7a7c174"}, - {file = "PyYAML-6.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d67d839ede4ed1b28a4e8909735fc992a923cdb84e618544973d7dfc71540803"}, - {file = "PyYAML-6.0-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:cba8c411ef271aa037d7357a2bc8f9ee8b58b9965831d9e51baf703280dc73d3"}, - {file = "PyYAML-6.0-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:40527857252b61eacd1d9af500c3337ba8deb8fc298940291486c465c8b46ec0"}, - {file = "PyYAML-6.0-cp39-cp39-win32.whl", hash = "sha256:b5b9eccad747aabaaffbc6064800670f0c297e52c12754eb1d976c57e4f74dcb"}, - {file = "PyYAML-6.0-cp39-cp39-win_amd64.whl", hash = "sha256:b3d267842bf12586ba6c734f89d1f5b871df0273157918b0ccefa29deb05c21c"}, - {file = "PyYAML-6.0.tar.gz", hash = "sha256:68fb519c14306fec9720a2a5b45bc9f0c8d1b9c72adf45c37baedfcd949c35a2"}, -] - -[[package]] -name = "pyyaml-env-tag" -version = "0.1" -description = "A custom YAML tag for referencing environment variables in YAML files. " -category = "dev" -optional = false -python-versions = ">=3.6" -files = [ - {file = "pyyaml_env_tag-0.1-py3-none-any.whl", hash = "sha256:af31106dec8a4d68c60207c1886031cbf839b68aa7abccdb19868200532c2069"}, - {file = "pyyaml_env_tag-0.1.tar.gz", hash = "sha256:70092675bda14fdec33b31ba77e7543de9ddc88f2e5b99160396572d11525bdb"}, -] - -[package.dependencies] -pyyaml = "*" - -[[package]] -name = "pyzmq" -version = "25.0.2" -description = "Python bindings for 0MQ" -category = "dev" -optional = false -python-versions = ">=3.6" -files = [ - {file = "pyzmq-25.0.2-cp310-cp310-macosx_10_15_universal2.whl", hash = "sha256:ac178e666c097c8d3deb5097b58cd1316092fc43e8ef5b5fdb259b51da7e7315"}, - {file = "pyzmq-25.0.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:659e62e1cbb063151c52f5b01a38e1df6b54feccfa3e2509d44c35ca6d7962ee"}, - {file = "pyzmq-25.0.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8280ada89010735a12b968ec3ea9a468ac2e04fddcc1cede59cb7f5178783b9c"}, - {file = "pyzmq-25.0.2-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a9b5eeb5278a8a636bb0abdd9ff5076bcbb836cd2302565df53ff1fa7d106d54"}, - {file = "pyzmq-25.0.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9a2e5fe42dfe6b73ca120b97ac9f34bfa8414feb15e00e37415dbd51cf227ef6"}, - {file = "pyzmq-25.0.2-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:827bf60e749e78acb408a6c5af6688efbc9993e44ecc792b036ec2f4b4acf485"}, - {file = "pyzmq-25.0.2-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:7b504ae43d37e282301da586529e2ded8b36d4ee2cd5e6db4386724ddeaa6bbc"}, - {file = "pyzmq-25.0.2-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:cb1f69a0a2a2b1aae8412979dd6293cc6bcddd4439bf07e4758d864ddb112354"}, - {file = "pyzmq-25.0.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:2b9c9cc965cdf28381e36da525dcb89fc1571d9c54800fdcd73e3f73a2fc29bd"}, - {file = "pyzmq-25.0.2-cp310-cp310-win32.whl", hash = "sha256:24abbfdbb75ac5039205e72d6c75f10fc39d925f2df8ff21ebc74179488ebfca"}, - {file = "pyzmq-25.0.2-cp310-cp310-win_amd64.whl", hash = "sha256:6a821a506822fac55d2df2085a52530f68ab15ceed12d63539adc32bd4410f6e"}, - {file = "pyzmq-25.0.2-cp311-cp311-macosx_10_15_universal2.whl", hash = "sha256:9af0bb0277e92f41af35e991c242c9c71920169d6aa53ade7e444f338f4c8128"}, - {file = "pyzmq-25.0.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:54a96cf77684a3a537b76acfa7237b1e79a8f8d14e7f00e0171a94b346c5293e"}, - {file = "pyzmq-25.0.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:88649b19ede1cab03b96b66c364cbbf17c953615cdbc844f7f6e5f14c5e5261c"}, - {file = "pyzmq-25.0.2-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:715cff7644a80a7795953c11b067a75f16eb9fc695a5a53316891ebee7f3c9d5"}, - {file = "pyzmq-25.0.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:312b3f0f066b4f1d17383aae509bacf833ccaf591184a1f3c7a1661c085063ae"}, - {file = "pyzmq-25.0.2-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:d488c5c8630f7e782e800869f82744c3aca4aca62c63232e5d8c490d3d66956a"}, - {file = "pyzmq-25.0.2-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:38d9f78d69bcdeec0c11e0feb3bc70f36f9b8c44fc06e5d06d91dc0a21b453c7"}, - {file = "pyzmq-25.0.2-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:3059a6a534c910e1d5d068df42f60d434f79e6cc6285aa469b384fa921f78cf8"}, - {file = "pyzmq-25.0.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:6526d097b75192f228c09d48420854d53dfbc7abbb41b0e26f363ccb26fbc177"}, - {file = "pyzmq-25.0.2-cp311-cp311-win32.whl", hash = "sha256:5c5fbb229e40a89a2fe73d0c1181916f31e30f253cb2d6d91bea7927c2e18413"}, - {file = "pyzmq-25.0.2-cp311-cp311-win_amd64.whl", hash = "sha256:ed15e3a2c3c2398e6ae5ce86d6a31b452dfd6ad4cd5d312596b30929c4b6e182"}, - {file = "pyzmq-25.0.2-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:032f5c8483c85bf9c9ca0593a11c7c749d734ce68d435e38c3f72e759b98b3c9"}, - {file = "pyzmq-25.0.2-cp36-cp36m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:374b55516393bfd4d7a7daa6c3b36d6dd6a31ff9d2adad0838cd6a203125e714"}, - {file = "pyzmq-25.0.2-cp36-cp36m-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:08bfcc21b5997a9be4fefa405341320d8e7f19b4d684fb9c0580255c5bd6d695"}, - {file = "pyzmq-25.0.2-cp36-cp36m-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:1a843d26a8da1b752c74bc019c7b20e6791ee813cd6877449e6a1415589d22ff"}, - {file = "pyzmq-25.0.2-cp36-cp36m-musllinux_1_1_aarch64.whl", hash = "sha256:b48616a09d7df9dbae2f45a0256eee7b794b903ddc6d8657a9948669b345f220"}, - {file = "pyzmq-25.0.2-cp36-cp36m-musllinux_1_1_i686.whl", hash = "sha256:d4427b4a136e3b7f85516c76dd2e0756c22eec4026afb76ca1397152b0ca8145"}, - {file = "pyzmq-25.0.2-cp36-cp36m-musllinux_1_1_x86_64.whl", hash = "sha256:26b0358e8933990502f4513c991c9935b6c06af01787a36d133b7c39b1df37fa"}, - {file = "pyzmq-25.0.2-cp36-cp36m-win32.whl", hash = "sha256:c8fedc3ccd62c6b77dfe6f43802057a803a411ee96f14e946f4a76ec4ed0e117"}, - {file = "pyzmq-25.0.2-cp36-cp36m-win_amd64.whl", hash = "sha256:2da6813b7995b6b1d1307329c73d3e3be2fd2d78e19acfc4eff2e27262732388"}, - {file = "pyzmq-25.0.2-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:a35960c8b2f63e4ef67fd6731851030df68e4b617a6715dd11b4b10312d19fef"}, - {file = "pyzmq-25.0.2-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:eef2a0b880ab40aca5a878933376cb6c1ec483fba72f7f34e015c0f675c90b20"}, - {file = "pyzmq-25.0.2-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:85762712b74c7bd18e340c3639d1bf2f23735a998d63f46bb6584d904b5e401d"}, - {file = "pyzmq-25.0.2-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:64812f29d6eee565e129ca14b0c785744bfff679a4727137484101b34602d1a7"}, - {file = "pyzmq-25.0.2-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:510d8e55b3a7cd13f8d3e9121edf0a8730b87d925d25298bace29a7e7bc82810"}, - {file = "pyzmq-25.0.2-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:b164cc3c8acb3d102e311f2eb6f3c305865ecb377e56adc015cb51f721f1dda6"}, - {file = "pyzmq-25.0.2-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:28fdb9224a258134784a9cf009b59265a9dde79582fb750d4e88a6bcbc6fa3dc"}, - {file = "pyzmq-25.0.2-cp37-cp37m-win32.whl", hash = "sha256:dd771a440effa1c36d3523bc6ba4e54ff5d2e54b4adcc1e060d8f3ca3721d228"}, - {file = "pyzmq-25.0.2-cp37-cp37m-win_amd64.whl", hash = "sha256:9bdc40efb679b9dcc39c06d25629e55581e4c4f7870a5e88db4f1c51ce25e20d"}, - {file = "pyzmq-25.0.2-cp38-cp38-macosx_10_15_universal2.whl", hash = "sha256:1f82906a2d8e4ee310f30487b165e7cc8ed09c009e4502da67178b03083c4ce0"}, - {file = "pyzmq-25.0.2-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:21ec0bf4831988af43c8d66ba3ccd81af2c5e793e1bf6790eb2d50e27b3c570a"}, - {file = "pyzmq-25.0.2-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:abbce982a17c88d2312ec2cf7673985d444f1beaac6e8189424e0a0e0448dbb3"}, - {file = "pyzmq-25.0.2-cp38-cp38-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:9e1d2f2d86fc75ed7f8845a992c5f6f1ab5db99747fb0d78b5e4046d041164d2"}, - {file = "pyzmq-25.0.2-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a2e92ff20ad5d13266bc999a29ed29a3b5b101c21fdf4b2cf420c09db9fb690e"}, - {file = "pyzmq-25.0.2-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:edbbf06cc2719889470a8d2bf5072bb00f423e12de0eb9ffec946c2c9748e149"}, - {file = "pyzmq-25.0.2-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:77942243ff4d14d90c11b2afd8ee6c039b45a0be4e53fb6fa7f5e4fd0b59da39"}, - {file = "pyzmq-25.0.2-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:ab046e9cb902d1f62c9cc0eca055b1d11108bdc271caf7c2171487298f229b56"}, - {file = "pyzmq-25.0.2-cp38-cp38-win32.whl", hash = "sha256:ad761cfbe477236802a7ab2c080d268c95e784fe30cafa7e055aacd1ca877eb0"}, - {file = "pyzmq-25.0.2-cp38-cp38-win_amd64.whl", hash = "sha256:8560756318ec7c4c49d2c341012167e704b5a46d9034905853c3d1ade4f55bee"}, - {file = "pyzmq-25.0.2-cp39-cp39-macosx_10_15_universal2.whl", hash = "sha256:ab2c056ac503f25a63f6c8c6771373e2a711b98b304614151dfb552d3d6c81f6"}, - {file = "pyzmq-25.0.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:cca8524b61c0eaaa3505382dc9b9a3bc8165f1d6c010fdd1452c224225a26689"}, - {file = "pyzmq-25.0.2-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:cfb9f7eae02d3ac42fbedad30006b7407c984a0eb4189a1322241a20944d61e5"}, - {file = "pyzmq-25.0.2-cp39-cp39-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:5eaeae038c68748082137d6896d5c4db7927e9349237ded08ee1bbd94f7361c9"}, - {file = "pyzmq-25.0.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4a31992a8f8d51663ebf79df0df6a04ffb905063083d682d4380ab8d2c67257c"}, - {file = "pyzmq-25.0.2-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:6a979e59d2184a0c8f2ede4b0810cbdd86b64d99d9cc8a023929e40dce7c86cc"}, - {file = "pyzmq-25.0.2-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:1f124cb73f1aa6654d31b183810febc8505fd0c597afa127c4f40076be4574e0"}, - {file = "pyzmq-25.0.2-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:65c19a63b4a83ae45d62178b70223adeee5f12f3032726b897431b6553aa25af"}, - {file = "pyzmq-25.0.2-cp39-cp39-win32.whl", hash = "sha256:83d822e8687621bed87404afc1c03d83fa2ce39733d54c2fd52d8829edb8a7ff"}, - {file = "pyzmq-25.0.2-cp39-cp39-win_amd64.whl", hash = "sha256:24683285cc6b7bf18ad37d75b9db0e0fefe58404e7001f1d82bf9e721806daa7"}, - {file = "pyzmq-25.0.2-pp37-pypy37_pp73-macosx_10_9_x86_64.whl", hash = "sha256:4a4b4261eb8f9ed71f63b9eb0198dd7c934aa3b3972dac586d0ef502ba9ab08b"}, - {file = "pyzmq-25.0.2-pp37-pypy37_pp73-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:62ec8d979f56c0053a92b2b6a10ff54b9ec8a4f187db2b6ec31ee3dd6d3ca6e2"}, - {file = "pyzmq-25.0.2-pp37-pypy37_pp73-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:affec1470351178e892121b3414c8ef7803269f207bf9bef85f9a6dd11cde264"}, - {file = "pyzmq-25.0.2-pp37-pypy37_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ffc71111433bd6ec8607a37b9211f4ef42e3d3b271c6d76c813669834764b248"}, - {file = "pyzmq-25.0.2-pp37-pypy37_pp73-win_amd64.whl", hash = "sha256:6fadc60970714d86eff27821f8fb01f8328dd36bebd496b0564a500fe4a9e354"}, - {file = "pyzmq-25.0.2-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:269968f2a76c0513490aeb3ba0dc3c77b7c7a11daa894f9d1da88d4a0db09835"}, - {file = "pyzmq-25.0.2-pp38-pypy38_pp73-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:f7c8b8368e84381ae7c57f1f5283b029c888504aaf4949c32e6e6fb256ec9bf0"}, - {file = "pyzmq-25.0.2-pp38-pypy38_pp73-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:25e6873a70ad5aa31e4a7c41e5e8c709296edef4a92313e1cd5fc87bbd1874e2"}, - {file = "pyzmq-25.0.2-pp38-pypy38_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b733076ff46e7db5504c5e7284f04a9852c63214c74688bdb6135808531755a3"}, - {file = "pyzmq-25.0.2-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:a6f6ae12478fdc26a6d5fdb21f806b08fa5403cd02fd312e4cb5f72df078f96f"}, - {file = "pyzmq-25.0.2-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:67da1c213fbd208906ab3470cfff1ee0048838365135a9bddc7b40b11e6d6c89"}, - {file = "pyzmq-25.0.2-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:531e36d9fcd66f18de27434a25b51d137eb546931033f392e85674c7a7cea853"}, - {file = "pyzmq-25.0.2-pp39-pypy39_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:34a6fddd159ff38aa9497b2e342a559f142ab365576284bc8f77cb3ead1f79c5"}, - {file = "pyzmq-25.0.2-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b491998ef886662c1f3d49ea2198055a9a536ddf7430b051b21054f2a5831800"}, - {file = "pyzmq-25.0.2-pp39-pypy39_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:5d496815074e3e3d183fe2c7fcea2109ad67b74084c254481f87b64e04e9a471"}, - {file = "pyzmq-25.0.2-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:56a94ab1d12af982b55ca96c6853db6ac85505e820d9458ac76364c1998972f4"}, - {file = "pyzmq-25.0.2.tar.gz", hash = "sha256:6b8c1bbb70e868dc88801aa532cae6bd4e3b5233784692b786f17ad2962e5149"}, -] - -[package.dependencies] -cffi = {version = "*", markers = "implementation_name == \"pypy\""} - -[[package]] -name = "qtconsole" -version = "5.4.2" -description = "Jupyter Qt console" -category = "dev" -optional = false -python-versions = ">= 3.7" -files = [ - {file = "qtconsole-5.4.2-py3-none-any.whl", hash = "sha256:30975c6a7d7941dd646d00a23e5982db49beaa60c3920bb243727d43da805f12"}, - {file = "qtconsole-5.4.2.tar.gz", hash = "sha256:dc935780da276a2ab31a7a08a8cf327a2ea47fa27e21d485073251a7eeb16167"}, -] - -[package.dependencies] -ipykernel = ">=4.1" -ipython-genutils = "*" -jupyter-client = ">=4.1" -jupyter-core = "*" -packaging = "*" -pygments = "*" -pyzmq = ">=17.1" -qtpy = ">=2.0.1" -traitlets = "<5.2.1 || >5.2.1,<5.2.2 || >5.2.2" - -[package.extras] -doc = ["Sphinx (>=1.3)"] -test = ["flaky", "pytest", "pytest-qt"] - -[[package]] -name = "qtpy" -version = "2.3.1" -description = "Provides an abstraction layer on top of the various Qt bindings (PyQt5/6 and PySide2/6)." -category = "dev" -optional = false -python-versions = ">=3.7" -files = [ - {file = "QtPy-2.3.1-py3-none-any.whl", hash = "sha256:5193d20e0b16e4d9d3bc2c642d04d9f4e2c892590bd1b9c92bfe38a95d5a2e12"}, - {file = "QtPy-2.3.1.tar.gz", hash = "sha256:a8c74982d6d172ce124d80cafd39653df78989683f760f2281ba91a6e7b9de8b"}, -] - -[package.dependencies] -packaging = "*" - -[package.extras] -test = ["pytest (>=6,!=7.0.0,!=7.0.1)", "pytest-cov (>=3.0.0)", "pytest-qt"] - -[[package]] -name = "regex" -version = "2023.3.23" -description = "Alternative regular expression module, to replace re." -category = "dev" -optional = false -python-versions = ">=3.8" -files = [ - {file = "regex-2023.3.23-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:845a5e2d84389c4ddada1a9b95c055320070f18bb76512608374aca00d22eca8"}, - {file = "regex-2023.3.23-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:87d9951f5a538dd1d016bdc0dcae59241d15fa94860964833a54d18197fcd134"}, - {file = "regex-2023.3.23-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:37ae17d3be44c0b3f782c28ae9edd8b47c1f1776d4cabe87edc0b98e1f12b021"}, - {file = "regex-2023.3.23-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:0b8eb1e3bca6b48dc721818a60ae83b8264d4089a4a41d62be6d05316ec38e15"}, - {file = "regex-2023.3.23-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:df45fac182ebc3c494460c644e853515cc24f5ad9da05f8ffb91da891bfee879"}, - {file = "regex-2023.3.23-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b7006105b10b59971d3b248ad75acc3651c7e4cf54d81694df5a5130a3c3f7ea"}, - {file = "regex-2023.3.23-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:93f3f1aa608380fe294aa4cb82e2afda07a7598e828d0341e124b8fd9327c715"}, - {file = "regex-2023.3.23-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:787954f541ab95d8195d97b0b8cf1dc304424adb1e07365967e656b92b38a699"}, - {file = "regex-2023.3.23-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:20abe0bdf03630fe92ccafc45a599bca8b3501f48d1de4f7d121153350a2f77d"}, - {file = "regex-2023.3.23-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:11d00c31aeab9a6e0503bc77e73ed9f4527b3984279d997eb145d7c7be6268fd"}, - {file = "regex-2023.3.23-cp310-cp310-musllinux_1_1_ppc64le.whl", hash = "sha256:d5bbe0e1511b844794a3be43d6c145001626ba9a6c1db8f84bdc724e91131d9d"}, - {file = "regex-2023.3.23-cp310-cp310-musllinux_1_1_s390x.whl", hash = "sha256:ea3c0cb56eadbf4ab2277e7a095676370b3e46dbfc74d5c383bd87b0d6317910"}, - {file = "regex-2023.3.23-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:d895b4c863059a4934d3e874b90998df774644a41b349ebb330f85f11b4ef2c0"}, - {file = "regex-2023.3.23-cp310-cp310-win32.whl", hash = "sha256:9d764514d19b4edcc75fd8cb1423448ef393e8b6cbd94f38cab983ab1b75855d"}, - {file = "regex-2023.3.23-cp310-cp310-win_amd64.whl", hash = "sha256:11d1f2b7a0696dc0310de0efb51b1f4d813ad4401fe368e83c0c62f344429f98"}, - {file = "regex-2023.3.23-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:8a9c63cde0eaa345795c0fdeb19dc62d22e378c50b0bc67bf4667cd5b482d98b"}, - {file = "regex-2023.3.23-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:dd7200b4c27b68cf9c9646da01647141c6db09f48cc5b51bc588deaf8e98a797"}, - {file = "regex-2023.3.23-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:22720024b90a6ba673a725dcc62e10fb1111b889305d7c6b887ac7466b74bedb"}, - {file = "regex-2023.3.23-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6b190a339090e6af25f4a5fd9e77591f6d911cc7b96ecbb2114890b061be0ac1"}, - {file = "regex-2023.3.23-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e76b6fc0d8e9efa39100369a9b3379ce35e20f6c75365653cf58d282ad290f6f"}, - {file = "regex-2023.3.23-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7868b8f218bf69a2a15402fde08b08712213a1f4b85a156d90473a6fb6b12b09"}, - {file = "regex-2023.3.23-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:2472428efc4127374f494e570e36b30bb5e6b37d9a754f7667f7073e43b0abdd"}, - {file = "regex-2023.3.23-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:c37df2a060cb476d94c047b18572ee2b37c31f831df126c0da3cd9227b39253d"}, - {file = "regex-2023.3.23-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:4479f9e2abc03362df4045b1332d4a2b7885b245a30d4f4b051c4083b97d95d8"}, - {file = "regex-2023.3.23-cp311-cp311-musllinux_1_1_ppc64le.whl", hash = "sha256:e2396e0678167f2d0c197da942b0b3fb48fee2f0b5915a0feb84d11b6686afe6"}, - {file = "regex-2023.3.23-cp311-cp311-musllinux_1_1_s390x.whl", hash = "sha256:75f288c60232a5339e0ff2fa05779a5e9c74e9fc085c81e931d4a264501e745b"}, - {file = "regex-2023.3.23-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:c869260aa62cee21c5eb171a466c0572b5e809213612ef8d495268cd2e34f20d"}, - {file = "regex-2023.3.23-cp311-cp311-win32.whl", hash = "sha256:25f0532fd0c53e96bad84664171969de9673b4131f2297f1db850d3918d58858"}, - {file = "regex-2023.3.23-cp311-cp311-win_amd64.whl", hash = "sha256:5ccfafd98473e007cebf7da10c1411035b7844f0f204015efd050601906dbb53"}, - {file = "regex-2023.3.23-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:6572ff287176c0fb96568adb292674b421fa762153ed074d94b1d939ed92c253"}, - {file = "regex-2023.3.23-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:a610e0adfcb0fc84ea25f6ea685e39e74cbcd9245a72a9a7aab85ff755a5ed27"}, - {file = "regex-2023.3.23-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:086afe222d58b88b62847bdbd92079b4699350b4acab892f88a935db5707c790"}, - {file = "regex-2023.3.23-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:79e29fd62fa2f597a6754b247356bda14b866131a22444d67f907d6d341e10f3"}, - {file = "regex-2023.3.23-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c07ce8e9eee878a48ebeb32ee661b49504b85e164b05bebf25420705709fdd31"}, - {file = "regex-2023.3.23-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:86b036f401895e854de9fefe061518e78d506d8a919cc250dc3416bca03f6f9a"}, - {file = "regex-2023.3.23-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:78ac8dd8e18800bb1f97aad0d73f68916592dddf233b99d2b5cabc562088503a"}, - {file = "regex-2023.3.23-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:539dd010dc35af935b32f248099e38447bbffc10b59c2b542bceead2bed5c325"}, - {file = "regex-2023.3.23-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:9bf4a5626f2a0ea006bf81e8963f498a57a47d58907eaa58f4b3e13be68759d8"}, - {file = "regex-2023.3.23-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:cf86b4328c204c3f315074a61bc1c06f8a75a8e102359f18ce99fbcbbf1951f0"}, - {file = "regex-2023.3.23-cp38-cp38-musllinux_1_1_ppc64le.whl", hash = "sha256:2848bf76673c83314068241c8d5b7fa9ad9bed866c979875a0e84039349e8fa7"}, - {file = "regex-2023.3.23-cp38-cp38-musllinux_1_1_s390x.whl", hash = "sha256:c125a02d22c555e68f7433bac8449992fa1cead525399f14e47c2d98f2f0e467"}, - {file = "regex-2023.3.23-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:cd1671e9d5ac05ce6aa86874dd8dfa048824d1dbe73060851b310c6c1a201a96"}, - {file = "regex-2023.3.23-cp38-cp38-win32.whl", hash = "sha256:fffe57312a358be6ec6baeb43d253c36e5790e436b7bf5b7a38df360363e88e9"}, - {file = "regex-2023.3.23-cp38-cp38-win_amd64.whl", hash = "sha256:dbb3f87e15d3dd76996d604af8678316ad2d7d20faa394e92d9394dfd621fd0c"}, - {file = "regex-2023.3.23-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:c88e8c226473b5549fe9616980ea7ca09289246cfbdf469241edf4741a620004"}, - {file = "regex-2023.3.23-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:6560776ec19c83f3645bbc5db64a7a5816c9d8fb7ed7201c5bcd269323d88072"}, - {file = "regex-2023.3.23-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1b1fc2632c01f42e06173d8dd9bb2e74ab9b0afa1d698058c867288d2c7a31f3"}, - {file = "regex-2023.3.23-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:fdf7ad455f1916b8ea5cdbc482d379f6daf93f3867b4232d14699867a5a13af7"}, - {file = "regex-2023.3.23-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5fc33b27b1d800fc5b78d7f7d0f287e35079ecabe68e83d46930cf45690e1c8c"}, - {file = "regex-2023.3.23-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4c49552dc938e3588f63f8a78c86f3c9c75301e813bca0bef13bdb4b87ccf364"}, - {file = "regex-2023.3.23-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e152461e9a0aedec7d37fc66ec0fa635eca984777d3d3c3e36f53bf3d3ceb16e"}, - {file = "regex-2023.3.23-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:db034255e72d2995cf581b14bb3fc9c00bdbe6822b49fcd4eef79e1d5f232618"}, - {file = "regex-2023.3.23-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:55ae114da21b7a790b90255ea52d2aa3a0d121a646deb2d3c6a3194e722fc762"}, - {file = "regex-2023.3.23-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:ef3f528fe1cc3d139508fe1b22523745aa77b9d6cb5b0bf277f48788ee0b993f"}, - {file = "regex-2023.3.23-cp39-cp39-musllinux_1_1_ppc64le.whl", hash = "sha256:a81c9ec59ca2303acd1ccd7b9ac409f1e478e40e96f8f79b943be476c5fdb8bb"}, - {file = "regex-2023.3.23-cp39-cp39-musllinux_1_1_s390x.whl", hash = "sha256:cde09c4fdd070772aa2596d97e942eb775a478b32459e042e1be71b739d08b77"}, - {file = "regex-2023.3.23-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:3cd9f5dd7b821f141d3a6ca0d5d9359b9221e4f051ca3139320adea9f1679691"}, - {file = "regex-2023.3.23-cp39-cp39-win32.whl", hash = "sha256:7304863f3a652dab5e68e6fb1725d05ebab36ec0390676d1736e0571ebb713ef"}, - {file = "regex-2023.3.23-cp39-cp39-win_amd64.whl", hash = "sha256:54c3fa855a3f7438149de3211738dd9b5f0c733f48b54ae05aa7fce83d48d858"}, - {file = "regex-2023.3.23.tar.gz", hash = "sha256:dc80df325b43ffea5cdea2e3eaa97a44f3dd298262b1c7fe9dbb2a9522b956a7"}, -] - -[[package]] -name = "requests" -version = "2.31.0" -description = "Python HTTP for Humans." -category = "dev" -optional = false -python-versions = ">=3.7" -files = [ - {file = "requests-2.31.0-py3-none-any.whl", hash = "sha256:58cd2187c01e70e6e26505bca751777aa9f2ee0b7f4300988b709f44e013003f"}, - {file = "requests-2.31.0.tar.gz", hash = "sha256:942c5a758f98d790eaed1a29cb6eefc7ffb0d1cf7af05c3d2791656dbd6ad1e1"}, -] - -[package.dependencies] -certifi = ">=2017.4.17" -charset-normalizer = ">=2,<4" -idna = ">=2.5,<4" -urllib3 = ">=1.21.1,<3" - -[package.extras] -socks = ["PySocks (>=1.5.6,!=1.5.7)"] -use-chardet-on-py3 = ["chardet (>=3.0.2,<6)"] - -[[package]] -name = "rfc3339-validator" -version = "0.1.4" -description = "A pure python RFC3339 validator" -category = "dev" -optional = false -python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*" -files = [ - {file = "rfc3339_validator-0.1.4-py2.py3-none-any.whl", hash = "sha256:24f6ec1eda14ef823da9e36ec7113124b39c04d50a4d3d3a3c2859577e7791fa"}, - {file = "rfc3339_validator-0.1.4.tar.gz", hash = "sha256:138a2abdf93304ad60530167e51d2dfb9549521a836871b88d7f4695d0022f6b"}, -] - -[package.dependencies] -six = "*" - -[[package]] -name = "rfc3986-validator" -version = "0.1.1" -description = "Pure python rfc3986 validator" -category = "dev" -optional = false -python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*" -files = [ - {file = "rfc3986_validator-0.1.1-py2.py3-none-any.whl", hash = "sha256:2f235c432ef459970b4306369336b9d5dbdda31b510ca1e327636e01f528bfa9"}, - {file = "rfc3986_validator-0.1.1.tar.gz", hash = "sha256:3d44bde7921b3b9ec3ae4e3adca370438eccebc676456449b145d533b240d055"}, -] - -[[package]] -name = "scikit-learn" -version = "1.2.2" -description = "A set of python modules for machine learning and data mining" -category = "main" -optional = false -python-versions = ">=3.8" -files = [ - {file = "scikit-learn-1.2.2.tar.gz", hash = "sha256:8429aea30ec24e7a8c7ed8a3fa6213adf3814a6efbea09e16e0a0c71e1a1a3d7"}, - {file = "scikit_learn-1.2.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:99cc01184e347de485bf253d19fcb3b1a3fb0ee4cea5ee3c43ec0cc429b6d29f"}, - {file = "scikit_learn-1.2.2-cp310-cp310-macosx_12_0_arm64.whl", hash = "sha256:e6e574db9914afcb4e11ade84fab084536a895ca60aadea3041e85b8ac963edb"}, - {file = "scikit_learn-1.2.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6fe83b676f407f00afa388dd1fdd49e5c6612e551ed84f3b1b182858f09e987d"}, - {file = "scikit_learn-1.2.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2e2642baa0ad1e8f8188917423dd73994bf25429f8893ddbe115be3ca3183584"}, - {file = "scikit_learn-1.2.2-cp310-cp310-win_amd64.whl", hash = "sha256:ad66c3848c0a1ec13464b2a95d0a484fd5b02ce74268eaa7e0c697b904f31d6c"}, - {file = "scikit_learn-1.2.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:dfeaf8be72117eb61a164ea6fc8afb6dfe08c6f90365bde2dc16456e4bc8e45f"}, - {file = "scikit_learn-1.2.2-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:fe0aa1a7029ed3e1dcbf4a5bc675aa3b1bc468d9012ecf6c6f081251ca47f590"}, - {file = "scikit_learn-1.2.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:065e9673e24e0dc5113e2dd2b4ca30c9d8aa2fa90f4c0597241c93b63130d233"}, - {file = "scikit_learn-1.2.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bf036ea7ef66115e0d49655f16febfa547886deba20149555a41d28f56fd6d3c"}, - {file = "scikit_learn-1.2.2-cp311-cp311-win_amd64.whl", hash = "sha256:8b0670d4224a3c2d596fd572fb4fa673b2a0ccfb07152688ebd2ea0b8c61025c"}, - {file = "scikit_learn-1.2.2-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:9c710ff9f9936ba8a3b74a455ccf0dcf59b230caa1e9ba0223773c490cab1e51"}, - {file = "scikit_learn-1.2.2-cp38-cp38-macosx_12_0_arm64.whl", hash = "sha256:2dd3ffd3950e3d6c0c0ef9033a9b9b32d910c61bd06cb8206303fb4514b88a49"}, - {file = "scikit_learn-1.2.2-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:44b47a305190c28dd8dd73fc9445f802b6ea716669cfc22ab1eb97b335d238b1"}, - {file = "scikit_learn-1.2.2-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:953236889928d104c2ef14027539f5f2609a47ebf716b8cbe4437e85dce42744"}, - {file = "scikit_learn-1.2.2-cp38-cp38-win_amd64.whl", hash = "sha256:7f69313884e8eb311460cc2f28676d5e400bd929841a2c8eb8742ae78ebf7c20"}, - {file = "scikit_learn-1.2.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:8156db41e1c39c69aa2d8599ab7577af53e9e5e7a57b0504e116cc73c39138dd"}, - {file = "scikit_learn-1.2.2-cp39-cp39-macosx_12_0_arm64.whl", hash = "sha256:fe175ee1dab589d2e1033657c5b6bec92a8a3b69103e3dd361b58014729975c3"}, - {file = "scikit_learn-1.2.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7d5312d9674bed14f73773d2acf15a3272639b981e60b72c9b190a0cffed5bad"}, - {file = "scikit_learn-1.2.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ea061bf0283bf9a9f36ea3c5d3231ba2176221bbd430abd2603b1c3b2ed85c89"}, - {file = "scikit_learn-1.2.2-cp39-cp39-win_amd64.whl", hash = "sha256:6477eed40dbce190f9f9e9d0d37e020815825b300121307942ec2110302b66a3"}, -] - -[package.dependencies] -joblib = ">=1.1.1" -numpy = ">=1.17.3" -scipy = ">=1.3.2" -threadpoolctl = ">=2.0.0" - -[package.extras] -benchmark = ["matplotlib (>=3.1.3)", "memory-profiler (>=0.57.0)", "pandas (>=1.0.5)"] -docs = ["Pillow (>=7.1.2)", "matplotlib (>=3.1.3)", "memory-profiler (>=0.57.0)", "numpydoc (>=1.2.0)", "pandas (>=1.0.5)", "plotly (>=5.10.0)", "pooch (>=1.6.0)", "scikit-image (>=0.16.2)", "seaborn (>=0.9.0)", "sphinx (>=4.0.1)", "sphinx-gallery (>=0.7.0)", "sphinx-prompt (>=1.3.0)", "sphinxext-opengraph (>=0.4.2)"] -examples = ["matplotlib (>=3.1.3)", "pandas (>=1.0.5)", "plotly (>=5.10.0)", "pooch (>=1.6.0)", "scikit-image (>=0.16.2)", "seaborn (>=0.9.0)"] -tests = ["black (>=22.3.0)", "flake8 (>=3.8.2)", "matplotlib (>=3.1.3)", "mypy (>=0.961)", "numpydoc (>=1.2.0)", "pandas (>=1.0.5)", "pooch (>=1.6.0)", "pyamg (>=4.0.0)", "pytest (>=5.3.1)", "pytest-cov (>=2.9.0)", "scikit-image (>=0.16.2)"] - -[[package]] -name = "scipy" -version = "1.10.1" -description = "Fundamental algorithms for scientific computing in Python" -category = "main" -optional = false -python-versions = "<3.12,>=3.8" -files = [ - {file = "scipy-1.10.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:e7354fd7527a4b0377ce55f286805b34e8c54b91be865bac273f527e1b839019"}, - {file = "scipy-1.10.1-cp310-cp310-macosx_12_0_arm64.whl", hash = "sha256:4b3f429188c66603a1a5c549fb414e4d3bdc2a24792e061ffbd607d3d75fd84e"}, - {file = "scipy-1.10.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1553b5dcddd64ba9a0d95355e63fe6c3fc303a8fd77c7bc91e77d61363f7433f"}, - {file = "scipy-1.10.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4c0ff64b06b10e35215abce517252b375e580a6125fd5fdf6421b98efbefb2d2"}, - {file = "scipy-1.10.1-cp310-cp310-win_amd64.whl", hash = "sha256:fae8a7b898c42dffe3f7361c40d5952b6bf32d10c4569098d276b4c547905ee1"}, - {file = "scipy-1.10.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:0f1564ea217e82c1bbe75ddf7285ba0709ecd503f048cb1236ae9995f64217bd"}, - {file = "scipy-1.10.1-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:d925fa1c81b772882aa55bcc10bf88324dadb66ff85d548c71515f6689c6dac5"}, - {file = "scipy-1.10.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:aaea0a6be54462ec027de54fca511540980d1e9eea68b2d5c1dbfe084797be35"}, - {file = "scipy-1.10.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:15a35c4242ec5f292c3dd364a7c71a61be87a3d4ddcc693372813c0b73c9af1d"}, - {file = "scipy-1.10.1-cp311-cp311-win_amd64.whl", hash = "sha256:43b8e0bcb877faf0abfb613d51026cd5cc78918e9530e375727bf0625c82788f"}, - {file = "scipy-1.10.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:5678f88c68ea866ed9ebe3a989091088553ba12c6090244fdae3e467b1139c35"}, - {file = "scipy-1.10.1-cp38-cp38-macosx_12_0_arm64.whl", hash = "sha256:39becb03541f9e58243f4197584286e339029e8908c46f7221abeea4b749fa88"}, - {file = "scipy-1.10.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bce5869c8d68cf383ce240e44c1d9ae7c06078a9396df68ce88a1230f93a30c1"}, - {file = "scipy-1.10.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:07c3457ce0b3ad5124f98a86533106b643dd811dd61b548e78cf4c8786652f6f"}, - {file = "scipy-1.10.1-cp38-cp38-win_amd64.whl", hash = "sha256:049a8bbf0ad95277ffba9b3b7d23e5369cc39e66406d60422c8cfef40ccc8415"}, - {file = "scipy-1.10.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:cd9f1027ff30d90618914a64ca9b1a77a431159df0e2a195d8a9e8a04c78abf9"}, - {file = "scipy-1.10.1-cp39-cp39-macosx_12_0_arm64.whl", hash = "sha256:79c8e5a6c6ffaf3a2262ef1be1e108a035cf4f05c14df56057b64acc5bebffb6"}, - {file = "scipy-1.10.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:51af417a000d2dbe1ec6c372dfe688e041a7084da4fdd350aeb139bd3fb55353"}, - {file = "scipy-1.10.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1b4735d6c28aad3cdcf52117e0e91d6b39acd4272f3f5cd9907c24ee931ad601"}, - {file = "scipy-1.10.1-cp39-cp39-win_amd64.whl", hash = "sha256:7ff7f37b1bf4417baca958d254e8e2875d0cc23aaadbe65b3d5b3077b0eb23ea"}, - {file = "scipy-1.10.1.tar.gz", hash = "sha256:2cf9dfb80a7b4589ba4c40ce7588986d6d5cebc5457cad2c2880f6bc2d42f3a5"}, -] - -[package.dependencies] -numpy = ">=1.19.5,<1.27.0" - -[package.extras] -dev = ["click", "doit (>=0.36.0)", "flake8", "mypy", "pycodestyle", "pydevtool", "rich-click", "typing_extensions"] -doc = ["matplotlib (>2)", "numpydoc", "pydata-sphinx-theme (==0.9.0)", "sphinx (!=4.1.0)", "sphinx-design (>=0.2.0)"] -test = ["asv", "gmpy2", "mpmath", "pooch", "pytest", "pytest-cov", "pytest-timeout", "pytest-xdist", "scikit-umfpack", "threadpoolctl"] - -[[package]] -name = "seaborn" -version = "0.12.2" -description = "Statistical data visualization" -category = "main" -optional = false -python-versions = ">=3.7" -files = [ - {file = "seaborn-0.12.2-py3-none-any.whl", hash = "sha256:ebf15355a4dba46037dfd65b7350f014ceb1f13c05e814eda2c9f5fd731afc08"}, - {file = "seaborn-0.12.2.tar.gz", hash = "sha256:374645f36509d0dcab895cba5b47daf0586f77bfe3b36c97c607db7da5be0139"}, -] - -[package.dependencies] -matplotlib = ">=3.1,<3.6.1 || >3.6.1" -numpy = ">=1.17,<1.24.0 || >1.24.0" -pandas = ">=0.25" - -[package.extras] -dev = ["flake8", "flit", "mypy", "pandas-stubs", "pre-commit", "pytest", "pytest-cov", "pytest-xdist"] -docs = ["ipykernel", "nbconvert", "numpydoc", "pydata_sphinx_theme (==0.10.0rc2)", "pyyaml", "sphinx-copybutton", "sphinx-design", "sphinx-issues"] -stats = ["scipy (>=1.3)", "statsmodels (>=0.10)"] - -[[package]] -name = "send2trash" -version = "1.8.0" -description = "Send file to trash natively under Mac OS X, Windows and Linux." -category = "dev" -optional = false -python-versions = "*" -files = [ - {file = "Send2Trash-1.8.0-py3-none-any.whl", hash = "sha256:f20eaadfdb517eaca5ce077640cb261c7d2698385a6a0f072a4a5447fd49fa08"}, - {file = "Send2Trash-1.8.0.tar.gz", hash = "sha256:d2c24762fd3759860a0aff155e45871447ea58d2be6bdd39b5c8f966a0c99c2d"}, -] - -[package.extras] -nativelib = ["pyobjc-framework-Cocoa", "pywin32"] -objc = ["pyobjc-framework-Cocoa"] -win32 = ["pywin32"] - -[[package]] -name = "setuptools" -version = "67.6.1" -description = "Easily download, build, install, upgrade, and uninstall Python packages" -category = "main" -optional = false -python-versions = ">=3.7" -files = [ - {file = "setuptools-67.6.1-py3-none-any.whl", hash = "sha256:e728ca814a823bf7bf60162daf9db95b93d532948c4c0bea762ce62f60189078"}, - {file = "setuptools-67.6.1.tar.gz", hash = "sha256:257de92a9d50a60b8e22abfcbb771571fde0dbf3ec234463212027a4eeecbe9a"}, -] - -[package.extras] -docs = ["furo", "jaraco.packaging (>=9)", "jaraco.tidelift (>=1.4)", "pygments-github-lexers (==0.0.5)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-favicon", "sphinx-hoverxref (<2)", "sphinx-inline-tabs", "sphinx-lint", "sphinx-notfound-page (==0.8.3)", "sphinx-reredirects", "sphinxcontrib-towncrier"] -testing = ["build[virtualenv]", "filelock (>=3.4.0)", "flake8 (<5)", "flake8-2020", "ini2toml[lite] (>=0.9)", "jaraco.envs (>=2.2)", "jaraco.path (>=3.2.0)", "pip (>=19.1)", "pip-run (>=8.8)", "pytest (>=6)", "pytest-black (>=0.3.7)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=1.3)", "pytest-flake8", "pytest-mypy (>=0.9.1)", "pytest-perf", "pytest-timeout", "pytest-xdist", "tomli-w (>=1.0.0)", "virtualenv (>=13.0.0)", "wheel"] -testing-integration = ["build[virtualenv]", "filelock (>=3.4.0)", "jaraco.envs (>=2.2)", "jaraco.path (>=3.2.0)", "pytest", "pytest-enabler", "pytest-xdist", "tomli", "virtualenv (>=13.0.0)", "wheel"] - -[[package]] -name = "six" -version = "1.16.0" -description = "Python 2 and 3 compatibility utilities" -category = "main" -optional = false -python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*" -files = [ - {file = "six-1.16.0-py2.py3-none-any.whl", hash = "sha256:8abb2f1d86890a2dfb989f9a77cfcfd3e47c2a354b01111771326f8aa26e0254"}, - {file = "six-1.16.0.tar.gz", hash = "sha256:1e61c37477a1626458e36f7b1d82aa5c9b094fa4802892072e49de9c60c4c926"}, -] - -[[package]] -name = "sniffio" -version = "1.3.0" -description = "Sniff out which async library your code is running under" -category = "dev" -optional = false -python-versions = ">=3.7" -files = [ - {file = "sniffio-1.3.0-py3-none-any.whl", hash = "sha256:eecefdce1e5bbfb7ad2eeaabf7c1eeb404d7757c379bd1f7e5cce9d8bf425384"}, - {file = "sniffio-1.3.0.tar.gz", hash = "sha256:e60305c5e5d314f5389259b7f22aaa33d8f7dee49763119234af3755c55b9101"}, -] - -[[package]] -name = "soupsieve" -version = "2.4" -description = "A modern CSS selector implementation for Beautiful Soup." -category = "dev" -optional = false -python-versions = ">=3.7" -files = [ - {file = "soupsieve-2.4-py3-none-any.whl", hash = "sha256:49e5368c2cda80ee7e84da9dbe3e110b70a4575f196efb74e51b94549d921955"}, - {file = "soupsieve-2.4.tar.gz", hash = "sha256:e28dba9ca6c7c00173e34e4ba57448f0688bb681b7c5e8bf4971daafc093d69a"}, -] - -[[package]] -name = "stack-data" -version = "0.6.2" -description = "Extract data from python stack frames and tracebacks for informative displays" -category = "dev" -optional = false -python-versions = "*" -files = [ - {file = "stack_data-0.6.2-py3-none-any.whl", hash = "sha256:cbb2a53eb64e5785878201a97ed7c7b94883f48b87bfb0bbe8b623c74679e4a8"}, - {file = "stack_data-0.6.2.tar.gz", hash = "sha256:32d2dd0376772d01b6cb9fc996f3c8b57a357089dec328ed4b6553d037eaf815"}, -] - -[package.dependencies] -asttokens = ">=2.1.0" -executing = ">=1.2.0" -pure-eval = "*" - -[package.extras] -tests = ["cython", "littleutils", "pygments", "pytest", "typeguard"] - -[[package]] -name = "sympy" -version = "1.12" -description = "Computer algebra system (CAS) in Python" -category = "main" -optional = false -python-versions = ">=3.8" -files = [ - {file = "sympy-1.12-py3-none-any.whl", hash = "sha256:c3588cd4295d0c0f603d0f2ae780587e64e2efeedb3521e46b9bb1d08d184fa5"}, - {file = "sympy-1.12.tar.gz", hash = "sha256:ebf595c8dac3e0fdc4152c51878b498396ec7f30e7a914d6071e674d49420fb8"}, -] - -[package.dependencies] -mpmath = ">=0.19" - -[[package]] -name = "terminado" -version = "0.17.1" -description = "Tornado websocket backend for the Xterm.js Javascript terminal emulator library." -category = "dev" -optional = false -python-versions = ">=3.7" -files = [ - {file = "terminado-0.17.1-py3-none-any.whl", hash = "sha256:8650d44334eba354dd591129ca3124a6ba42c3d5b70df5051b6921d506fdaeae"}, - {file = "terminado-0.17.1.tar.gz", hash = "sha256:6ccbbcd3a4f8a25a5ec04991f39a0b8db52dfcd487ea0e578d977e6752380333"}, -] - -[package.dependencies] -ptyprocess = {version = "*", markers = "os_name != \"nt\""} -pywinpty = {version = ">=1.1.0", markers = "os_name == \"nt\""} -tornado = ">=6.1.0" - -[package.extras] -docs = ["myst-parser", "pydata-sphinx-theme", "sphinx"] -test = ["pre-commit", "pytest (>=7.0)", "pytest-timeout"] - -[[package]] -name = "threadpoolctl" -version = "3.1.0" -description = "threadpoolctl" -category = "main" -optional = false -python-versions = ">=3.6" -files = [ - {file = "threadpoolctl-3.1.0-py3-none-any.whl", hash = "sha256:8b99adda265feb6773280df41eece7b2e6561b772d21ffd52e372f999024907b"}, - {file = "threadpoolctl-3.1.0.tar.gz", hash = "sha256:a335baacfaa4400ae1f0d8e3a58d6674d2f8828e3716bb2802c44955ad391380"}, -] - -[[package]] -name = "tinkerforge" -version = "2.1.30" -description = "Python API Bindings for Tinkerforge Bricks and Bricklets" -category = "main" -optional = true -python-versions = "*" -files = [ - {file = "tinkerforge-2.1.30.tar.gz", hash = "sha256:76f0c32b2e21571444ca1e46fa7bb65a71fe88531ec413c528aa2430704589b7"}, -] - -[[package]] -name = "tinycss2" -version = "1.2.1" -description = "A tiny CSS parser" -category = "dev" -optional = false -python-versions = ">=3.7" -files = [ - {file = "tinycss2-1.2.1-py3-none-any.whl", hash = "sha256:2b80a96d41e7c3914b8cda8bc7f705a4d9c49275616e886103dd839dfc847847"}, - {file = "tinycss2-1.2.1.tar.gz", hash = "sha256:8cff3a8f066c2ec677c06dbc7b45619804a6938478d9d73c284b29d14ecb0627"}, -] - -[package.dependencies] -webencodings = ">=0.4" - -[package.extras] -doc = ["sphinx", "sphinx_rtd_theme"] -test = ["flake8", "isort", "pytest"] - -[[package]] -name = "toml" -version = "0.10.2" -description = "Python Library for Tom's Obvious, Minimal Language" -category = "dev" -optional = false -python-versions = ">=2.6, !=3.0.*, !=3.1.*, !=3.2.*" -files = [ - {file = "toml-0.10.2-py2.py3-none-any.whl", hash = "sha256:806143ae5bfb6a3c6e736a764057db0e6a0e05e338b5630894a5f779cabb4f9b"}, - {file = "toml-0.10.2.tar.gz", hash = "sha256:b3bda1d108d5dd99f4a20d24d9c348e91c4db7ab1b749200bded2f839ccbe68f"}, -] - -[[package]] -name = "tomli" -version = "2.0.1" -description = "A lil' TOML parser" -category = "dev" -optional = false -python-versions = ">=3.7" -files = [ - {file = "tomli-2.0.1-py3-none-any.whl", hash = "sha256:939de3e7a6161af0c887ef91b7d41a53e7c5a1ca976325f429cb46ea9bc30ecc"}, - {file = "tomli-2.0.1.tar.gz", hash = "sha256:de526c12914f0c550d15924c62d72abc48d6fe7364aa87328337a31007fe8a4f"}, -] - -[[package]] -name = "torch" -version = "2.0.0" -description = "Tensors and Dynamic neural networks in Python with strong GPU acceleration" -category = "main" -optional = false -python-versions = ">=3.8.0" -files = [ - {file = "torch-2.0.0-1-cp310-cp310-manylinux2014_aarch64.whl", hash = "sha256:c9090bda7d2eeeecd74f51b721420dbeb44f838d4536cc1b284e879417e3064a"}, - {file = "torch-2.0.0-1-cp311-cp311-manylinux2014_aarch64.whl", hash = "sha256:bd42db2a48a20574d2c33489e120e9f32789c4dc13c514b0c44272972d14a2d7"}, - {file = "torch-2.0.0-1-cp38-cp38-manylinux2014_aarch64.whl", hash = "sha256:8969aa8375bcbc0c2993e7ede0a7f889df9515f18b9b548433f412affed478d9"}, - {file = "torch-2.0.0-1-cp39-cp39-manylinux2014_aarch64.whl", hash = "sha256:ab2da16567cb55b67ae39e32d520d68ec736191d88ac79526ca5874754c32203"}, - {file = "torch-2.0.0-cp310-cp310-manylinux1_x86_64.whl", hash = "sha256:7a9319a67294ef02459a19738bbfa8727bb5307b822dadd708bc2ccf6c901aca"}, - {file = "torch-2.0.0-cp310-cp310-manylinux2014_aarch64.whl", hash = "sha256:9f01fe1f6263f31bd04e1757946fd63ad531ae37f28bb2dbf66f5c826ee089f4"}, - {file = "torch-2.0.0-cp310-cp310-win_amd64.whl", hash = "sha256:527f4ae68df7b8301ee6b1158ca56350282ea633686537b30dbb5d7b4a52622a"}, - {file = "torch-2.0.0-cp310-none-macosx_10_9_x86_64.whl", hash = "sha256:ce9b5a49bd513dff7950a5a07d6e26594dd51989cee05ba388b03e8e366fd5d5"}, - {file = "torch-2.0.0-cp310-none-macosx_11_0_arm64.whl", hash = "sha256:53e1c33c6896583cdb9a583693e22e99266444c4a43392dddc562640d39e542b"}, - {file = "torch-2.0.0-cp311-cp311-manylinux1_x86_64.whl", hash = "sha256:09651bff72e439d004c991f15add0c397c66f98ab36fe60d5514b44e4da722e8"}, - {file = "torch-2.0.0-cp311-cp311-manylinux2014_aarch64.whl", hash = "sha256:d439aec349c98f12819e8564b8c54008e4613dd4428582af0e6e14c24ca85870"}, - {file = "torch-2.0.0-cp311-cp311-win_amd64.whl", hash = "sha256:2802f84f021907deee7e9470ed10c0e78af7457ac9a08a6cd7d55adef835fede"}, - {file = "torch-2.0.0-cp311-none-macosx_10_9_x86_64.whl", hash = "sha256:01858620f25f25e7a9ec4b547ff38e5e27c92d38ec4ccba9cfbfb31d7071ed9c"}, - {file = "torch-2.0.0-cp311-none-macosx_11_0_arm64.whl", hash = "sha256:9a2e53b5783ef5896a6af338b36d782f28e83c8ddfc2ac44b67b066d9d76f498"}, - {file = "torch-2.0.0-cp38-cp38-manylinux1_x86_64.whl", hash = "sha256:ec5fff2447663e369682838ff0f82187b4d846057ef4d119a8dea7772a0b17dd"}, - {file = "torch-2.0.0-cp38-cp38-manylinux2014_aarch64.whl", hash = "sha256:11b0384fe3c18c01b8fc5992e70fc519cde65e44c51cc87be1838c1803daf42f"}, - {file = "torch-2.0.0-cp38-cp38-win_amd64.whl", hash = "sha256:e54846aa63855298cfb1195487f032e413e7ac9cbfa978fda32354cc39551475"}, - {file = "torch-2.0.0-cp38-none-macosx_10_9_x86_64.whl", hash = "sha256:cc788cbbbbc6eb4c90e52c550efd067586c2693092cf367c135b34893a64ae78"}, - {file = "torch-2.0.0-cp38-none-macosx_11_0_arm64.whl", hash = "sha256:d292640f0fd72b7a31b2a6e3b635eb5065fcbedd4478f9cad1a1e7a9ec861d35"}, - {file = "torch-2.0.0-cp39-cp39-manylinux1_x86_64.whl", hash = "sha256:6befaad784004b7af357e3d87fa0863c1f642866291f12a4c2af2de435e8ac5c"}, - {file = "torch-2.0.0-cp39-cp39-manylinux2014_aarch64.whl", hash = "sha256:a83b26bd6ae36fbf5fee3d56973d9816e2002e8a3b7d9205531167c28aaa38a7"}, - {file = "torch-2.0.0-cp39-cp39-win_amd64.whl", hash = "sha256:c7e67195e1c3e33da53954b026e89a8e1ff3bc1aeb9eb32b677172d4a9b5dcbf"}, - {file = "torch-2.0.0-cp39-none-macosx_10_9_x86_64.whl", hash = "sha256:6e0b97beb037a165669c312591f242382e9109a240e20054d5a5782d9236cad0"}, - {file = "torch-2.0.0-cp39-none-macosx_11_0_arm64.whl", hash = "sha256:297a4919aff1c0f98a58ebe969200f71350a1d4d4f986dbfd60c02ffce780e99"}, -] - -[package.dependencies] -filelock = "*" -jinja2 = "*" -networkx = "*" -nvidia-cublas-cu11 = {version = "11.10.3.66", markers = "platform_system == \"Linux\" and platform_machine == \"x86_64\""} -nvidia-cuda-cupti-cu11 = {version = "11.7.101", markers = "platform_system == \"Linux\" and platform_machine == \"x86_64\""} -nvidia-cuda-nvrtc-cu11 = {version = "11.7.99", markers = "platform_system == \"Linux\" and platform_machine == \"x86_64\""} -nvidia-cuda-runtime-cu11 = {version = "11.7.99", markers = "platform_system == \"Linux\" and platform_machine == \"x86_64\""} -nvidia-cudnn-cu11 = {version = "8.5.0.96", markers = "platform_system == \"Linux\" and platform_machine == \"x86_64\""} -nvidia-cufft-cu11 = {version = "10.9.0.58", markers = "platform_system == \"Linux\" and platform_machine == \"x86_64\""} -nvidia-curand-cu11 = {version = "10.2.10.91", markers = "platform_system == \"Linux\" and platform_machine == \"x86_64\""} -nvidia-cusolver-cu11 = {version = "11.4.0.1", markers = "platform_system == \"Linux\" and platform_machine == \"x86_64\""} -nvidia-cusparse-cu11 = {version = "11.7.4.91", markers = "platform_system == \"Linux\" and platform_machine == \"x86_64\""} -nvidia-nccl-cu11 = {version = "2.14.3", markers = "platform_system == \"Linux\" and platform_machine == \"x86_64\""} -nvidia-nvtx-cu11 = {version = "11.7.91", markers = "platform_system == \"Linux\" and platform_machine == \"x86_64\""} -sympy = "*" -triton = {version = "2.0.0", markers = "platform_system == \"Linux\" and platform_machine == \"x86_64\""} -typing-extensions = "*" - -[package.extras] -opt-einsum = ["opt-einsum (>=3.3)"] - -[[package]] -name = "tornado" -version = "6.3.2" -description = "Tornado is a Python web framework and asynchronous networking library, originally developed at FriendFeed." -category = "dev" -optional = false -python-versions = ">= 3.8" -files = [ - {file = "tornado-6.3.2-cp38-abi3-macosx_10_9_universal2.whl", hash = "sha256:c367ab6c0393d71171123ca5515c61ff62fe09024fa6bf299cd1339dc9456829"}, - {file = "tornado-6.3.2-cp38-abi3-macosx_10_9_x86_64.whl", hash = "sha256:b46a6ab20f5c7c1cb949c72c1994a4585d2eaa0be4853f50a03b5031e964fc7c"}, - {file = "tornado-6.3.2-cp38-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c2de14066c4a38b4ecbbcd55c5cc4b5340eb04f1c5e81da7451ef555859c833f"}, - {file = "tornado-6.3.2-cp38-abi3-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:05615096845cf50a895026f749195bf0b10b8909f9be672f50b0fe69cba368e4"}, - {file = "tornado-6.3.2-cp38-abi3-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5b17b1cf5f8354efa3d37c6e28fdfd9c1c1e5122f2cb56dac121ac61baa47cbe"}, - {file = "tornado-6.3.2-cp38-abi3-musllinux_1_1_aarch64.whl", hash = "sha256:29e71c847a35f6e10ca3b5c2990a52ce38b233019d8e858b755ea6ce4dcdd19d"}, - {file = "tornado-6.3.2-cp38-abi3-musllinux_1_1_i686.whl", hash = "sha256:834ae7540ad3a83199a8da8f9f2d383e3c3d5130a328889e4cc991acc81e87a0"}, - {file = "tornado-6.3.2-cp38-abi3-musllinux_1_1_x86_64.whl", hash = "sha256:6a0848f1aea0d196a7c4f6772197cbe2abc4266f836b0aac76947872cd29b411"}, - {file = "tornado-6.3.2-cp38-abi3-win32.whl", hash = "sha256:7efcbcc30b7c654eb6a8c9c9da787a851c18f8ccd4a5a3a95b05c7accfa068d2"}, - {file = "tornado-6.3.2-cp38-abi3-win_amd64.whl", hash = "sha256:0c325e66c8123c606eea33084976c832aa4e766b7dff8aedd7587ea44a604cdf"}, - {file = "tornado-6.3.2.tar.gz", hash = "sha256:4b927c4f19b71e627b13f3db2324e4ae660527143f9e1f2e2fb404f3a187e2ba"}, -] - -[[package]] -name = "tqdm" -version = "4.65.0" -description = "Fast, Extensible Progress Meter" -category = "main" -optional = false -python-versions = ">=3.7" -files = [ - {file = "tqdm-4.65.0-py3-none-any.whl", hash = "sha256:c4f53a17fe37e132815abceec022631be8ffe1b9381c2e6e30aa70edc99e9671"}, - {file = "tqdm-4.65.0.tar.gz", hash = "sha256:1871fb68a86b8fb3b59ca4cdd3dcccbc7e6d613eeed31f4c332531977b89beb5"}, -] - -[package.dependencies] -colorama = {version = "*", markers = "platform_system == \"Windows\""} - -[package.extras] -dev = ["py-make (>=0.1.0)", "twine", "wheel"] -notebook = ["ipywidgets (>=6)"] -slack = ["slack-sdk"] -telegram = ["requests"] - -[[package]] -name = "traitlets" -version = "5.9.0" -description = "Traitlets Python configuration system" -category = "dev" -optional = false -python-versions = ">=3.7" -files = [ - {file = "traitlets-5.9.0-py3-none-any.whl", hash = "sha256:9e6ec080259b9a5940c797d58b613b5e31441c2257b87c2e795c5228ae80d2d8"}, - {file = "traitlets-5.9.0.tar.gz", hash = "sha256:f6cde21a9c68cf756af02035f72d5a723bf607e862e7be33ece505abf4a3bad9"}, -] - -[package.extras] -docs = ["myst-parser", "pydata-sphinx-theme", "sphinx"] -test = ["argcomplete (>=2.0)", "pre-commit", "pytest", "pytest-mock"] - -[[package]] -name = "triton" -version = "2.0.0" -description = "A language and compiler for custom Deep Learning operations" -category = "main" -optional = false -python-versions = "*" -files = [ - {file = "triton-2.0.0-1-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:38806ee9663f4b0f7cd64790e96c579374089e58f49aac4a6608121aa55e2505"}, - {file = "triton-2.0.0-1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:226941c7b8595219ddef59a1fdb821e8c744289a132415ddd584facedeb475b1"}, - {file = "triton-2.0.0-1-cp36-cp36m-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:4c9fc8c89874bc48eb7e7b2107a9b8d2c0bf139778637be5bfccb09191685cfd"}, - {file = "triton-2.0.0-1-cp37-cp37m-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d2684b6a60b9f174f447f36f933e9a45f31db96cb723723ecd2dcfd1c57b778b"}, - {file = "triton-2.0.0-1-cp38-cp38-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:9d4978298b74fcf59a75fe71e535c092b023088933b2f1df933ec32615e4beef"}, - {file = "triton-2.0.0-1-cp39-cp39-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:74f118c12b437fb2ca25e1a04759173b517582fcf4c7be11913316c764213656"}, - {file = "triton-2.0.0-1-pp37-pypy37_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:9618815a8da1d9157514f08f855d9e9ff92e329cd81c0305003eb9ec25cc5add"}, - {file = "triton-2.0.0-1-pp38-pypy38_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:1aca3303629cd3136375b82cb9921727f804e47ebee27b2677fef23005c3851a"}, - {file = "triton-2.0.0-1-pp39-pypy39_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:e3e13aa8b527c9b642e3a9defcc0fbd8ffbe1c80d8ac8c15a01692478dc64d8a"}, - {file = "triton-2.0.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8f05a7e64e4ca0565535e3d5d3405d7e49f9d308505bb7773d21fb26a4c008c2"}, - {file = "triton-2.0.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bb4b99ca3c6844066e516658541d876c28a5f6e3a852286bbc97ad57134827fd"}, - {file = "triton-2.0.0-cp36-cp36m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:47b4d70dc92fb40af553b4460492c31dc7d3a114a979ffb7a5cdedb7eb546c08"}, - {file = "triton-2.0.0-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fedce6a381901b1547e0e7e1f2546e4f65dca6d91e2d8a7305a2d1f5551895be"}, - {file = "triton-2.0.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:75834f27926eab6c7f00ce73aaf1ab5bfb9bec6eb57ab7c0bfc0a23fac803b4c"}, - {file = "triton-2.0.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0117722f8c2b579cd429e0bee80f7731ae05f63fe8e9414acd9a679885fcbf42"}, - {file = "triton-2.0.0-pp37-pypy37_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bcd9be5d0c2e45d2b7e6ddc6da20112b6862d69741576f9c3dbaf941d745ecae"}, - {file = "triton-2.0.0-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:42a0d2c3fc2eab4ba71384f2e785fbfd47aa41ae05fa58bf12cb31dcbd0aeceb"}, - {file = "triton-2.0.0-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:52c47b72c72693198163ece9d90a721299e4fb3b8e24fd13141e384ad952724f"}, -] - -[package.dependencies] -cmake = "*" -filelock = "*" -lit = "*" -torch = "*" - -[package.extras] -tests = ["autopep8", "flake8", "isort", "numpy", "pytest", "scipy (>=1.7.1)"] -tutorials = ["matplotlib", "pandas", "tabulate"] - -[[package]] -name = "typing-extensions" -version = "4.5.0" -description = "Backported and Experimental Type Hints for Python 3.7+" -category = "main" -optional = false -python-versions = ">=3.7" -files = [ - {file = "typing_extensions-4.5.0-py3-none-any.whl", hash = "sha256:fb33085c39dd998ac16d1431ebc293a8b3eedd00fd4a32de0ff79002c19511b4"}, - {file = "typing_extensions-4.5.0.tar.gz", hash = "sha256:5cb5f4a79139d699607b3ef622a1dedafa84e115ab0024e0d9c044a9479ca7cb"}, -] - -[[package]] -name = "tzdata" -version = "2023.3" -description = "Provider of IANA time zone data" -category = "main" -optional = false -python-versions = ">=2" -files = [ - {file = "tzdata-2023.3-py2.py3-none-any.whl", hash = "sha256:7e65763eef3120314099b6939b5546db7adce1e7d6f2e179e3df563c70511eda"}, - {file = "tzdata-2023.3.tar.gz", hash = "sha256:11ef1e08e54acb0d4f95bdb1be05da659673de4acbd21bf9c69e94cc5e907a3a"}, -] - -[[package]] -name = "uri-template" -version = "1.2.0" -description = "RFC 6570 URI Template Processor" -category = "dev" -optional = false -python-versions = ">=3.6" -files = [ - {file = "uri_template-1.2.0-py3-none-any.whl", hash = "sha256:f1699c77b73b925cf4937eae31ab282a86dc885c333f2e942513f08f691fc7db"}, - {file = "uri_template-1.2.0.tar.gz", hash = "sha256:934e4d09d108b70eb8a24410af8615294d09d279ce0e7cbcdaef1bd21f932b06"}, -] - -[package.extras] -dev = ["flake8 (<4.0.0)", "flake8-annotations", "flake8-bugbear", "flake8-commas", "flake8-comprehensions", "flake8-continuation", "flake8-datetimez", "flake8-docstrings", "flake8-import-order", "flake8-literal", "flake8-noqa", "flake8-requirements", "flake8-type-annotations", "flake8-use-fstring", "mypy", "pep8-naming"] - -[[package]] -name = "urllib3" -version = "1.26.15" -description = "HTTP library with thread-safe connection pooling, file post, and more." -category = "dev" -optional = false -python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*" -files = [ - {file = "urllib3-1.26.15-py2.py3-none-any.whl", hash = "sha256:aa751d169e23c7479ce47a0cb0da579e3ede798f994f5816a74e4f4500dcea42"}, - {file = "urllib3-1.26.15.tar.gz", hash = "sha256:8a388717b9476f934a21484e8c8e61875ab60644d29b9b39e11e4b9dc1c6b305"}, -] - -[package.extras] -brotli = ["brotli (>=1.0.9)", "brotlicffi (>=0.8.0)", "brotlipy (>=0.6.0)"] -secure = ["certifi", "cryptography (>=1.3.4)", "idna (>=2.0.0)", "ipaddress", "pyOpenSSL (>=0.14)", "urllib3-secure-extra"] -socks = ["PySocks (>=1.5.6,!=1.5.7,<2.0)"] - -[[package]] -name = "virtualenv" -version = "20.21.0" -description = "Virtual Python Environment builder" -category = "dev" -optional = false -python-versions = ">=3.7" -files = [ - {file = "virtualenv-20.21.0-py3-none-any.whl", hash = "sha256:31712f8f2a17bd06234fa97fdf19609e789dd4e3e4bf108c3da71d710651adbc"}, - {file = "virtualenv-20.21.0.tar.gz", hash = "sha256:f50e3e60f990a0757c9b68333c9fdaa72d7188caa417f96af9e52407831a3b68"}, -] - -[package.dependencies] -distlib = ">=0.3.6,<1" -filelock = ">=3.4.1,<4" -platformdirs = ">=2.4,<4" - -[package.extras] -docs = ["furo (>=2022.12.7)", "proselint (>=0.13)", "sphinx (>=6.1.3)", "sphinx-argparse (>=0.4)", "sphinxcontrib-towncrier (>=0.2.1a0)", "towncrier (>=22.12)"] -test = ["covdefaults (>=2.2.2)", "coverage (>=7.1)", "coverage-enable-subprocess (>=1)", "flaky (>=3.7)", "packaging (>=23)", "pytest (>=7.2.1)", "pytest-env (>=0.8.1)", "pytest-freezegun (>=0.4.2)", "pytest-mock (>=3.10)", "pytest-randomly (>=3.12)", "pytest-timeout (>=2.1)"] - -[[package]] -name = "watchdog" -version = "3.0.0" -description = "Filesystem events monitoring" -category = "dev" -optional = false -python-versions = ">=3.7" -files = [ - {file = "watchdog-3.0.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:336adfc6f5cc4e037d52db31194f7581ff744b67382eb6021c868322e32eef41"}, - {file = "watchdog-3.0.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:a70a8dcde91be523c35b2bf96196edc5730edb347e374c7de7cd20c43ed95397"}, - {file = "watchdog-3.0.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:adfdeab2da79ea2f76f87eb42a3ab1966a5313e5a69a0213a3cc06ef692b0e96"}, - {file = "watchdog-3.0.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:2b57a1e730af3156d13b7fdddfc23dea6487fceca29fc75c5a868beed29177ae"}, - {file = "watchdog-3.0.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:7ade88d0d778b1b222adebcc0927428f883db07017618a5e684fd03b83342bd9"}, - {file = "watchdog-3.0.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:7e447d172af52ad204d19982739aa2346245cc5ba6f579d16dac4bfec226d2e7"}, - {file = "watchdog-3.0.0-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:9fac43a7466eb73e64a9940ac9ed6369baa39b3bf221ae23493a9ec4d0022674"}, - {file = "watchdog-3.0.0-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:8ae9cda41fa114e28faf86cb137d751a17ffd0316d1c34ccf2235e8a84365c7f"}, - {file = "watchdog-3.0.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:25f70b4aa53bd743729c7475d7ec41093a580528b100e9a8c5b5efe8899592fc"}, - {file = "watchdog-3.0.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:4f94069eb16657d2c6faada4624c39464f65c05606af50bb7902e036e3219be3"}, - {file = "watchdog-3.0.0-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:7c5f84b5194c24dd573fa6472685b2a27cc5a17fe5f7b6fd40345378ca6812e3"}, - {file = "watchdog-3.0.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:3aa7f6a12e831ddfe78cdd4f8996af9cf334fd6346531b16cec61c3b3c0d8da0"}, - {file = "watchdog-3.0.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:233b5817932685d39a7896b1090353fc8efc1ef99c9c054e46c8002561252fb8"}, - {file = "watchdog-3.0.0-pp37-pypy37_pp73-macosx_10_9_x86_64.whl", hash = "sha256:13bbbb462ee42ec3c5723e1205be8ced776f05b100e4737518c67c8325cf6100"}, - {file = "watchdog-3.0.0-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:8f3ceecd20d71067c7fd4c9e832d4e22584318983cabc013dbf3f70ea95de346"}, - {file = "watchdog-3.0.0-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:c9d8c8ec7efb887333cf71e328e39cffbf771d8f8f95d308ea4125bf5f90ba64"}, - {file = "watchdog-3.0.0-py3-none-manylinux2014_aarch64.whl", hash = "sha256:0e06ab8858a76e1219e68c7573dfeba9dd1c0219476c5a44d5333b01d7e1743a"}, - {file = "watchdog-3.0.0-py3-none-manylinux2014_armv7l.whl", hash = "sha256:d00e6be486affb5781468457b21a6cbe848c33ef43f9ea4a73b4882e5f188a44"}, - {file = "watchdog-3.0.0-py3-none-manylinux2014_i686.whl", hash = "sha256:c07253088265c363d1ddf4b3cdb808d59a0468ecd017770ed716991620b8f77a"}, - {file = "watchdog-3.0.0-py3-none-manylinux2014_ppc64.whl", hash = "sha256:5113334cf8cf0ac8cd45e1f8309a603291b614191c9add34d33075727a967709"}, - {file = "watchdog-3.0.0-py3-none-manylinux2014_ppc64le.whl", hash = "sha256:51f90f73b4697bac9c9a78394c3acbbd331ccd3655c11be1a15ae6fe289a8c83"}, - {file = "watchdog-3.0.0-py3-none-manylinux2014_s390x.whl", hash = "sha256:ba07e92756c97e3aca0912b5cbc4e5ad802f4557212788e72a72a47ff376950d"}, - {file = "watchdog-3.0.0-py3-none-manylinux2014_x86_64.whl", hash = "sha256:d429c2430c93b7903914e4db9a966c7f2b068dd2ebdd2fa9b9ce094c7d459f33"}, - {file = "watchdog-3.0.0-py3-none-win32.whl", hash = "sha256:3ed7c71a9dccfe838c2f0b6314ed0d9b22e77d268c67e015450a29036a81f60f"}, - {file = "watchdog-3.0.0-py3-none-win_amd64.whl", hash = "sha256:4c9956d27be0bb08fc5f30d9d0179a855436e655f046d288e2bcc11adfae893c"}, - {file = "watchdog-3.0.0-py3-none-win_ia64.whl", hash = "sha256:5d9f3a10e02d7371cd929b5d8f11e87d4bad890212ed3901f9b4d68767bee759"}, - {file = "watchdog-3.0.0.tar.gz", hash = "sha256:4d98a320595da7a7c5a18fc48cb633c2e73cda78f93cac2ef42d42bf609a33f9"}, -] - -[package.extras] -watchmedo = ["PyYAML (>=3.10)"] - -[[package]] -name = "wcwidth" -version = "0.2.6" -description = "Measures the displayed width of unicode strings in a terminal" -category = "dev" -optional = false -python-versions = "*" -files = [ - {file = "wcwidth-0.2.6-py2.py3-none-any.whl", hash = "sha256:795b138f6875577cd91bba52baf9e445cd5118fd32723b460e30a0af30ea230e"}, - {file = "wcwidth-0.2.6.tar.gz", hash = "sha256:a5220780a404dbe3353789870978e472cfe477761f06ee55077256e509b156d0"}, -] - -[[package]] -name = "webcolors" -version = "1.13" -description = "A library for working with the color formats defined by HTML and CSS." -category = "dev" -optional = false -python-versions = ">=3.7" -files = [ - {file = "webcolors-1.13-py3-none-any.whl", hash = "sha256:29bc7e8752c0a1bd4a1f03c14d6e6a72e93d82193738fa860cbff59d0fcc11bf"}, - {file = "webcolors-1.13.tar.gz", hash = "sha256:c225b674c83fa923be93d235330ce0300373d02885cef23238813b0d5668304a"}, -] - -[package.extras] -docs = ["furo", "sphinx", "sphinx-copybutton", "sphinx-inline-tabs", "sphinx-notfound-page", "sphinxext-opengraph"] -tests = ["pytest", "pytest-cov"] - -[[package]] -name = "webencodings" -version = "0.5.1" -description = "Character encoding aliases for legacy web content" -category = "dev" -optional = false -python-versions = "*" -files = [ - {file = "webencodings-0.5.1-py2.py3-none-any.whl", hash = "sha256:a0af1213f3c2226497a97e2b3aa01a7e4bee4f403f95be16fc9acd2947514a78"}, - {file = "webencodings-0.5.1.tar.gz", hash = "sha256:b36a1c245f2d304965eb4e0a82848379241dc04b865afcc4aab16748587e1923"}, -] - -[[package]] -name = "websocket-client" -version = "1.5.1" -description = "WebSocket client for Python with low level API options" -category = "dev" -optional = false -python-versions = ">=3.7" -files = [ - {file = "websocket-client-1.5.1.tar.gz", hash = "sha256:3f09e6d8230892547132177f575a4e3e73cfdf06526e20cc02aa1c3b47184d40"}, - {file = "websocket_client-1.5.1-py3-none-any.whl", hash = "sha256:cdf5877568b7e83aa7cf2244ab56a3213de587bbe0ce9d8b9600fc77b455d89e"}, -] - -[package.extras] -docs = ["Sphinx (>=3.4)", "sphinx-rtd-theme (>=0.5)"] -optional = ["python-socks", "wsaccel"] -test = ["websockets"] - -[[package]] -name = "wheel" -version = "0.40.0" -description = "A built-package format for Python" -category = "main" -optional = false -python-versions = ">=3.7" -files = [ - {file = "wheel-0.40.0-py3-none-any.whl", hash = "sha256:d236b20e7cb522daf2390fa84c55eea81c5c30190f90f29ae2ca1ad8355bf247"}, - {file = "wheel-0.40.0.tar.gz", hash = "sha256:cd1196f3faee2b31968d626e1731c94f99cbdb67cf5a46e4f5656cbee7738873"}, -] - -[package.extras] -test = ["pytest (>=6.0.0)"] - -[[package]] -name = "widgetsnbextension" -version = "4.0.7" -description = "Jupyter interactive widgets for Jupyter Notebook" -category = "dev" -optional = false -python-versions = ">=3.7" -files = [ - {file = "widgetsnbextension-4.0.7-py3-none-any.whl", hash = "sha256:be3228a73bbab189a16be2d4a3cd89ecbd4e31948bfdc64edac17dcdee3cd99c"}, - {file = "widgetsnbextension-4.0.7.tar.gz", hash = "sha256:ea67c17a7cd4ae358f8f46c3b304c40698bc0423732e3f273321ee141232c8be"}, -] - -[[package]] -name = "zipp" -version = "3.15.0" -description = "Backport of pathlib-compatible object wrapper for zip files" -category = "main" -optional = false -python-versions = ">=3.7" -files = [ - {file = "zipp-3.15.0-py3-none-any.whl", hash = "sha256:48904fc76a60e542af151aded95726c1a5c34ed43ab4134b597665c86d7ad556"}, - {file = "zipp-3.15.0.tar.gz", hash = "sha256:112929ad649da941c23de50f356a2b5570c954b65150642bccdd66bf194d224b"}, -] - -[package.extras] -docs = ["furo", "jaraco.packaging (>=9)", "jaraco.tidelift (>=1.4)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-lint"] -testing = ["big-O", "flake8 (<5)", "jaraco.functools", "jaraco.itertools", "more-itertools", "pytest (>=6)", "pytest-black (>=0.3.7)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=1.3)", "pytest-flake8", "pytest-mypy (>=0.9.1)"] - -[extras] -tinkerforge = ["tinkerforge"] - -[metadata] -lock-version = "2.0" -python-versions = ">=3.8.10,<3.11" -content-hash = "b360fe84272740fdc44b53158351417ba3d09ac5aea8daf42fb59174b068cd2b" diff --git a/pyproject.toml b/pyproject.toml index 5ff457910..3eccd6648 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,57 +1,112 @@ -[tool.poetry] +[project] name = "autora" -version = "0.0.0" -description = "Autonomous Research Assistant (AutoRA) is a framework for automating steps of the empirical research process. This framework implements tools for autonomously and iteratively generating 1) new theories to describe real-world data, and 2) experiments to invalidate those theories and seed a new cycle of theory-making. The experiments will be run online via crowd-sourcing platforms (MTurk, Prolific)." +description = "Autonomous Research Assistant (AutoRA) is a framework for automating steps of the empirical research process." authors = [ - "Sebastian Musslick ", - "John Gerrard Holland ", + { name = "Sebastian Musslick", email = "sebastian@musslick.de" } +] +maintainers = [ + { name = "Ben Andrew", email = "benwallaceandrew@gmail.com" }, + { name = "George Dang", email = "george_dang@brown.edu" }, + { name = "John Gerrard Holland", email = "john_holland1@brown.edu" }, + { name = "Younes Strittmatter", email = "younes_strittmatter@brown.edu" }, ] readme = "README.md" -homepage = "https://musslick.github.io/AER_website/Research.html" +license = { file = "LICENSE.md" } +dynamic = ["version"] + +dependencies = [ + "autora-core", + "autora-workflow", + "autora-synthetic", +] + +[project.optional-dependencies] +dev = [ + "autora-core[dev]", +] + +all = [ + "autora[all-theorists]", + "autora[all-experimentalists]", + "autora[all-experiment-runners]", +] + +all-theorists = [ + "autora[theorist-darts]", + "autora[theorist-bms]", + "autora[theorist-bsr]", +] +theorist-darts = [ + "autora-theorist-darts", +] +theorist-bms = [ + "autora-theorist-bms", +] +theorist-bsr = [ + "autora-theorist-bsr", +] + +all-experimentalists = [ + "autora[experimentalist-sampler-inequality]", + "autora[experimentalist-sampler-novelty]", + "autora[experimentalist-sampler-nearest-value]", + "autora[experimentalist-sampler-model-disagreement]", + "autora[experimentalist-sampler-uncertainty]", + "autora[experimentalist-falsification]", +] +experimentalist-sampler-inequality =[ + "autora-experimentalist-sampler-inequality" +] +experimentalist-sampler-novelty =[ + "autora-experimentalist-sampler-novelty" +] +experimentalist-sampler-nearest-value =[ + "autora-experimentalist-sampler-nearest-value" +] +experimentalist-sampler-model-disagreement =[ + "autora-experimentalist-sampler-model-disagreement" +] +experimentalist-sampler-uncertainty =[ + "autora-experimentalist-sampler-uncertainty" +] +experimentalist-falsification =[ + "autora-experimentalist-falsification" +] + +all-experiment-runners = [ + "autora[experiment-runner-firebase-prolific]" +] +experiment-runner-firebase-prolific = [ + "autora-experiment-runner-firebase-prolific" +] +all-experiment-runner-experimentation-managers = [ + "autora[experiment-runner-experimentation-manager-firebase]" +] +experiment-runner-experimentation-manager-firebase = [ + "autora-experiment-runner-experimentation-manager-firebase" +] +all-experiment-runner-recruitment-managers=[ + "autora[experiment-runner-recruitment-manager-prolific]" +] +experiment-runner-recruitment-manager-prolific = [ + "autora-experiment-runner-recruitment-manager-prolific" +] + +docs = [ + "autora-core[docs]", +] + +test = [ + "pytest" +] + +[project.urls] +homepage = "http://www.empiricalresearch.ai/" repository = "https://github.com/AutoResearch/autora" documentation = "https://autoresearch.github.io/autora/" -[tool.poetry.dependencies] -python = ">=3.8.10,<3.11" -numpy = ">=1.22.1" -scipy = "^1.9.3" -imageio = "^2.9.0" -matplotlib = "^3.2.1" -pandas = ">=1.4.2,<3.0.0" -graphviz = ">=0.14.1,<0.21.0" -seaborn = ">=0.11.1,<0.13.0" -scikit-learn = "^1.1.1" -sympy = "^1.10.1" -tinkerforge = {version = "^2.1.25", optional=true} -torch = "2.0.0" -tqdm = "^4.64.0" - -[tool.poetry.extras] -tinkerforge = ["tinkerforge"] - -[tool.poetry.group.dev.dependencies] -jupyter = "^1.0.0" -ipython = "^8.4.0" -ipywidgets = ">=7.7.1,<9.0.0" -flake8 = "^6.0.0" - -[tool.poetry.group.test.dependencies] -pytest = "^7.2.0" - -[tool.poetry.group.pre-commit.dependencies] -pre-commit = ">=2.20,<4.0" - -[tool.poetry.group.docs.dependencies] -mkdocs-material = ">=8.5.10,<10.0.0" -mkdocs-gen-files = ">=0.3.4,<0.6.0" -mkdocs-literate-nav = ">=0.4.1,<0.7.0" -mkdocs-section-index = "^0.3.4" -mkdocstrings-python = ">=0.7.1,<1.2.0" -mkdocs-jupyter = "^0.24.1" - [build-system] -requires = ["poetry-core>=1.0.0"] -build-backend = "poetry.core.masonry.api" +requires = ["setuptools", "setuptools-scm"] +build-backend = "setuptools.build_meta" -[tool.isort] -profile = "black" +[tool.setuptools_scm] diff --git a/src/.keep b/src/.keep new file mode 100644 index 000000000..a5b252d28 --- /dev/null +++ b/src/.keep @@ -0,0 +1 @@ +# file to ensure that the src/ directory always exists so setuptools works diff --git a/test_install.sh b/test_install.sh deleted file mode 100644 index 5db0ce05c..000000000 --- a/test_install.sh +++ /dev/null @@ -1,40 +0,0 @@ -#!/bin/bash - -# Build the distribution -original_directory=$(pwd) -distfile="${original_directory}/dist/$(poetry build -f sdist | tail -1 | awk -F' ' '{print $NF}')" - -# Create a new tempfile for the test -tempdir=$(mktemp -d) -echo "new temporary directory: ${tempdir}" - -# Copy the test files -echo "copying the test files" -cp -r -v "${original_directory}/tests" "${tempdir}/." - -# Change to the new directory -echo "change to the new directory" -cd "$tempdir" || exit - -# Create a new virtualenv and install the distribution -echo "creating new virtualenv" -virtualenv venv - -echo "activating new venv" -# shellcheck source=/dev/null -source venv/bin/activate - -echo "installing distribution file ${distfile}" -pip install "${distfile}" -pip install pytest - -echo "Installed version of AutoRA: $(python -c 'import autora; print(autora.__version__)')" - -echo "running unit tests:" -pytest - -echo "Run and test using:" -echo "cd \"${tempdir}\"" -echo "source ${tempdir}/venv/bin/activate" -echo "python -c 'import autora; print(autora.__version__)'" -echo "pytest" diff --git a/tests/README.md b/tests/README.md deleted file mode 100644 index aaeb4a919..000000000 --- a/tests/README.md +++ /dev/null @@ -1,34 +0,0 @@ -# Tests - -## Seeding - -Some testcases involve random numbers, including: -- All neural network models including DARTS, Bayesian DARTS -- All Tree models including BMS. - -In order to avoid the testcases from running correctly sometimes, and incorrectly other times, we seed all the relevant random number generators for those testcases. To accomplish this, add the following pytest fixture to the test file and include it as required in the test functions: - -```python -import random -import pytest -import torch - -@pytest.fixture -def seed(): - """ - Ensures that the results are the same each time the tests are run. - """ - random.seed(180) # required for models which use the python `random` module, e.g. BMS - torch.manual_seed(180) # required for PyTorch models, e.g. DARTS - return - - -def test_foo(seed): - """ Test something. """ - - # No need to use `seed` in the function body – adding it as an argument is sufficient - - ... # Run tests -``` - -The seed value should be consistent but not tuned to produce correct results. The integer `180` is used in many tests, inspired "180 George St., Providence, RI, USA", the office address for the Center for Computation and Visualization at Brown University, whose staff supported the development of the AutoRA package. Sensible alternatives are `42`, `31415926` and `2654435769`. See [https://en.wikipedia.org/wiki/Nothing-up-my-sleeve_number](https://en.wikipedia.org/wiki/Nothing-up-my-sleeve_number) for more inspiration. diff --git a/tests/__init__.py b/tests/__init__.py deleted file mode 100644 index e69de29bb..000000000 diff --git a/tests/test_bms_1d_primitive_recovery.py b/tests/test_bms_1d_primitive_recovery.py deleted file mode 100644 index 6f9738ff3..000000000 --- a/tests/test_bms_1d_primitive_recovery.py +++ /dev/null @@ -1,265 +0,0 @@ -#!/usr/bin/env python -import warnings -from typing import Callable - -import matplotlib.pyplot as plt -import numpy as np -import pytest # noqa: 401 - -from autora.skl.bms import BMSRegressor - -warnings.filterwarnings("ignore") - - -def generate_x(start=-1, stop=1, num=500): - x = np.expand_dims(np.linspace(start=start, stop=stop, num=num), 1) - return x - - -def generate_pos_x(start=0.5, stop=1, num=500): - x = np.expand_dims(np.linspace(start=start, stop=stop, num=num), 1) - return x - - -def generate_x_log(start=-1, stop=1, num=500, base=10): - x = np.expand_dims(np.logspace(start=start, stop=stop, num=num, base=base), 1) - return x - - -def transform_through_primitive_pow2(x: np.ndarray) -> np.ndarray: - return x**2 - - -def transform_through_primitive_pow3(x: np.ndarray) -> np.ndarray: - return x**3 - - -def transform_through_primitive_sqrt(x: np.ndarray) -> np.ndarray: - return np.sqrt(x) - - -def transform_through_primitive_abs(x: np.ndarray) -> np.ndarray: - return np.abs(x) - - -def transform_through_primitive_fac(x: np.ndarray) -> np.ndarray: - y = [] - for x_i in x: - y.append(np.math.gamma(x_i[0] + 1.0)) - y_hat = np.array(y) - return np.expand_dims(y_hat, 1) - - -def transform_through_primitive_none(x: np.ndarray) -> np.ndarray: - return x * 0 - - -def transform_through_primitive_add(x: np.ndarray) -> np.ndarray: - return x - - -def transform_through_primitive_relu(x: np.ndarray): - y = x.copy() - y[x < 0.0] = 0.0 - return y - - -def transform_through_primitive_sigmoid(x: np.ndarray): - y = 1.0 / (1.0 + np.exp(-x)) - return y - - -def transform_through_primitive_exp(x: np.ndarray): - y = np.exp(x) - return y - - -def transform_through_primitive_cos(x: np.ndarray): - y = np.cos(x) - return y - - -def transform_through_primitive_cosh(x: np.ndarray): - y = np.cosh(x) - return y - - -def transform_through_primitive_sin(x: np.ndarray): - y = np.sin(x) - return y - - -def transform_through_primitive_sinh(x: np.ndarray): - y = np.sinh(x) - return y - - -def transform_through_primitive_tan(x: np.ndarray): - y = np.tan(x) - return y - - -def transform_through_primitive_tanh(x: np.ndarray): - y = np.tanh(x) - return y - - -def transform_through_primitive_inverse(x: np.ndarray): - y = 1.0 / x - return y - - -def transform_through_primitive_ln(x: np.ndarray): - y = np.log(x) - return y - - -def run_test_primitive_fitting( - X: np.ndarray, - transformer: Callable, - verbose: bool = False, -): - y = transformer(X) - regressor = BMSRegressor(epochs=30) - regressor.fit(X, y.ravel()) - if verbose: - y_predict = regressor.predict(X) - for x_i in X.T[ - :, - ]: - plot_results(x_i, y, y_predict) - print(regressor.model_) - print(regressor.pms.trees) - - -def plot_results(X, y, y_predict): - plt.figure() - plt.plot(X, y, "o") - plt.plot(X, y_predict, "-") - plt.show() - - -def test_primitive_fitting_restricted_none(): - run_test_primitive_fitting( - generate_x(), - transform_through_primitive_none, - ) - - -def test_primitive_fitting_restricted_add(): - run_test_primitive_fitting( - generate_x(), - transform_through_primitive_add, - ) - - -def test_primitive_fitting_pow2(): - run_test_primitive_fitting( - generate_x(), - transform_through_primitive_pow2, - ) - - -def test_primitive_fitting_pow3(): - run_test_primitive_fitting( - generate_x(), - transform_through_primitive_pow3, - ) - - -def test_primitive_fitting_sqrt(): - run_test_primitive_fitting( - generate_pos_x(), - transform_through_primitive_sqrt, - ) - - -def test_primitive_fitting_abs(): - run_test_primitive_fitting( - generate_x(), - transform_through_primitive_abs, - ) - - -def test_primitive_fitting_fac(): - run_test_primitive_fitting( - generate_pos_x(), - transform_through_primitive_fac, - ) - - -def test_primitive_fitting_none(): - run_test_primitive_fitting( - generate_x(), - transform_through_primitive_none, - ) - - -def test_primitive_fitting_add(): - run_test_primitive_fitting( - generate_x(), - transform_through_primitive_add, - ) - - -def test_primitive_fitting_relu(): - run_test_primitive_fitting( - generate_x(), - transform_through_primitive_relu, - ) - - -def test_primitive_fitting_sigmoid(): - run_test_primitive_fitting( - generate_x(-10, +10), - transform_through_primitive_sigmoid, - ) - - -def test_primitive_fitting_exp(): - run_test_primitive_fitting( - generate_x(), - transform_through_primitive_exp, - ) - - -def test_primitive_fitting_cos(): - run_test_primitive_fitting( - generate_x(start=0, stop=2 * np.pi), - transform_through_primitive_cos, - ) - - -def test_primitive_fitting_cosh(): - run_test_primitive_fitting( - generate_x(start=0, stop=2 * np.pi), - transform_through_primitive_cosh, - ) - - -def test_primitive_fitting_sin(): - run_test_primitive_fitting( - generate_x(start=0, stop=2 * np.pi), - transform_through_primitive_sin, - ) - - -def test_primitive_fitting_sinh(): - run_test_primitive_fitting( - generate_x(start=0, stop=2 * np.pi), - transform_through_primitive_sinh, - ) - - -def test_primitive_fitting_tan(): - run_test_primitive_fitting( - generate_x(start=0, stop=2 * np.pi), - transform_through_primitive_tan, - ) - - -def test_primitive_fitting_tanh(): - run_test_primitive_fitting( - generate_x(start=0, stop=2 * np.pi), - transform_through_primitive_tanh, - ) diff --git a/tests/test_bms_2d_primitive_recovery.py b/tests/test_bms_2d_primitive_recovery.py deleted file mode 100644 index b0917d59a..000000000 --- a/tests/test_bms_2d_primitive_recovery.py +++ /dev/null @@ -1,107 +0,0 @@ -#!/usr/bin/env python -import warnings -from typing import Callable - -import matplotlib.pyplot as plt -import numpy as np -import pytest # noqa: 401 - -from autora.skl.bms import BMSRegressor - -warnings.filterwarnings("ignore") - - -def generate_x_2d(start=-1, stop=1, num=40): - step = abs(stop - start) / num - x2 = np.mgrid[start:stop:step, start:stop:step].reshape(2, -1).T - return x2 - - -def generate_pos_x_2d(start=0.5, stop=1, num=40): - step = abs(stop - start) / num - x2 = np.mgrid[start:stop:step, start:stop:step].reshape(2, -1).T - return x2 - - -def transform_through_primitive_add_2d(x: np.ndarray) -> np.ndarray: - return x[:, 0] + x[:, 1] - - -def transform_through_primitive_subtract_2d(x: np.ndarray) -> np.ndarray: - return x[:, 0] - x[:, 1] - - -def transform_through_primitive_mult_2d(x: np.ndarray) -> np.ndarray: - return np.multiply(x[:, 0], x[:, 1]) - - -def transform_through_primitive_div_2d(x: np.ndarray) -> np.ndarray: - return np.multiply(x[:, 0], np.reciprocal(x[:, 1])) - - -def transform_through_primitive_pow_2d(x: np.ndarray) -> np.ndarray: - return np.power(x[:, 0], x[:, 1]) - - -def run_test_primitive_fitting_2d( - X: np.ndarray, - transformer: Callable, - verbose: bool = False, -): - y = transformer(X) - regressor = BMSRegressor(epochs=30) - regressor.fit(X, y.ravel()) - if verbose: - y_predict = regressor.predict(X) - plot_results_2d(X, y, y_predict) - print(regressor.model_) - print(regressor.pms.trees) - - -def plot_results_2d(X, y, y_predict): - fig = plt.figure() - ax = fig.add_subplot(projection="3d") - ax.scatter(X[:, 0], X[:, 1], y, s=0.5) - n = np.sqrt(X.shape[0]).astype(int) - ax.plot_surface( - X[:, 0].reshape(n, n), - X[:, 1].reshape(n, n), - y_predict.reshape(n, n), - color="orange", - ) - plt.show() - - -def test_primitive_fitting_add_2d(): - run_test_primitive_fitting_2d( - generate_x_2d(), - transform_through_primitive_add_2d, - ) - - -def test_primitive_fitting_subtract_2d(): - run_test_primitive_fitting_2d( - generate_x_2d(), - transform_through_primitive_subtract_2d, - ) - - -def test_primitive_fitting_mult_2d(): - run_test_primitive_fitting_2d( - generate_x_2d(), - transform_through_primitive_mult_2d, - ) - - -def test_primitive_fitting_div_2d(): - run_test_primitive_fitting_2d( - generate_pos_x_2d(), - transform_through_primitive_div_2d, - ) - - -def test_primitive_fitting_pow_2d(): - run_test_primitive_fitting_2d( - generate_pos_x_2d(), - transform_through_primitive_pow_2d, - ) diff --git a/tests/test_bms_custom_primitives.py b/tests/test_bms_custom_primitives.py deleted file mode 100644 index d2b5ed1ad..000000000 --- a/tests/test_bms_custom_primitives.py +++ /dev/null @@ -1,129 +0,0 @@ -from typing import Callable, Optional - -import matplotlib.pyplot as plt -import numpy as np -import pytest # noqa: 401 - -from autora.skl.bms import BMSRegressor -from autora.theorist.bms.prior import relu - - -def generate_x(start=-1, stop=1, num=500): - x = np.expand_dims(np.linspace(start=start, stop=stop, num=num), 1) - return x - - -def generate_x_2d(start=-1, stop=1, num=40): - step = abs(stop - start) / num - x2 = np.mgrid[start:stop:step, start:stop:step].reshape(2, -1).T - return x2 - - -def transform_through_primitive_relu(x: np.ndarray) -> np.ndarray: - return np.array([y for y in [relu(x) for x in x]]) - - -def transform_through_primitive_softmax_2d(x: np.ndarray) -> np.ndarray: - return np.array([y for y in [softmax_2d(x, y) for x, y in x]]) - - -def transform_through_primitive_softmax_1d(x: np.ndarray) -> np.ndarray: - return np.array([y for y in [softmax_1d(x) for x in x]]) - - -def run_test_primitive_fitting( - X: np.ndarray, - transformer: Callable, - verbose: bool = False, - custom_primitive: Optional[Callable] = None, -): - y = transformer(X) - regressor = BMSRegressor(epochs=30) - regressor.fit(X, y.ravel(), custom_ops=[custom_primitive]) - # custom primitive is none or it is in bms' custom ops - assert custom_primitive is None or custom_primitive in regressor.custom_ops.values() - # custom primitive is none or its name is in bms' ops - assert custom_primitive is None or custom_primitive.__name__ in regressor.ops.keys() - # custom primitive is none or it is in the fitted models' custom ops - assert ( - custom_primitive is None - or custom_primitive in regressor.model_.custom_ops.values() - ) - # custom primitive is none or its name is in the fitted models' ops - assert ( - custom_primitive is None - or custom_primitive.__name__ in regressor.model_.ops.keys() - ) - if verbose: - y_predict = regressor.predict(X) - for x_i in X.T[ - :, - ]: - plot_results(x_i, y, y_predict) - print(regressor.model_) - print(regressor.pms.trees) - - -def plot_results(X, y, y_predict): - plt.figure() - plt.plot(X, y, "o") - plt.plot(X, y_predict, "-") - plt.show() - - -def run_test_primitive_fitting_2d( - X: np.ndarray, - transformer: Callable, - verbose: bool = False, - custom_primitive: Optional[Callable] = None, -): - y = transformer(X) - regressor = BMSRegressor(epochs=30) - regressor.fit(X, y.ravel(), custom_ops=[custom_primitive]) - # custom primitive is none or it is in bms' custom ops - assert custom_primitive is None or custom_primitive in regressor.custom_ops.values() - # custom primitive is none or its name is in bms' ops - assert custom_primitive is None or custom_primitive.__name__ in regressor.ops.keys() - # custom primitive is none or it is in the fitted models' custom ops - assert ( - custom_primitive is None - or custom_primitive in regressor.model_.custom_ops.values() - ) - # custom primitive is none or its name is in the fitted models' ops - assert ( - custom_primitive is None - or custom_primitive.__name__ in regressor.model_.ops.keys() - ) - if verbose: - print(regressor.model_) - print(regressor.pms.trees) - - -def test_primitive_fitting_relu(): - run_test_primitive_fitting( - generate_x(), transform_through_primitive_relu, custom_primitive=relu - ) - - -def softmax_2d(x, y): - return np.exp(x) / (np.exp(x) + np.exp(y)) - - -def test_primitive_fitting_softmax_2d(): - run_test_primitive_fitting_2d( - generate_x_2d(), - transformer=transform_through_primitive_softmax_2d, - custom_primitive=softmax_2d, - ) - - -def softmax_1d(x): - return np.exp(x) / (np.exp(x)) - - -def test_primitive_fitting_softmax_1d(): - run_test_primitive_fitting( - generate_x(), - transformer=transform_through_primitive_softmax_1d, - custom_primitive=softmax_1d, - ) diff --git a/tests/test_bms_enforce_root.py b/tests/test_bms_enforce_root.py deleted file mode 100644 index 1c9472c2a..000000000 --- a/tests/test_bms_enforce_root.py +++ /dev/null @@ -1,52 +0,0 @@ -from typing import Callable, Optional - -import numpy as np -import pytest # noqa: 401 - -from autora.skl.bms import BMSRegressor - - -def generate_x_2d(start=-1, stop=1, num=40): - step = abs(stop - start) / num - x2 = np.mgrid[start:stop:step, start:stop:step].reshape(2, -1).T - return x2 - - -def transform_through_primitive_softmax_2d(x: np.ndarray) -> np.ndarray: - return np.array([y for y in [softmax_2d(x, y) for x, y in x]]) - - -def run_test_primitive_fitting_2d( - X: np.ndarray, - transformer: Callable, - verbose: bool = False, - custom_primitive: Optional[Callable] = None, - root=None, -): - y = transformer(X) - regressor = BMSRegressor(epochs=60) - regressor.fit(X, y.ravel(), custom_ops=[custom_primitive], root=root) - # root is none or is in custom ops - assert root is None or root in regressor.custom_ops.values() - # root is none or it is the root of the fitted model - assert root is None or root is regressor.custom_ops[regressor.model_.root.value] - for model in regressor.models_: - # root is none or it is the root of all of the fitted models - assert root is None or root is regressor.custom_ops[model.root.value] - if verbose: - print(regressor.model_) - print(regressor.pms.trees) - - -def softmax_2d(x, y): - return np.exp(x) / (np.exp(x) + np.exp(y)) - - -def test_primitive_fitting_softmax_2d_fixed_root(): - run_test_primitive_fitting_2d( - generate_x_2d(), - transformer=transform_through_primitive_softmax_2d, - custom_primitive=softmax_2d, - root=softmax_2d, - verbose=True, - ) diff --git a/tests/test_bms_mcmc.py b/tests/test_bms_mcmc.py deleted file mode 100644 index e28846068..000000000 --- a/tests/test_bms_mcmc.py +++ /dev/null @@ -1,61 +0,0 @@ -import numpy as np -import pandas as pd -import pytest # noqa: 401 - -from autora.theorist.bms import Tree, get_priors - - -def test_tree_mcmc_stepping( - num_points: int = 10, samples: int = 100, show_plot: bool = False -) -> Tree: - """ - Testing the basic MCMC capacity. Note that even though an option (`show_plot`) is - offered to compare the actual data (`y`) against the prediction, this test does not - try to assess the prediction accuracy; it only ensures that the MCMC functionality - can work bug-free. - - Parameters: - num_points: - the number of data points in each dimension of the synthetic data - samples: - the number of MCMC samples we want to get. The total MCMC iteration can be - calculated as `burnin` + `samples` - show_plot: - whether to plot the predicted against actual response variable - - Returns: - the expression tree obtained from running the MCMC algorithm - """ - - # Create the data - x = pd.DataFrame( - dict([("x%d" % i, np.random.uniform(0, 10, num_points)) for i in range(5)]) - ) - eps = np.random.normal(0.0, 5, num_points) - y = 50.0 * np.sin(x["x0"]) / x["x2"] - 4.0 * x["x1"] + 3 + eps - - # Create the formula - t = Tree( - variables=["x%d" % i for i in range(5)], - parameters=["a%d" % i for i in range(10)], - x=x, - y=y, - prior_par=get_priors()[0], - BT=1.0, - ) - - # MCMC - t.mcmc(burnin=200, thin=10, samples=samples, verbose=False) - - # Predict - print(t.predict(x)) - print(y) - print(50.0 * np.sin(x["x0"]) / x["x2"] - 4.0 * x["x1"] + 3) - - if show_plot: - import matplotlib.pyplot as plt - - plt.plot(t.predict(x), 50.0 * np.sin(x["x0"]) / x["x2"] - 4.0 * x["x1"] + 3) - plt.show() - - return t diff --git a/tests/test_bms_multi_model_output.py b/tests/test_bms_multi_model_output.py deleted file mode 100644 index 3d3962800..000000000 --- a/tests/test_bms_multi_model_output.py +++ /dev/null @@ -1,25 +0,0 @@ -import numpy as np -import pytest - -from autora.skl.bms import BMSRegressor -from autora.theorist.bms import Tree - - -@pytest.fixture -def curve_to_fit(): - x = np.linspace(-10, 10, 100).reshape(-1, 1) - y = (x**3.0) + (2.0 * x**2.0) + (17.0 * x) - 1 - return x, y - - -def test_bms_models(curve_to_fit): - x, y = curve_to_fit - regressor = BMSRegressor(epochs=100) - - regressor.fit(x, y) - - print(regressor.models_) - - assert len(regressor.models_) == len(regressor.ts) # Currently hardcoded - for model in regressor.models_: - assert isinstance(model, Tree) diff --git a/tests/test_bsr_1d_recovery.py b/tests/test_bsr_1d_recovery.py deleted file mode 100644 index c9b81f122..000000000 --- a/tests/test_bsr_1d_recovery.py +++ /dev/null @@ -1,179 +0,0 @@ -import warnings -from typing import Callable - -import matplotlib.pyplot as plt -import numpy as np -import pytest # noqa: 401 - -from autora.skl.bsr import BSRRegressor - -warnings.filterwarnings("ignore") - - -def generate_x(start=-1, stop=1, num=500): - x = np.expand_dims(np.linspace(start=start, stop=stop, num=num), 1) - return x - - -def generate_pos_x(start=0.5, stop=1, num=500): - x = np.expand_dims(np.linspace(start=start, stop=stop, num=num), 1) - return x - - -def generate_x_log(start=-1, stop=1, num=500, base=10): - x = np.expand_dims(np.logspace(start=start, stop=stop, num=num, base=base), 1) - return x - - -def transform_through_primitive_pow2(x: np.ndarray) -> np.ndarray: - return x**2 - - -def transform_through_primitive_pow3(x: np.ndarray) -> np.ndarray: - return x**3 - - -def transform_through_primitive_sqrt(x: np.ndarray) -> np.ndarray: - return np.sqrt(x) - - -def transform_through_primitive_abs(x: np.ndarray) -> np.ndarray: - return np.abs(x) - - -def transform_through_primitive_fac(x: np.ndarray) -> np.ndarray: - y = [] - for x_i in x: - y.append(np.math.gamma(x_i[0] + 1.0)) - y_hat = np.array(y) - return np.expand_dims(y_hat, 1) - - -def transform_through_primitive_none(x: np.ndarray) -> np.ndarray: - return x * 0 - - -def transform_through_primitive_add(x: np.ndarray) -> np.ndarray: - return x - - -def transform_through_primitive_relu(x: np.ndarray): - y = x.copy() - y[x < 0.0] = 0.0 - return y - - -def transform_through_primitive_sigmoid(x: np.ndarray): - y = 1.0 / (1.0 + np.exp(-x)) - return y - - -def transform_through_primitive_exp(x: np.ndarray): - y = np.exp(x) - return y - - -def transform_through_primitive_cos(x: np.ndarray): - y = np.cos(x) - return y - - -def transform_through_primitive_cosh(x: np.ndarray): - y = np.cosh(x) - return y - - -def transform_through_primitive_sin(x: np.ndarray): - y = np.sin(x) - return y - - -def transform_through_primitive_sinh(x: np.ndarray): - y = np.sinh(x) - return y - - -def transform_through_primitive_tan(x: np.ndarray): - y = np.tan(x) - return y - - -def transform_through_primitive_tanh(x: np.ndarray): - y = np.tanh(x) - return y - - -def transform_through_primitive_inverse(x: np.ndarray): - y = 1.0 / x - return y - - -def transform_through_primitive_ln(x: np.ndarray): - y = np.log(x) - return y - - -def run_test_primitive_fitting( - X: np.ndarray, - transformer: Callable, - verbose: bool = False, -): - y = transformer(X) - regressor = BSRRegressor(tree_num=3, itr_num=10, val=10) - regressor.fit(X, y.ravel()) - if verbose: - y_predict = regressor.predict(X) - for x_i in X.T[ - :, - ]: - plot_results(x_i, y, y_predict) - print(regressor._model()) - - -def plot_results(X, y, y_predict): - plt.figure() - plt.plot(X, y, "o") - plt.plot(X, y_predict, "-") - plt.show() - - -def test_primitive_fitting_restricted_add(): - run_test_primitive_fitting( - generate_x(), - transform_through_primitive_add, - ) - - -def test_primitive_fitting_pow2(): - run_test_primitive_fitting( - generate_x(), - transform_through_primitive_pow2, - ) - - -def test_primitive_fitting_pow3(): - run_test_primitive_fitting( - generate_x(), - transform_through_primitive_pow3, - ) - - -def test_primitive_fitting_sqrt(): - run_test_primitive_fitting( - generate_pos_x(), - transform_through_primitive_sqrt, - ) - - -def test_primitive_fitting_abs(): - run_test_primitive_fitting( - generate_x(), - transform_through_primitive_abs, - ) - - -def test_primitive_fitting_fac(): - run_test_primitive_fitting( - generate_pos_x(), - transform_through_primitive_fac, - ) diff --git a/tests/test_bsr_2d_recovery.py b/tests/test_bsr_2d_recovery.py deleted file mode 100644 index 7ed6739fb..000000000 --- a/tests/test_bsr_2d_recovery.py +++ /dev/null @@ -1,105 +0,0 @@ -import warnings -from typing import Callable - -import matplotlib.pyplot as plt -import numpy as np -import pytest # noqa: 401 - -from autora.skl.bsr import BSRRegressor - -warnings.filterwarnings("ignore") - - -def generate_x_2d(start=-1, stop=1, num=40): - step = abs(stop - start) / num - x2 = np.mgrid[start:stop:step, start:stop:step].reshape(2, -1).T - return x2 - - -def generate_pos_x_2d(start=0.5, stop=1, num=40): - step = abs(stop - start) / num - x2 = np.mgrid[start:stop:step, start:stop:step].reshape(2, -1).T - return x2 - - -def transform_through_primitive_add_2d(x: np.ndarray) -> np.ndarray: - return x[:, 0] + x[:, 1] - - -def transform_through_primitive_subtract_2d(x: np.ndarray) -> np.ndarray: - return x[:, 0] - x[:, 1] - - -def transform_through_primitive_mult_2d(x: np.ndarray) -> np.ndarray: - return np.multiply(x[:, 0], x[:, 1]) - - -def transform_through_primitive_div_2d(x: np.ndarray) -> np.ndarray: - return np.multiply(x[:, 0], np.reciprocal(x[:, 1])) - - -def transform_through_primitive_pow_2d(x: np.ndarray) -> np.ndarray: - return np.power(x[:, 0], x[:, 1]) - - -def run_test_primitive_fitting_2d( - X: np.ndarray, - transformer: Callable, - verbose: bool = False, -): - y = transformer(X) - regressor = BSRRegressor(tree_num=3, itr_num=10) - regressor.fit(X, y.ravel()) - if verbose: - y_predict = regressor.predict(X) - plot_results_2d(X, y, y_predict) - print(regressor._model()) - - -def plot_results_2d(X, y, y_predict): - fig = plt.figure() - ax = fig.add_subplot(projection="3d") - ax.scatter(X[:, 0], X[:, 1], y, s=0.5) - n = np.sqrt(X.shape[0]).astype(int) - ax.plot_surface( - X[:, 0].reshape(n, n), - X[:, 1].reshape(n, n), - y_predict.reshape(n, n), - color="orange", - ) - plt.show() - - -def test_primitive_fitting_add_2d(): - run_test_primitive_fitting_2d( - generate_x_2d(), - transform_through_primitive_add_2d, - ) - - -def test_primitive_fitting_subtract_2d(): - run_test_primitive_fitting_2d( - generate_x_2d(), - transform_through_primitive_subtract_2d, - ) - - -def test_primitive_fitting_mult_2d(): - run_test_primitive_fitting_2d( - generate_x_2d(), - transform_through_primitive_mult_2d, - ) - - -def test_primitive_fitting_div_2d(): - run_test_primitive_fitting_2d( - generate_pos_x_2d(), - transform_through_primitive_div_2d, - ) - - -def test_primitive_fitting_pow_2d(): - run_test_primitive_fitting_2d( - generate_pos_x_2d(), - transform_through_primitive_pow_2d, - ) diff --git a/tests/test_bsr_mcmc_actions.py b/tests/test_bsr_mcmc_actions.py deleted file mode 100644 index 78dc08ecb..000000000 --- a/tests/test_bsr_mcmc_actions.py +++ /dev/null @@ -1,174 +0,0 @@ -from typing import List, Union - -from autora.theorist.bsr.funcs import ( - de_transform, - get_all_nodes, - grow, - prune, - reassign_feat, - reassign_op, - transform, -) -from autora.theorist.bsr.node import Node, NodeType, Optional -from autora.theorist.bsr.prior import get_prior_dict - - -def _build_tree_from_literals(literals: List[Union[str, int]], **hyper_params): - """ - Helper testing function that builds up a valid computation tree with a list of str/int inputs - where a string input represents an operation (e.g. `inv`, `+`) and an integer indicates which - feature to use in a leaf node. For the list of valid operations, see `priors.py`. - - The construction is done level-by-level. For example, the list `["sin", "inv", 1, 0] will render - the following computation tree - - sin (root) - / \ - inv feature 1 - / - feature 0 - - Note that for simplicity this function doesn't check the validity of input list; e.g. using - a binary operation without specifying the features used by its two leaf nodes might cause error. - - Arguments: - literals: a list of strings and integers that specifies how the tree should be built - hyper_params: parameters to initialize certain operations - Returns: - root: the root node of the tree - """ - _, _, prior_dict = get_prior_dict() - root = Node(0) - node_queue = [root] - for s in literals: - node = node_queue.pop(0) - params = {} - if isinstance(s, str): - ops_init = prior_dict[s]["init"] - # init is a function randomized by some hyper-params - if callable(ops_init): - params.update(ops_init(**hyper_params)) - else: # init is deterministic dict - params.update(ops_init) - node.setup(s, prior_dict[s]) - elif isinstance(s, int): - params["feature"] = s - node.setup(**params) - if node.left: - node_queue.append(node.left) - if node.right: - node_queue.append(node.right) - return root - - -def _assert_tree_completeness( - tree: Node, depth: int = 0, parent: Optional[Node] = None -): - assert tree.depth == depth - assert tree.node_type != NodeType.EMPTY - if parent: - assert tree.parent is parent - if tree.node_type == NodeType.LEAF: - assert tree.op_name == "" - assert "feature" in tree.params - elif tree.node_type == NodeType.UNARY: - assert tree.op_arity == 1 - assert tree.left and not tree.right - _assert_tree_completeness(tree.left, depth + 1, tree) - else: - assert tree.op_arity == 2 and tree.left and tree.right - if tree.op_init: # operation with params - assert len(tree.params) > 0 - _assert_tree_completeness(tree.left, depth + 1, tree) - _assert_tree_completeness(tree.right, depth + 1, tree) - - -def test_mcmc_grow(): - ops_name_list, ops_weight_list, ops_priors = get_prior_dict() - hyper_params = {"sigma_a": 1, "sigma_b": 1} - node = _build_tree_from_literals(["*", "+", "-", 0, 1, 0, 1], **hyper_params) - grow(node.left.left, ops_name_list, ops_weight_list, ops_priors, **hyper_params) - _assert_tree_completeness(node) - - node = _build_tree_from_literals([0], **hyper_params) - grow(node, ops_name_list, ops_weight_list, ops_priors, **hyper_params) - _assert_tree_completeness(node) - assert len(get_all_nodes(node)) > 1 - - -def test_mcmc_prune(): - hyper_params = {"sigma_a": 1, "sigma_b": 1} - node = _build_tree_from_literals(["*", "+", "-", 0, 1, 0, 1], **hyper_params) - prune(node.right) - _assert_tree_completeness(node) - assert node.left.op_name == "+" - assert node.right.node_type == NodeType.LEAF - - -def test_mcmc_de_transform(**hyper_params): - hyper_params = {"sigma_a": 1, "sigma_b": 1} - node = _build_tree_from_literals(["*", "exp", "-", 0, 0, 1], **hyper_params) - repl, disc = de_transform(node.left) # the unary case, replaced with child - assert disc is None - assert repl.node_type == NodeType.LEAF and repl.params["feature"] == 0 - # binary & root case - node = _build_tree_from_literals(["*", 2, "-", 0, 1], **hyper_params) - repl, disc = de_transform(node) - assert disc.node_type == NodeType.LEAF and disc.params["feature"] == 2 - _assert_tree_completeness(repl, 1, node) - # binary & non-root case - node = _build_tree_from_literals(["+", "*", "-", "exp", 0, 1, 2, 3], **hyper_params) - _assert_tree_completeness(node) - repl, disc = de_transform(node.left) - if repl is node.left.left: - assert disc is node.left.right - else: - assert disc is node.left.left - _assert_tree_completeness(repl, 2, node.left) - - -def test_mcmc_transform(): - ops_name_list, ops_weight_list, ops_priors = get_prior_dict() - hyper_params = {"sigma_a": 1, "sigma_b": 1} - - node = _build_tree_from_literals(["*", "+", "-", 0, 1, 0, 1], **hyper_params) - old_left = node.left - transform(old_left, ops_name_list, ops_weight_list, ops_priors, **hyper_params) - _assert_tree_completeness(node) - assert old_left.parent.parent is node - assert node.left is old_left.parent - assert old_left.parent.left is old_left - - -def test_mcmc_reassign_op(): - ops_name_list, ops_weight_list, ops_priors = get_prior_dict() - hyper_params = {"sigma_a": 1, "sigma_b": 1} - # repeat multiple times to cover all cases - for _ in range(5): - node = _build_tree_from_literals(["*", "exp", "-", 0, 0, 1], **hyper_params) - reassign_op(node, ops_name_list, ops_weight_list, ops_priors, **hyper_params) - _assert_tree_completeness(node) - if node.node_type == NodeType.BINARY: - assert node.left.op_name == "exp" - assert node.right.op_name == "-" - else: - assert node.left.op_name == "exp" - assert node.left.left.params["feature"] == 0 - reassign_op( - node.left, ops_name_list, ops_weight_list, ops_priors, **hyper_params - ) - _assert_tree_completeness(node) - assert node.left.left.params["feature"] == 0 - if node.left.node_type == NodeType.BINARY: - assert node.left.right.node_type != NodeType.EMPTY - - -def test_mcmc_reassign_feat(**hyper_params): - node = _build_tree_from_literals(["*", "exp", "-", 2, 2, 3], **hyper_params) - reassign_feat(node.left.left) - reassign_feat(node.right.right) - _assert_tree_completeness(node) - assert node.left.op_name == "exp" - assert node.left.left.params["feature"] < 2 - assert node.right.left.params["feature"] == 2 - assert node.right.right.params["feature"] < 2 diff --git a/tests/test_bsr_node_and_operator.py b/tests/test_bsr_node_and_operator.py deleted file mode 100644 index cb8d1b08e..000000000 --- a/tests/test_bsr_node_and_operator.py +++ /dev/null @@ -1,118 +0,0 @@ -from typing import List, Union - -import numpy as np - -from autora.theorist.bsr.node import Node -from autora.theorist.bsr.prior import get_prior_dict - - -def _build_tree_from_literals(literals: List[Union[str, int]], **hyper_params): - """ - Helper testing function that builds up a valid computation tree with a list of str/int inputs - where a string input represents an operation (e.g. `inv`, `+`) and an integer indicates which - feature to use in a leaf node. For the list of valid operations, see `priors.py`. - - The construction is done level-by-level. For example, the list `["sin", "inv", 1, 0] will render - the following computation tree - - sin (root) - / \ - inv feature 1 - / - feature 0 - - Note that for simplicity this function doesn't check the validity of input list; e.g. using - a binary operation without specifying the features used by its two leaf nodes might cause error. - - Arguments: - literals: a list of strings and integers that specifies how the tree should be built - hyper_params: parameters to initialize certain operations - Returns: - root: the root node of the tree - """ - _, _, prior_dict = get_prior_dict() - root = Node(0) - node_queue = [root] - for s in literals: - node = node_queue.pop(0) - params = {} - if isinstance(s, str): - ops_init = prior_dict[s]["init"] - # init is a function randomized by some hyper-params - if callable(ops_init): - params.update(ops_init(**hyper_params)) - else: # init is deterministic dict - params.update(ops_init) - node.setup(s, prior_dict[s]) - elif isinstance(s, int): - params["feature"] = s - node.setup(**params) - if node.left: - node_queue.append(node.left) - if node.right: - node_queue.append(node.right) - return root - - -def test_basic_linear_operation(): - root = _build_tree_from_literals(["ln", 0]) - root.params.update({"a": 2, "b": 3}) - test_x = np.array([[1, 2, 3], [4, 5, 6]]) - test_y = 2 * test_x[:, 0] + 3 - assert (test_y - root.evaluate(test_x) < 1e-5).all() - - -def test_basic_exp_operation(): - root = _build_tree_from_literals(["exp", 0]) - test_x = np.array([[1, 2, 3], [4, 5, 6]]) - test_y = np.exp(test_x[:, 0]) - assert (test_y - root.evaluate(test_x) < 1e-5).all() - - -def test_basic_inv_operation(): - root = _build_tree_from_literals(["inv", 0]) - test_x = np.array([[1, 2, 3], [4, 5, 6]]) - test_y = 1 / test_x[:, 0] - assert (test_y - root.evaluate(test_x) < 1e-5).all() - - -def test_basic_neg_operation(): - root = _build_tree_from_literals(["neg", 0]) - test_x = np.array([[1, 2, 3], [4, 5, 6]]) - test_y = -test_x[:, 0] - assert (test_y - root.evaluate(test_x) < 1e-5).all() - - -def test_basic_sin_operation(): - root = _build_tree_from_literals(["sin", 0]) - test_x = np.array([[1, 2, 3], [4, 5, 6]]) - test_y = np.sin(test_x[:, 0]) - assert (test_y - root.evaluate(test_x) < 1e-5).all() - - -def test_basic_cos_operation(): - root = _build_tree_from_literals(["cos", 0]) - test_x = np.array([[1, 2, 3], [4, 5, 6]]) - test_y = np.cos(test_x[:, 0]) - assert (test_y - root.evaluate(test_x) < 1e-5).all() - - -def test_basic_plus_operation(): - root = _build_tree_from_literals(["+", 0, 1]) - test_x = np.array([[1, 2, 3], [4, 5, 6]]) - test_y = np.add(test_x[:, 0], test_x[:, 1]) - assert (test_y - root.evaluate(test_x) < 1e-5).all() - - -def test_basic_minus_operation(): - root = _build_tree_from_literals(["-", 0, 1]) - test_x = np.array([[1, 2, 3], [4, 5, 6]]) - test_y = np.subtract(test_x[:, 0], test_x[:, 1]) - assert (test_y - root.evaluate(test_x) < 1e-5).all() - - -def test_basic_multiply_operation(): - root = _build_tree_from_literals(["*", 0, 1]) - test_x = np.array([[1, 2, 3], [4, 5, 6]]) - test_y = np.multiply(test_x[:, 0], test_x[:, 1]) - assert (test_y - root.evaluate(test_x) < 1e-5).all() diff --git a/tests/test_bsr_tree_operation.py b/tests/test_bsr_tree_operation.py deleted file mode 100644 index 1f485ca31..000000000 --- a/tests/test_bsr_tree_operation.py +++ /dev/null @@ -1,17 +0,0 @@ -from autora.theorist.bsr.funcs import grow -from autora.theorist.bsr.misc import get_ops_expr -from autora.theorist.bsr.node import Node -from autora.theorist.bsr.prior import get_prior_dict - - -def test_grow_and_print_node(): - root = Node(depth=0) - ops_name_lst, ops_weight_lst, prior_dict = get_prior_dict() - hyper_params = { - "beta": -1, - "sigma_a": 1, - "sigma_b": 1, - } - grow(root, ops_name_lst, ops_weight_lst, prior_dict, **hyper_params) - ops_expr = get_ops_expr() - print(root.get_expression(ops_expr)) diff --git a/tests/test_core_imports.py b/tests/test_core_imports.py new file mode 100644 index 000000000..1972cc612 --- /dev/null +++ b/tests/test_core_imports.py @@ -0,0 +1,8 @@ +def test_core_imports(): + # Only include default packages installed by `pip install autora` without any extras here + import autora # noqa + import autora.experiment_runner.synthetic # noqa + import autora.experimentalist # noqa + import autora.utils # noqa + import autora.variable # noqa + import autora.workflow # noqa diff --git a/tests/test_cycle_plots.py b/tests/test_cycle_plots.py deleted file mode 100644 index b2a8a0fb1..000000000 --- a/tests/test_cycle_plots.py +++ /dev/null @@ -1,492 +0,0 @@ -import random - -import numpy as np -import pytest -from sklearn.linear_model import LinearRegression -from sklearn.metrics import r2_score - -from autora.cycle import ( - Cycle, - cycle_default_score, - cycle_specified_score, - plot_cycle_score, - plot_results_panel_2d, - plot_results_panel_3d, -) -from autora.cycle.plot_utils import _check_replace_default_kw -from autora.experimentalist.pipeline import Pipeline -from autora.experimentalist.pooler.general_pool import grid_pool -from autora.experimentalist.sampler import random_sampler -from autora.variable import Variable, VariableCollection - - -@pytest.fixture -def ground_truth_1x(): - def ground_truth(xs): - return xs + 1.0 - - return ground_truth - - -@pytest.fixture -def cycle_lr(ground_truth_1x): - random.seed(1) - - # Variable Metadata - study_metadata = VariableCollection( - independent_variables=[ - Variable(name="x1", allowed_values=np.linspace(0, 1, 100)) - ], - dependent_variables=[Variable(name="y", value_range=(-20, 20))], - ) - - # Theorist - lm = LinearRegression() - - # Experimentalist - example_experimentalist = Pipeline( - [ - ("pool", grid_pool), - ("sampler", random_sampler), - ("transform", lambda x: [s[0] for s in x]), - ], - params={ - "pool": {"ivs": study_metadata.independent_variables}, - "sampler": {"n": 5}, - }, - ) - - # Experiment Runner - def get_example_synthetic_experiment_runner(): - rng = np.random.default_rng(seed=180) - - def runner(xs): - return ground_truth_1x(xs) + rng.normal(0, 0.1, xs.shape) - - return runner - - example_synthetic_experiment_runner = get_example_synthetic_experiment_runner() - - # Initialize Cycle - cycle = Cycle( - metadata=study_metadata, - theorist=lm, - experimentalist=example_experimentalist, - experiment_runner=example_synthetic_experiment_runner, - ) - - # Run 10 iterations - cycle.run(10) - - return cycle - - -@pytest.fixture -def ground_truth_2x(): - def ground_truth(X): - return X[:, 0] + (0.5 * X[:, 1]) + 1.0 - - return ground_truth - - -@pytest.fixture -def cycle_multi_lr(ground_truth_2x): - random.seed(1) - - # def ground_truth(X): - # return X[:, 0] + (0.5 * X[:, 1]) + 1.0 - - # Variable Metadata - study_metadata = VariableCollection( - independent_variables=[ - Variable(name="x1", allowed_values=np.linspace(0, 1, 10)), - Variable(name="x2", allowed_values=np.linspace(0, 1, 10)), - ], - dependent_variables=[Variable(name="y", value_range=(-20, 20))], - ) - - # Theorist - lm = LinearRegression() - - # Experimentalist - example_experimentalist = Pipeline( - [ - ("pool", grid_pool), - ("sampler", random_sampler), - ("transform", lambda x: np.array(x)), - ], - params={ - "pool": {"ivs": study_metadata.independent_variables}, - "sampler": {"n": 10}, - }, - ) - - # Experiment Runner - def get_example_synthetic_experiment_runner(): - rng = np.random.default_rng(seed=180) - - def runner(xs): - return ground_truth_2x(xs) + rng.normal(0, 0.25, xs.shape[0]) - - return runner - - example_synthetic_experiment_runner = get_example_synthetic_experiment_runner() - - # Initialize Cycle - cycle = Cycle( - metadata=study_metadata, - theorist=lm, - experimentalist=example_experimentalist, - experiment_runner=example_synthetic_experiment_runner, - ) - - # Run 6 iterations - cycle.run(6) - - return cycle - - -def test_check_replace_default_kw(): - default = { - "subplot_kw": {"sharex": True, "sharey": True}, - "gridspec_kw": {"bottom": 0.16}, - } - user = { - "new_kw": True, - "subplot_kw": {"sharey": False}, - "gridspec_kw": {"bottom": 0.2, "top": 0.9}, - } - d_result = _check_replace_default_kw(default, user) - - assert d_result == { - "subplot_kw": {"sharex": True, "sharey": False}, - "gridspec_kw": {"bottom": 0.2, "top": 0.9}, - "new_kw": True, - } - - -def test_2d_plot(cycle_lr): - """ - Tests plotting functionality of plot_results_panel_2d. - """ - steps = 51 - fig = plot_results_panel_2d( - cycle_lr, steps=steps, wrap=3, subplot_kw={"sharex": True, "sharey": True} - ) - - # Should have 12 axes, 10 with data and the last 2 turned off - assert len(fig.axes) == 12 - assert sum([s.axison for s in fig.axes]) == 10 - - # Check number of data points on each figure - # Blue dots should start at 0 and augment by 5. - # Orange should always be 5-this is the condition sampling rate set by the Experimentalist. - l_counts = [] - for axes in fig.axes[:-2]: - blue_dots = ( - len(axes.collections[0].get_offsets().mask) - - axes.collections[0].get_offsets().mask.any(axis=1).sum() - ) - orange_dots = ( - len(axes.collections[1].get_offsets().mask) - - axes.collections[1].get_offsets().mask.any(axis=1).sum() - ) - l_counts.append([blue_dots, orange_dots]) - assert np.array_equal( - np.array(l_counts), - np.array( - [ - [0, 5], - [5, 5], - [10, 5], - [15, 5], - [20, 5], - [25, 5], - [30, 5], - [35, 5], - [40, 5], - [45, 5], - ] - ), - ) - - # Test theory line is being plotted - for axes in fig.axes[:-2]: - assert len(axes.lines[0].get_xdata()) == steps - assert len(axes.lines[0].get_ydata()) == steps - - -def test_3d_plot(cycle_multi_lr): - """ - Tests plotting functionality of plot_results_panel_3d. - """ - steps = 20 - fig = plot_results_panel_3d( - cycle_multi_lr, - steps=steps, - view=(20, 60), - wrap=3, - subplot_kw=dict(figsize=(11, 8)), - ) - - # Should have 6 axes - assert len(fig.axes) == 6 - assert sum([s._axis3don for s in fig.axes]) == 6 - - # Check number of data points on each figure - # Blue dots should start at 0 and augment by 5. - # Orange should always be 5-this is the condition sampling rate set by the Experimentalist. - l_counts = [] - for axes in fig.axes[:-1]: - blue_dots = ( - len(axes.collections[0].get_offsets().mask) - - axes.collections[0].get_offsets().mask.any(axis=1).sum() - ) - orange_dots = ( - len(axes.collections[1].get_offsets().mask) - - axes.collections[1].get_offsets().mask.any(axis=1).sum() - ) - l_counts.append([blue_dots, orange_dots]) - assert np.array_equal( - np.array(l_counts), - np.array([[0, 10], [10, 10], [20, 10], [30, 10], [40, 10]]), - ) - - -def test_score_functions(cycle_lr, ground_truth_1x): - """ - Tests the scoring functions cycle_default_score and cycle_specified_score. - """ - X_test = cycle_lr.data.metadata.independent_variables[0].allowed_values.reshape( - -1, 1 - ) - y_test = ground_truth_1x(X_test) - - scores_default = cycle_default_score(cycle_lr, X_test, y_test) - scores_specified = cycle_specified_score(r2_score, cycle_lr, X_test, y_test) - - # Check scores are the expected values - score_values = [ - 0.98950589, - 0.99352993, - 0.9858365, - 0.99909308, - 0.99811927, - 0.98663153, - 0.98748396, - 0.9848339, - 0.99359794, - 0.99691326, - ] - assert np.array_equal(np.around(score_values, 8), np.around(scores_default, 8)) - - # Results should be equal between the two functions. - # The default scorer of the LinearRegression estimator is r2_score. - assert np.array_equal(scores_default, scores_specified) - - -def test_cycle_score_plot(cycle_lr, ground_truth_1x): - """ - Tests plotting functionality of test_cycle_score_plot with a 2D linear regression. - """ - X_test = cycle_lr.data.metadata.independent_variables[0].allowed_values.reshape( - -1, 1 - ) - y_test = ground_truth_1x(X_test) - fig = plot_cycle_score(cycle_lr, X_test, y_test) - - # Should have 1 axis - assert len(fig.axes) == 1 - - # Test line is plotted correctly - axis = fig.axes[0] - assert len(axis.lines[0].get_xdata()) == 10 - y_values = np.array( - [ - 0.98950589, - 0.99352993, - 0.9858365, - 0.99909308, - 0.99811927, - 0.98663153, - 0.98748396, - 0.9848339, - 0.99359794, - 0.99691326, - ] - ) - y_plotted = axis.lines[0].get_ydata() - assert np.array_equal(np.around(y_plotted, 8), np.around(y_values, 8)) - - -def test_cycle_score_plot_multi_lr(cycle_multi_lr, ground_truth_2x): - """ - Tests plotting functionality of test_cycle_score_plot with multiple linear regression cycle. - """ - cycle_multi_lr.run(6) # Run additional 6 times, total of 12 cycles - X_test = np.array( - list(grid_pool(cycle_multi_lr.data.metadata.independent_variables)) - ) - y_test = ground_truth_2x(X_test) - fig = plot_cycle_score(cycle_multi_lr, X_test, y_test) - - # Test line is plotted correctly - axis = fig.axes[0] - assert len(axis.lines[0].get_xdata()) == 12 - y_values = np.array( - [ - 0.89368929, - 0.91897824, - 0.96375643, - 0.94514076, - 0.97807231, - 0.98778323, - 0.9931792, - 0.98768072, - 0.98952749, - 0.98867354, - 0.9872955, - 0.98999052, - ] - ) - y_plotted = axis.lines[0].get_ydata() - assert np.array_equal(np.around(y_plotted, 8), np.around(y_values, 8)) - - -def test_2d_plot_indexing(cycle_lr): - """ - Test indexing of 2d plotter. - """ - steps = 51 - fig = plot_results_panel_2d( - cycle_lr, - steps=steps, - wrap=2, - query=[0, 3, 7], - subplot_kw={"sharex": True, "sharey": True}, - ) - - # Should have 4 axes, 3 with data and the last turned off - assert len(fig.axes) == 4 - assert sum([s.axison for s in fig.axes]) == 3 - - -def test_2d_plot_negative_indexing(cycle_lr): - """ - Test indexing of 2d plotter. - """ - steps = 51 - fig = plot_results_panel_2d( - cycle_lr, - steps=steps, - wrap=2, - query=[-2, -1], - subplot_kw={"sharex": True, "sharey": True}, - ) - - # Should have 2 axes - assert len(fig.axes) == 2 - assert sum([s.axison for s in fig.axes]) == 2 - - # Should be plotting cycles 8 and 9 - assert fig.axes[0].get_children()[3].get_text() == "Cycle 8" - assert fig.axes[1].get_children()[3].get_text() == "Cycle 9" - - -def test_2d_plot_slicing(cycle_lr): - """ - Test slicing of 2d plotter using built-in slice() function. - """ - steps = 51 - - # Using Slice function - # Cycles 0, 2, 4, 6, 8 - fig = plot_results_panel_2d( - cycle_lr, - steps=steps, - wrap=3, - query=slice(0, 9, 2), - subplot_kw={"sharex": True, "sharey": True}, - ) - # Should have 6 axes, 5 with data and the last turned off - assert len(fig.axes) == 6 - assert sum([s.axison for s in fig.axes]) == 5 - - # Last 4 plots - fig2 = plot_results_panel_2d( - cycle_lr, - steps=steps, - wrap=3, - query=slice(-4, None, None), - subplot_kw={"sharex": True, "sharey": True}, - ) - # Should have 6 axes, 4 with data - assert len(fig2.axes) == 6 - assert sum([s.axison for s in fig2.axes]) == 4 - - -def test_2d_plot_slicing_np(cycle_lr): - """ - Test slicing of 2d plotter using np.s_ Index Expression - """ - steps = 51 - - # Cycles 0, 2, 4, 6, 8 - fig1 = plot_results_panel_2d( - cycle_lr, - steps=steps, - wrap=3, - query=np.s_[0:9:2], - subplot_kw={"sharex": True, "sharey": True}, - ) - # Should have 6 axes, 5 with data and the last turned off - assert len(fig1.axes) == 6 - assert sum([s.axison for s in fig1.axes]) == 5 - - fig2 = plot_results_panel_2d( - cycle_lr, - steps=steps, - wrap=3, - query=np.s_[-4:], - subplot_kw={"sharex": True, "sharey": True}, - ) - # Should have 6 axes, 4 with data - assert len(fig2.axes) == 6 - assert sum([s.axison for s in fig2.axes]) == 4 - - -def test_2d_plot_plot_single(cycle_lr): - """ - Test query of 2d plotter for a single cycle. - """ - steps = 51 - - # Using index - fig1 = plot_results_panel_2d( - cycle_lr, - steps=steps, - query=[9], - subplot_kw={"sharex": True, "sharey": True}, - ) - assert len(fig1.axes) == 1 - assert sum([s.axison for s in fig1.axes]) == 1 - - # Using slice() - fig2 = plot_results_panel_2d( - cycle_lr, - steps=steps, - query=slice(-1, None, None), - subplot_kw={"sharex": True, "sharey": True}, - ) - assert len(fig2.axes) == 1 - assert sum([s.axison for s in fig2.axes]) == 1 - - # Using np.s_ Index expression - fig3 = plot_results_panel_2d( - cycle_lr, - steps=steps, - query=np.s_[-1:], - subplot_kw={"sharex": True, "sharey": True}, - ) - assert len(fig3.axes) == 1 - assert sum([s.axison for s in fig3.axes]) == 1 diff --git a/tests/test_darts_1d_primitive_recovery.py b/tests/test_darts_1d_primitive_recovery.py deleted file mode 100644 index 12b1ceccb..000000000 --- a/tests/test_darts_1d_primitive_recovery.py +++ /dev/null @@ -1,287 +0,0 @@ -#!/usr/bin/env python -from typing import Callable, Sequence - -import matplotlib.pyplot as plt -import numpy as np -import pytest -import torch - -from autora.skl.darts import DARTSRegressor - -non_interchangeable_primitives = [ - "none", - "add", - "subtract", - "logistic", - "exp", - "relu", - "cos", - "sin", - "tanh", -] - - -@pytest.fixture -def seed(): - """ - Ensures that the results are the same each time the tests are run. - """ - torch.manual_seed(180) - return - - -def generate_x(start=-1, stop=1, num=500): - x = np.expand_dims(np.linspace(start=start, stop=stop, num=num), 1) - return x - - -def generate_x_log(start=-1, stop=1, num=500, base=10): - x = np.expand_dims(np.logspace(start=start, stop=stop, num=num, base=base), 1) - return x - - -def transform_through_primitive_none(x: np.ndarray) -> np.ndarray: - return x * 0.0 - - -def transform_through_primitive_add(x: np.ndarray) -> np.ndarray: - return x - - -def transform_through_primitive_subtract(x: np.ndarray) -> np.ndarray: - return -x - - -def transform_through_primitive_relu(x: np.ndarray): - y = x.copy() - y[x < 0.0] = 0.0 - return y - - -def transform_through_primitive_sigmoid(x: np.ndarray): - y = 1.0 / (1.0 + np.exp(-x)) - return y - - -def transform_through_primitive_exp(x: np.ndarray): - y = np.exp(x) - return y - - -def transform_through_primitive_cos(x: np.ndarray): - y = np.cos(x) - return y - - -def transform_through_primitive_sin(x: np.ndarray): - y = np.sin(x) - return y - - -def transform_through_primitive_tanh(x: np.ndarray): - y = np.tanh(x) - return y - - -def transform_through_primitive_softplus(x: np.ndarray, beta=1.0): - y = np.log(1 + np.exp(beta * x)) / beta - return y - - -def transform_through_primitive_softminus(x: np.ndarray, beta=1.0): - y = x - np.log(1 + np.exp(beta * x)) / beta - return y - - -def transform_through_primitive_inverse(x: np.ndarray): - y = 1.0 / x - return y - - -def transform_through_primitive_ln(x: np.ndarray): - y = np.log(x) - return y - - -def transform_through_primitive_mult(x: np.ndarray, coefficient=5.0): - y = coefficient * x - return y - - -def get_primitive_from_single_node_model(model): - primitive = model[0].primitives[np.argmax(model[0].max_alphas_normal()).numpy()] - return primitive - - -def run_test_primitive_fitting( - X: np.ndarray, - transformer: Callable, - expected_primitive: str, - primitives: Sequence[str], - verbose: bool = False, -): - y = transformer(X) - regressor = DARTSRegressor( - num_graph_nodes=1, - param_updates_per_epoch=100, - max_epochs=300, - arch_updates_per_epoch=1, - param_weight_decay=3e-4, - arch_weight_decay_df=0.001, - arch_weight_decay=1e-4, - arch_learning_rate_max=0.3, - param_learning_rate_max=0.0025, - param_learning_rate_min=0.01, - param_momentum=0.90, - primitives=primitives, - train_classifier_bias=False, - train_classifier_coefficients=False, - ) - regressor.fit(X, y) - - if verbose: - y_predict = regressor.predict(X) - report_weights(X, expected_primitive, primitives, regressor, y) - plot_results(X, y, y_predict) - - assert get_primitive_from_single_node_model(regressor.model_) == expected_primitive - - -def plot_results(X, y, y_predict): - plt.plot(X, y, "o") - plt.plot(X, y_predict, "-") - plt.show() - - -def report_weights(X, expected_primitive, primitives, regressor, y): - print("\n", np.column_stack((X, y, regressor.predict(X))).round(2)) - print(get_primitive_from_single_node_model(regressor.model_)) - print( - "Weight of winning primitive: {0}".format( - regressor.model_[0]._arch_parameters[0][ - 0, - primitives.index( - get_primitive_from_single_node_model(regressor.model_) - ), - ] - ) - ) - print( - "Weight of correct primitive: {0}".format( - regressor.model_[0]._arch_parameters[0][ - 0, primitives.index(expected_primitive) - ] - ) - ) - print(regressor.model_[0]._arch_parameters[0].data) - - -def test_primitive_fitting_restricted_none(seed): - run_test_primitive_fitting( - generate_x(), - transform_through_primitive_none, - "none", - primitives=["none", "add", "subtract"], - ) - - -def test_primitive_fitting_restricted_add(seed): - run_test_primitive_fitting( - generate_x(), - transform_through_primitive_add, - "add", - primitives=["none", "add", "subtract"], - ) - - -def test_primitive_fitting_restricted_subtract(seed): - run_test_primitive_fitting( - generate_x(), - transform_through_primitive_subtract, - "subtract", - primitives=["none", "add", "subtract"], - ) - - -def test_primitive_fitting_none(seed): - run_test_primitive_fitting( - generate_x(), - transform_through_primitive_none, - "none", - primitives=non_interchangeable_primitives, - ) - - -def test_primitive_fitting_add(seed): - run_test_primitive_fitting( - generate_x(), - transform_through_primitive_add, - "add", - primitives=non_interchangeable_primitives, - ) - - -def test_primitive_fitting_subtract(seed): - run_test_primitive_fitting( - generate_x(), - transform_through_primitive_subtract, - "subtract", - primitives=non_interchangeable_primitives, - ) - - -def test_primitive_fitting_relu(seed): - run_test_primitive_fitting( - generate_x(), - transform_through_primitive_relu, - "relu", - primitives=non_interchangeable_primitives, - ) - - -def test_primitive_fitting_sigmoid(seed): - run_test_primitive_fitting( - generate_x(-10, +10), - transform_through_primitive_sigmoid, - "logistic", - # Restricted group of primitives, as sigmoid function doesn't fit otherwise. - primitives=["none", "logistic", "linear", "sin", "tanh"], - ) - - -def test_primitive_fitting_exp(seed): - run_test_primitive_fitting( - generate_x(), - transform_through_primitive_exp, - "exp", - primitives=non_interchangeable_primitives, - ) - - -def test_primitive_fitting_cos(seed): - run_test_primitive_fitting( - generate_x(start=-3 * np.pi, stop=3 * np.pi), - transform_through_primitive_cos, - "cos", - # Restricted group of primitives, as the code doesn't - # find cos in the full set - primitives=["none", "cos", "linear", "subtract"], - ) - - -def test_primitive_fitting_sin(seed): - run_test_primitive_fitting( - generate_x(start=0, stop=2 * np.pi), - transform_through_primitive_sin, - "sin", - primitives=non_interchangeable_primitives, - ) - - -def test_primitive_fitting_tanh(seed): - run_test_primitive_fitting( - generate_x(start=0, stop=2 * np.pi), - transform_through_primitive_tanh, - "tanh", - primitives=non_interchangeable_primitives, - ) diff --git a/tests/test_experimentalist_assumption.py b/tests/test_experimentalist_assumption.py deleted file mode 100644 index ab2bfe524..000000000 --- a/tests/test_experimentalist_assumption.py +++ /dev/null @@ -1,74 +0,0 @@ -from functools import partial - -import numpy as np -from sklearn.linear_model import RidgeCV -from sklearn.metrics import mean_absolute_error, mean_squared_error - -from autora.experimentalist.pipeline import make_pipeline -from autora.experimentalist.pooler import grid_pool -from autora.experimentalist.sampler import assumption_sampler -from autora.variable import Variable, VariableCollection - - -def test_experimentalist_assumption(): - """ - Tests the implementation of the experimentalist pipeline with an exhaustive pool of discrete - values, no filter, assumption sampler. A ridge regression model is trained using - synthetic data generated from a ground_truth function for use. - - """ - # Make the data - def ground_truth(xs): - return (xs**2.0) + xs + 1.0 - - # X = np.random.randint(low=0, high=10, size=100).reshape(-1, 1) - X = np.array(range(11)).reshape(-1, 1) - y = np.array([x for x in ground_truth(X)]) - - # Train ridge regression model - model = RidgeCV(scoring="neg_mean_squared_error") - model.fit(X, y) - - metadata = VariableCollection( - independent_variables=[Variable(name="x1", allowed_values=range(11))], - dependent_variables=[Variable(name="y", value_range=(-20, 20))], - ) - - n_trials = 10 # Number of trails for sampler to select - - # Set up pipeline functions with partial - pooler_callable = partial(grid_pool, ivs=metadata.independent_variables) - sampler = partial(assumption_sampler, y=y, model=model, n=n_trials) - # currently theorist objects are not required to have its loss function as an attribute - - # Initialize pipeline - pipeline = make_pipeline([pooler_callable, sampler]) - # Run the pipeline - results = pipeline.run() - - # ***Checks*** - # Is sampling the number of trials we expect - assert len(results) == n_trials - - # Assumption sampling is behaving as expected by comparing results with manual calculation - pipeline_pool_filter = make_pipeline([pooler_callable]) - pool = np.array(list(pipeline_pool_filter.run())) # Create filtered pool - y_pred = model.predict(X) # get model predictions - # model_loss_function = get_scorer(scoring=model.get_params()['scoring']) - # assert model_loss_function == mean_squared_error - # sklearn does not quite seem to have functionality to retrieve loss function used by model - # you can get the scorer which corresponds to the loss function - # but there does not seem to be any built-in dictionary to get the corresponding function - model_loss_function = mean_squared_error - model_loss = model_loss_function( - y_true=y.reshape(1, -1), y_pred=y_pred.reshape(1, -1), multioutput="raw_values" - ) - # calculate model loss on an alternative loss function - alternative_model_loss_function = mean_absolute_error - alternative_model_loss = alternative_model_loss_function( - y_true=y.reshape(1, -1), y_pred=y_pred.reshape(1, -1), multioutput="raw_values" - ) - loss_delta = alternative_model_loss - model_loss - select_idx = np.flip(loss_delta.argsort()[:n_trials]) - results_manual = pool[select_idx] # Index conditions from pool - assert np.array_equal(results, results_manual) diff --git a/tests/test_experimentalist_pipeline.py b/tests/test_experimentalist_pipeline.py deleted file mode 100644 index a02bfa855..000000000 --- a/tests/test_experimentalist_pipeline.py +++ /dev/null @@ -1,350 +0,0 @@ -from functools import partial -from itertools import product -from math import sqrt - -import numpy as np - -from autora.experimentalist.pipeline import ( - Pipeline, - _parse_params_to_nested_dict, - make_pipeline, -) - -############################################################################## -# Building blocks -############################################################################## - - -def linear_pool_generator(stop=10): - return range(stop) - - -def even_filter(values): - return filter(lambda i: i % 2 == 0, values) - - -def odd_filter(values): - return filter(lambda i: (i + 1) % 2 == 0, values) - - -def divisor_filter(values, divisor): - return filter(lambda i: i % divisor == 0, values) - - -def is_sqrt_filter(values): - return filter(lambda i: sqrt(i) % 1 == 0.0, values) - - -############################################################################## -# Simple pipelines of one variable -############################################################################## - - -def test_zeroth_pipline_zeroth_input(): - pipeline = Pipeline() - result_0 = list(pipeline()) - assert result_0 == [] - - -def test_zeroth_pipline_basic_input(): - pipeline = Pipeline([]) - result_0 = list(pipeline([0, 1, 2, 3])) - assert result_0 == [0, 1, 2, 3] - - -def test_zeroth_make_pipeline(): - pipeline = make_pipeline() - result = list(pipeline([0, 1, 2, 3])) - assert result == [0, 1, 2, 3] - - -def test_single_element_pipeline(): - pipeline = Pipeline([("even_filter", even_filter)]) - result = list(pipeline(range(10))) - assert result == [0, 2, 4, 6, 8] - - -def test_single_element_make_pipeline(): - pipeline = make_pipeline([even_filter]) - result = list(pipeline(range(10))) - assert result == [0, 2, 4, 6, 8] - - -def test_multiple_element_pipeline(): - pipeline = Pipeline( - [ - ("even_filter", even_filter), - ("divisor_filter", partial(divisor_filter, divisor=3)), - ] - ) - result = list(pipeline(range(13))) - assert result == [0, 6, 12] - - -def test_multiple_element_make_pipeline(): - pipeline = make_pipeline([even_filter, partial(divisor_filter, divisor=3)]) - result = list(pipeline(range(13))) - assert result == [0, 6, 12] - - -def test_two_element_make_pipeline_with_params(): - pipeline = make_pipeline( - [even_filter, divisor_filter], params={"divisor_filter": {"divisor": 5}} - ) - result = list(pipeline(range(21))) - assert result == [0, 10, 20] - - -def test_three_element_make_pipeline(): - pipeline = make_pipeline( - [divisor_filter, divisor_filter, divisor_filter], - params={ - "divisor_filter_0": {"divisor": 5}, - "divisor_filter_1": {"divisor": 7}, - "divisor_filter_2": {"divisor": 11}, - }, - ) - result = list(pipeline(range(500))) - assert result == [0, 385] - - -def test_nested_pipeline(): - inner_pipeline = Pipeline([("pool", lambda: range(32))]) - outer_pipeline = Pipeline( - [ - ("inner_pipeline", inner_pipeline), - ("filter_by_divisor", partial(divisor_filter, divisor=8)), - ], - ) - result = list(outer_pipeline()) - assert result == [0, 8, 16, 24] - - -def test_nested_pipeline_nested_parameters(): - inner_pipeline = Pipeline([("pool", lambda maximum: range(maximum))]) - outer_pipeline = Pipeline( - [ - ("inner_pipeline", inner_pipeline), - ("filter_by_divisor", divisor_filter), - ], - params={ - "inner_pipeline": {"pool": {"maximum": 32}}, - "filter_by_divisor": {"divisor": 8}, - }, - ) - result = list(outer_pipeline()) - assert result == [0, 8, 16, 24] - - -def test_nested_pipeline_flat_parameters(): - inner_pipeline = Pipeline([("pool", lambda maximum: range(maximum))]) - outer_pipeline = Pipeline( - [ - ("inner_pipeline", inner_pipeline), - ("filter_by_divisor", divisor_filter), - ], - params={"inner_pipeline__pool__maximum": 32, "filter_by_divisor__divisor": 8}, - ) - result = list(outer_pipeline()) - assert result == [0, 8, 16, 24] - - -def test_nested_pipeline_nested_parameters_in_kwargs(): - inner_pipeline = Pipeline([("pool", lambda maximum: range(maximum))]) - outer_pipeline = Pipeline( - [ - ("inner_pipeline", inner_pipeline), - ("filter_by_divisor", divisor_filter), - ], - ) - result = list( - outer_pipeline( - **{ - "inner_pipeline": {"pool": {"maximum": 32}}, - "filter_by_divisor": {"divisor": 8}, - } - ) - ) - assert result == [0, 8, 16, 24] - - -def test_nested_pipeline_flat_parameters_in_kwargs(): - inner_pipeline = Pipeline([("pool", lambda maximum: range(maximum))]) - outer_pipeline = Pipeline( - [ - ("inner_pipeline", inner_pipeline), - ("filter_by_divisor", divisor_filter), - ], - ) - result = list( - outer_pipeline( - **{"inner_pipeline__pool__maximum": 32, "filter_by_divisor__divisor": 8} - ) - ) - assert result == [0, 8, 16, 24] - - -############################################################################## -# Simple pool and filters of one variable -############################################################################## - - -def test_zeroth_poolpipeline(): - pipeline = make_pipeline([linear_pool_generator]) - result = list(pipeline()) - assert result == [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] - - -def test_even_poolpipeline(): - pipeline = make_pipeline([linear_pool_generator, even_filter]) - result = list(pipeline()) - assert result == [0, 2, 4, 6, 8] - - -def test_odd_poolpipeline(): - pipeline = make_pipeline([linear_pool_generator, odd_filter]) - result = list(pipeline()) - assert result == [1, 3, 5, 7, 9] - - -def test_poolpipeline_run(): - pipeline = make_pipeline([linear_pool_generator, odd_filter]) - result = list(pipeline.run()) - assert result == [1, 3, 5, 7, 9] - - -############################################################################## -# Pool and filters of two Weber variables -############################################################################## - - -def weber_pool(vmin=0, vmax=1, steps=5): - s1 = s2 = np.linspace(vmin, vmax, steps) - pool = product(s1, s2) - return pool - - -def weber_filter(values): - return filter(lambda s: s[0] >= s[1], values) - - -def test_weber_unfiltered_poolpipeline(): - pipeline = make_pipeline([weber_pool]) - result = list(pipeline()) - assert result[0] == (0.0, 0.0) - assert result[1] == (0.0, 0.25) - assert result[-1] == (1.0, 1.0) - - -def test_weber_filtered_poolpipeline(): - pipeline = make_pipeline([weber_pool, weber_filter]) - result = list(pipeline()) - assert result[0] == (0.0, 0.0) - assert result[1] == (0.25, 0.0) - assert result[-1] == (1.0, 1.0) - - -############################################################################## -# Helper Functions -############################################################################## -def test_params_parser_zero_level(): - params = { - "model": "%%newest_theory%%", - "n": 10, - "measure": "least_confident", - } - result = _parse_params_to_nested_dict(params, divider="__") - assert result == params - - -def test_params_parser_one_level(): - params = { - "pool__ivs": "%%independent_variables%%", - "uncertainty_sampler__model": "%%newest_theory%%", - "uncertainty_sampler__n": 10, - "uncertainty_sampler__measure": "least_confident", - } - - result = _parse_params_to_nested_dict(params, divider="__") - assert result == { - "pool": { - "ivs": "%%independent_variables%%", - }, - "uncertainty_sampler": { - "model": "%%newest_theory%%", - "n": 10, - "measure": "least_confident", - }, - } - - -def test_params_parser_recurse_one(): - - params = { - "filter_pipeline__step1__n_samples": 100, - } - - result = _parse_params_to_nested_dict(params, divider="__") - assert result == {"filter_pipeline": {"step1": {"n_samples": 100}}} - - -def test_params_parser_recurse_one_n_levels(): - params = { - "a__b__c__d__e__f": 100, - "a__b__c__d__e__g": 200, - "a__b__h": 300, - } - result = _parse_params_to_nested_dict(params, divider="__") - assert result == {"a": {"b": {"c": {"d": {"e": {"f": 100, "g": 200}}}, "h": 300}}} - - -def test_params_parser_recurse_one_n_levels_alternative_divider(): - params = { - "a:b:c:d:e:f": 100, - "a:b:c:d:e:g": 200, - "a:b:h": 300, - } - result = _parse_params_to_nested_dict(params, divider=":") - assert result == {"a": {"b": {"c": {"d": {"e": {"f": 100, "g": 200}}}, "h": 300}}} - - -def test_params_parser_recurse(): - - params = { - "pool__ivs": "%%independent_variables%%", - "filter_pipeline__step1__n_samples": 100, - "filter_pipeline__step2__n_samples": 10, - "uncertainty_sampler__model": "%%newest_theory%%", - "uncertainty_sampler__n": 10, - "uncertainty_sampler__measure": "least_confident", - } - - result = _parse_params_to_nested_dict(params, divider="__") - assert result == { - "pool": { - "ivs": "%%independent_variables%%", - }, - "filter_pipeline": {"step1": {"n_samples": 100}, "step2": {"n_samples": 10}}, - "uncertainty_sampler": { - "model": "%%newest_theory%%", - "n": 10, - "measure": "least_confident", - }, - } - - -############################################################################## -# Parallel Pipelines -############################################################################## - - -def test_parallelpipeline_run(): - pl = make_pipeline([range(3), range(10, 13)], kind="union") - assert list(pl.run()) == [0, 1, 2, 10, 11, 12] - - -def test_parallelpipeline_many_steps(): - pl = make_pipeline([range(0, 5) for _ in range(1000)], kind="union") - results = list(pl.run()) - assert len(results) == 5000 - assert results[0:10] == [0, 1, 2, 3, 4, 0, 1, 2, 3, 4] diff --git a/tests/test_experimentalist_random.py b/tests/test_experimentalist_random.py deleted file mode 100644 index e85f0a72a..000000000 --- a/tests/test_experimentalist_random.py +++ /dev/null @@ -1,132 +0,0 @@ -from functools import partial - -import numpy as np -import pytest - -from autora.experimentalist.filter import weber_filter -from autora.experimentalist.pipeline import make_pipeline -from autora.experimentalist.pooler.general_pool import grid_pool -from autora.experimentalist.sampler import random_sampler -from autora.variable import DV, IV, ValueType, VariableCollection - - -def test_random_experimentalist(metadata): - """ - Tests the implementation of the experimentalist pipeline with an exhaustive pool of discrete - values, Weber filter, random selector. Tests two different implementations of the pool function - as a callable and passing in as interator/generator. - - """ - - n_trials = 25 # Number of trails for sampler to select - - # ---Implementation 1 - Pool using Callable via partial function---- - # Set up pipeline functions with partial - pooler_callable = partial(grid_pool, ivs=metadata.independent_variables) - sampler = partial(random_sampler, n=n_trials) - pipeline_random_samp = make_pipeline( - [pooler_callable, weber_filter, sampler], - ) - - results = pipeline_random_samp.run() - - # ***Checks*** - # Gridsearch pool is working as expected - _, pool = pipeline_random_samp.steps[0] - pool_len = len(list(pool())) - pool_len_expected = np.prod( - [len(s.allowed_values) for s in metadata.independent_variables] - ) - assert pool_len == pool_len_expected - - # Is sampling the number of trials we expect - assert len(results) == n_trials - - # Filter is selecting where IV1 >= IV2 - assert all([s[0] <= s[1] for s in results]) - - # Is sampling randomly. Runs 10 times and checks if consecutive runs are equal. - # Assert will fail if all 9 pairs return equal. - l_results = [pipeline_random_samp.run() for s in range(10)] - assert not np.all( - [ - np.array_equal(l_results[i], l_results[i + 1]) - for i, s in enumerate(l_results) - if i < len(l_results) - 1 - ] - ) - - -def test_random_experimentalist_generator(metadata): - n_trials = 25 # Number of trails for sampler to select - - pooler_generator = grid_pool(metadata.independent_variables) - sampler = partial(random_sampler, n=n_trials) - pipeline_random_samp_poolgen = make_pipeline( - [pooler_generator, weber_filter, sampler] - ) - - results_poolgen = list(pipeline_random_samp_poolgen.run()) - - # Is sampling the number of trials we expect - assert len(results_poolgen) == n_trials - - # Filter is selecting where IV1 >= IV2 - assert all([s[0] <= s[1] for s in results_poolgen]) - - # This will fail - # The Generator is exhausted after the first run and the pool is not regenerated when pipeline - # is run again. The pool should be set up as a callable if the pipeline is to be rerun. - results_poolgen2 = pipeline_random_samp_poolgen.run() - assert len(results_poolgen2) == 0 - - -@pytest.fixture -def metadata(): - # Specify independent variables - iv1 = IV( - name="S1", - allowed_values=np.linspace(0, 5, 5), - units="intensity", - variable_label="Stimulus 1 Intensity", - ) - - iv2 = IV( - name="S2", - allowed_values=np.linspace(0, 5, 5), - units="intensity", - variable_label="Stimulus 2 Intensity", - ) - - iv3 = IV( - name="S3", - allowed_values=[0, 1], - units="binary", - variable_label="Stimulus 3 Binary", - ) - - # Specify dependent variable with type - # The experimentalist pipeline doesn't actually use DVs, they are just specified here for - # example. - dv1 = DV( - name="difference_detected", - value_range=(0, 1), - units="probability", - variable_label="P(difference detected)", - type=ValueType.SIGMOID, - ) - - dv2 = DV( - name="difference_detected_sample", - value_range=(0, 1), - units="response", - variable_label="difference detected", - type=ValueType.PROBABILITY_SAMPLE, - ) - # Variable collection with ivs and dvs - metadata = VariableCollection( - independent_variables=[iv1, iv2, iv3], - dependent_variables=[dv1, dv2], - ) - - return metadata diff --git a/tests/test_experimentalist_uncertainty.py b/tests/test_experimentalist_uncertainty.py deleted file mode 100644 index 2e4657731..000000000 --- a/tests/test_experimentalist_uncertainty.py +++ /dev/null @@ -1,99 +0,0 @@ -from functools import partial - -import numpy as np -import pandas as pd -from sklearn.linear_model import LogisticRegression - -from autora.experimentalist.filter import weber_filter -from autora.experimentalist.pipeline import make_pipeline -from autora.experimentalist.pooler.general_pool import grid_pool -from autora.experimentalist.sampler import uncertainty_sampler -from autora.variable import DV, IV, ValueType, VariableCollection - - -def test_experimentalist_uncertainty(): - """ - Tests the implementation of the experimentalist pipeline with an exhaustive pool of discrete - values, Weber filter, uncertainty sampler. A logistic regression model is trained using - synthetic Weber experiment data for use in Uncertainty sampling. - - """ - # Load the data - resolution = 25 - s1_values = s2_values = np.linspace(0.2, 5.0, resolution) - X = np.array(np.meshgrid(s1_values, s2_values)).T.reshape(-1, 2) - # remove all combinations where s1 > s2 - X = X[X[:, 0] <= X[:, 1]] - - weber_constant = 1.0 - y = weber_constant * np.log(X[:, 1] / X[:, 0]) - - y_classified = np.where(y >= 0.5, 1, 0) - - # Train logistic regression model - logireg_model = LogisticRegression() - logireg_model.fit(X, y_classified) - - # Specify independent variables - iv1 = IV( - name="S1", - allowed_values=np.linspace(0, 5, 5), - units="intensity", - variable_label="Stimulus 1 Intensity", - ) - - iv2 = IV( - name="S2", - allowed_values=np.linspace(0, 5, 5), - units="intensity", - variable_label="Stimulus 2 Intensity", - ) - - # The experimentalist pipeline doesn't actually use DVs, they are just specified here for - # example. - dv1 = DV( - name="difference_detected", - value_range=(0, 1), - units="probability", - variable_label="P(difference detected)", - type=ValueType.PROBABILITY, - ) - - # Variable collection with ivs and dvs - metadata = VariableCollection( - independent_variables=[iv1, iv2], - dependent_variables=[dv1], - ) - - n_trials = 10 # Number of trails for sampler to select - - # Set up pipeline functions with partial - pooler_callable = partial(grid_pool, ivs=metadata.independent_variables) - sampler = partial( - uncertainty_sampler, model=logireg_model, n=n_trials, measure="least_confident" - ) - - # Initialize pipeline - pipeline = make_pipeline([pooler_callable, weber_filter, sampler]) - # Run the pipeline - results = pipeline.run() - - # ***Checks*** - # Is sampling the number of trials we expect - assert len(results) == n_trials - - # Filter is selecting where IV1 >= IV2 - assert all([s[0] <= s[1] for s in results]) - - # Uncertainty sampling is behaving as expected by comparing results with manual calculation - pipeline_pool_filter = make_pipeline([pooler_callable, weber_filter]) - pool = np.array(list(pipeline_pool_filter.run())) # Create filtered pool - a_prob = logireg_model.predict_proba(pool) # Get predicted probabilities - # Calculate and sort max probability from each condition - s_max_prob = pd.Series([np.max(s) for s in a_prob]).sort_values(ascending=True) - select_idx = s_max_prob.index[ - 0:n_trials - ].to_list() # Get index of lowest probabilities - results_manual = pool[select_idx] # Index conditions from pool - # Check results from the function match manaual method - assert np.array_equal(results, results_manual) diff --git a/tests/test_model_disagreement_sampler.py b/tests/test_model_disagreement_sampler.py deleted file mode 100644 index ed987681e..000000000 --- a/tests/test_model_disagreement_sampler.py +++ /dev/null @@ -1,131 +0,0 @@ -import numpy as np -import pytest -from sklearn.linear_model import LinearRegression, LogisticRegression -from sklearn.pipeline import Pipeline -from sklearn.preprocessing import PolynomialFeatures - -from autora.experimentalist.sampler.model_disagreement import model_disagreement_sampler - - -def get_classification_data(n: int = 100): - x1 = np.linspace(0, 1, n) - x2 = np.linspace(0, 1, n) - - # cross product of x1 and x2 - X = np.array([(x1[i], x2[j]) for i in range(len(x1)) for j in range(len(x2))]) - - # create a vector of 0s and 1s which is 0 whenever x1 < 0.5 and x2 < 0.5 and 1 otherwise - y_A = np.zeros(n * n) - y_B = np.zeros(n * n) - y_A[(X[:, 0] >= 0.5) | (X[:, 1] >= 0.5)] = 1 - y_B[(X[:, 0] >= 0.5)] = 1 - - return X, y_A, y_B - - -def get_polynomial_data(n: int = 100): - x = np.linspace(-1, 1, 100) - y = x**2 - return x, y - - -@pytest.fixture -def synthetic_lr_models(): - """ - Creates two logistic regression classifier for 2 classes based on synthetic data. - Each classifier is trained on a different data set and thus should yield different predictions. - """ - X, y_A, y_B = get_classification_data() - model_A = LogisticRegression() - model_B = LogisticRegression() - model_A.fit(X, y_A) - model_B.fit(X, y_B) - - models = [model_A, model_B] - return models - - -@pytest.fixture -def synthetic_linr_model(): - """ - Creates linear regression based on synthetic data. - """ - x, y = get_polynomial_data() - model = LinearRegression() - model.fit(x.reshape(-1, 1), y) - return model - - -@pytest.fixture -def synthetic_poly_model(): - """ - Creates polynomial regression based on synthetic data. - """ - x, y = get_polynomial_data() - - # define the steps in the pipeline - steps = [ - ( - "poly", - PolynomialFeatures(degree=3), - ), # transform input data into polynomial features - ("lr", LinearRegression()), # fit a linear regression model - ] - # create the pipeline - model = Pipeline(steps) - model.fit(x.reshape(-1, 1), y) - return model - - -@pytest.fixture -def classification_data_to_test(n=10): - x1 = np.linspace(0, 1, n) - x2 = np.linspace(0, 1, n) - - # cross product of x1 and x2 - X = np.array([(x1[i], x2[j]) for i in range(len(x1)) for j in range(len(x2))]) - return X - - -@pytest.fixture -def regression_data_to_test(n=100): - data = np.linspace(-2, 2, n) - return data - - -def test_model_disagreement_classification( - synthetic_lr_models, classification_data_to_test -): - - num_requested_samples = 10 - - # Import model and data - X = classification_data_to_test - models = synthetic_lr_models - - # Run model disagreement sampler - samples = model_disagreement_sampler(X, models, num_requested_samples) - - assert samples.shape[0] == num_requested_samples - assert samples[0, 0] < 0.25 and samples[0, 1] > 0.75 - assert samples[1, 0] < 0.25 and samples[1, 1] > 0.75 - - -def test_model_disagreement_regression( - synthetic_linr_model, synthetic_poly_model, regression_data_to_test -): - - num_requested_samples = 2 - - # Import model and data - X = regression_data_to_test - model_A = synthetic_linr_model - model_B = synthetic_poly_model - models = [model_A, model_B] - - # Run model disagreement sampler - samples = model_disagreement_sampler(X, models, num_requested_samples) - - assert len(samples) == num_requested_samples - assert samples[0] == 2.0 or samples[0] == -2.0 - assert samples[1] == 2.0 or samples[1] == -2.0 diff --git a/tests/test_poppernet_pooler.py b/tests/test_poppernet_pooler.py deleted file mode 100644 index c2d4d1078..000000000 --- a/tests/test_poppernet_pooler.py +++ /dev/null @@ -1,202 +0,0 @@ -import numpy as np -import pytest -import torch -from sklearn.linear_model import LinearRegression, LogisticRegression - -from autora.experimentalist.pipeline import Pipeline -from autora.experimentalist.pooler import poppernet_pool -from autora.experimentalist.sampler import nearest_values_sampler -from autora.variable import DV, IV, ValueType, VariableCollection - - -@pytest.fixture -def seed(): - """ - Ensures that the results are the same each time the tests are run. - """ - torch.manual_seed(180) - return - - -def get_xor_data(n: int = 3): - X = ([[1, 0]] * n) + ([[0, 1]] * n) + ([[0, 0]] * n) + ([[1, 1]]) - y = ([0] * n) + ([0] * n) + ([1] * n) + ([1]) - return X, y - - -def get_sin_data(n: int = 100): - x = np.linspace(0, 2 * np.pi, 100) - y = np.sin(x) - return x, y - - -@pytest.fixture -def synthetic_logr_model(): - """ - Creates logistic regression classifier for 3 classes based on synthetic data. - """ - X, y = get_xor_data() - model = LogisticRegression() - model.fit(X, y) - return model - - -@pytest.fixture -def synthetic_linr_model(): - """ - Creates linear regression based on synthetic data. - """ - x, y = get_sin_data() - model = LinearRegression() - model.fit(x.reshape(-1, 1), y) - return model - - -@pytest.fixture -def classification_data_to_test(): - data = np.array( - [ - [1, 0], - [0, 1], - [0, 0], - [1, 1], - ] - ) - return data - - -@pytest.fixture -def regression_data_to_test(): - data = [-10, 0, 1.5, 3, 4.5, 6, 10] - return data - - -def test_poppernet_classification( - synthetic_logr_model, classification_data_to_test, seed -): - - # Import model and data - X_train, Y_train = get_xor_data() - X = classification_data_to_test - model = synthetic_logr_model - - # Specify independent variables - iv1 = IV( - name="x", - value_range=(0, 5), - units="intensity", - variable_label="stimulus 1", - ) - - # specify dependent variables - dv1 = DV( - name="y", - value_range=(0, 1), - units="class", - variable_label="class", - type=ValueType.CLASS, - ) - - # Variable collection with ivs and dvs - metadata = VariableCollection( - independent_variables=[iv1, iv1], - dependent_variables=[dv1], - ) - - # Run popper net sampler - poppernet_pipeline = Pipeline( - [("pool", poppernet_pool), ("sampler", nearest_values_sampler)], - params={ - "pool": dict( - model=model, - x_train=X_train, - y_train=Y_train, - metadata=metadata, - n=2, - training_epochs=1000, - optimization_epochs=1000, - training_lr=1e-3, - optimization_lr=1e-3, - mse_scale=1, - limit_offset=10**-10, - limit_repulsion=0, - ), - "sampler": {"allowed_values": X, "n": 2}, - }, - ) - - samples = poppernet_pipeline.run() - - print(samples) - # Check that at least one of the resulting samples is the one that is - # underrepresented in the data used for model training - - assert (samples[0, :] == [1, 1]).all or (samples[1, :] == [1, 1]).all - - -def test_poppernet_regression(synthetic_linr_model, regression_data_to_test, seed): - - # Import model and data - X_train, Y_train = get_sin_data() - X = regression_data_to_test - model = synthetic_linr_model - - # specify meta data - - # Specify independent variables - iv = IV( - name="x", - value_range=(0, 2 * np.pi), - units="intensity", - variable_label="stimulus", - ) - - # specify dependent variables - dv = DV( - name="y", - value_range=(-1, 1), - units="real", - variable_label="response", - type=ValueType.REAL, - ) - - # Variable collection with ivs and dvs - metadata = VariableCollection( - independent_variables=[iv], - dependent_variables=[dv], - ) - - poppernet_pipeline = Pipeline( - [("pool", poppernet_pool), ("sampler", nearest_values_sampler)], - params={ - "pool": dict( - model=model, - x_train=X_train, - y_train=Y_train, - metadata=metadata, - n=5, - training_epochs=1000, - optimization_epochs=5000, - training_lr=1e-3, - optimization_lr=1e-3, - mse_scale=1, - limit_offset=0, - limit_repulsion=0.01, - ), - "sampler": {"allowed_values": X, "n": 5}, - }, - ) - - sample = poppernet_pipeline.run() - - # the first value should be close to one of the local maxima of the - # sine function - assert ( - sample[0] == 1.5 - or sample[0] == 4.5 - or sample[0] == 6 - or sample[0] == 0 - or sample[0] == 3 - ) - if sample[0] == 6 or sample[0] == 0 or sample[0] == 3: - assert sample[1] == 4.5 or sample[1] == 1.5 diff --git a/tests/test_sklearn_bms.py b/tests/test_sklearn_bms.py deleted file mode 100644 index 8ce99033e..000000000 --- a/tests/test_sklearn_bms.py +++ /dev/null @@ -1,266 +0,0 @@ -import warnings - -import numpy as np -import pandas as pd -from sklearn.model_selection import train_test_split - -from autora.skl.bms import BMSRegressor - -warnings.filterwarnings("ignore") - - -def generate_noisy_constant_data( - const: float = 0.5, epsilon: float = 0.01, num: int = 1000, seed: int = 42 -): - X = np.expand_dims(np.linspace(start=0, stop=1, num=num), 1) - y = np.random.default_rng(seed).normal(loc=const, scale=epsilon, size=num) - return X, y, const, epsilon - - -def test_constant_model(): - X, y, const, epsilon = generate_noisy_constant_data() - for x in X: - print(x) - if x[0] == 0.0: - x[0] = 0.001 - print(X) - X_train, X_test, y_train, y_test = train_test_split( - X, y, test_size=0.2, random_state=42 - ) - estimator = BMSRegressor(epochs=30) - assert estimator is not None - estimator.fit(X_train, y_train) - # print(X_train) - # print(estimator.model_) - # print(estimator.predict(X_test)) - - -def test_weber_model(): - raw_data = pd.DataFrame( - columns=["S1", "S2", "difference_detected"], - data=np.array( - [ - (0.0, 0.0, 0.5), - (0.0, 0.2631578947368421, 0.5654124021530151), - (0.0, 0.5263157894736842, 0.6286234259605408), - (0.0, 0.7894736842105263, 0.6877183318138123), - (0.0, 1.0526315789473684, 0.7412799000740051), - (0.0, 1.3157894736842104, 0.7884804010391235), - (0.0, 1.5789473684210529, 0.8290553689002991), - (0.0, 1.8421052631578947, 0.8631975054740906), - (0.0, 2.1052631578947367, 0.8914136290550232), - (0.0, 2.3684210526315788, 0.9143873453140259), - (0.0, 2.631578947368421, 0.9328665137290955), - (0.0, 2.8947368421052633, 0.9475856423377991), - (0.0, 3.1578947368421053, 0.9592186808586121), - (0.0, 3.421052631578948, 0.9683560729026794), - (0.0, 3.684210526315789, 0.975498378276825), - (0.0, 3.947368421052632, 0.9810601472854614), - (0.0, 4.2105263157894735, 0.9853783845901489), - (0.0, 4.473684210526316, 0.9887233972549438), - (0.0, 4.7368421052631575, 0.9913098812103271), - (0.0, 5.0, 0.9933071732521057), - (0.2631578947368421, 0.2631578947368421, 0.43458759784698486), - (0.2631578947368421, 0.5263157894736842, 0.5), - (0.2631578947368421, 0.7894736842105263, 0.5654124021530151), - (0.2631578947368421, 1.0526315789473684, 0.6286234259605408), - (0.2631578947368421, 1.3157894736842104, 0.6877183318138123), - (0.2631578947368421, 1.5789473684210529, 0.7412799000740051), - (0.2631578947368421, 1.8421052631578947, 0.7884804010391235), - (0.2631578947368421, 2.1052631578947367, 0.8290553689002991), - (0.2631578947368421, 2.3684210526315788, 0.8631975054740906), - (0.2631578947368421, 2.631578947368421, 0.8914136290550232), - (0.2631578947368421, 2.8947368421052633, 0.9143873453140259), - (0.2631578947368421, 3.1578947368421053, 0.9328665137290955), - (0.2631578947368421, 3.421052631578948, 0.9475856423377991), - (0.2631578947368421, 3.684210526315789, 0.9592186808586121), - (0.2631578947368421, 3.947368421052632, 0.9683560729026794), - (0.2631578947368421, 4.2105263157894735, 0.975498378276825), - (0.2631578947368421, 4.473684210526316, 0.9810601472854614), - (0.2631578947368421, 4.7368421052631575, 0.9853783845901489), - (0.2631578947368421, 5.0, 0.9887233972549438), - (0.5263157894736842, 0.5263157894736842, 0.37137657403945923), - (0.5263157894736842, 0.7894736842105263, 0.43458759784698486), - (0.5263157894736842, 1.0526315789473684, 0.5), - (0.5263157894736842, 1.3157894736842104, 0.5654124021530151), - (0.5263157894736842, 1.5789473684210529, 0.6286234259605408), - (0.5263157894736842, 1.8421052631578947, 0.6877183318138123), - (0.5263157894736842, 2.1052631578947367, 0.7412799000740051), - (0.5263157894736842, 2.3684210526315788, 0.7884804010391235), - (0.5263157894736842, 2.631578947368421, 0.8290553689002991), - (0.5263157894736842, 2.8947368421052633, 0.8631975054740906), - (0.5263157894736842, 3.1578947368421053, 0.8914136290550232), - (0.5263157894736842, 3.421052631578948, 0.9143873453140259), - (0.5263157894736842, 3.684210526315789, 0.9328665137290955), - (0.5263157894736842, 3.947368421052632, 0.9475856423377991), - (0.5263157894736842, 4.2105263157894735, 0.9592186808586121), - (0.5263157894736842, 4.473684210526316, 0.9683560729026794), - (0.5263157894736842, 4.7368421052631575, 0.975498378276825), - (0.5263157894736842, 5.0, 0.9810601472854614), - (0.7894736842105263, 0.7894736842105263, 0.31228166818618774), - (0.7894736842105263, 1.0526315789473684, 0.37137657403945923), - (0.7894736842105263, 1.3157894736842104, 0.43458759784698486), - (0.7894736842105263, 1.5789473684210529, 0.5), - (0.7894736842105263, 1.8421052631578947, 0.5654124021530151), - (0.7894736842105263, 2.1052631578947367, 0.6286234259605408), - (0.7894736842105263, 2.3684210526315788, 0.6877182722091675), - (0.7894736842105263, 2.631578947368421, 0.7412799000740051), - (0.7894736842105263, 2.8947368421052633, 0.788480281829834), - (0.7894736842105263, 3.1578947368421053, 0.8290553689002991), - (0.7894736842105263, 3.421052631578948, 0.8631974458694458), - (0.7894736842105263, 3.684210526315789, 0.8914136290550232), - (0.7894736842105263, 3.947368421052632, 0.9143873453140259), - (0.7894736842105263, 4.2105263157894735, 0.9328665137290955), - (0.7894736842105263, 4.473684210526316, 0.9475856423377991), - (0.7894736842105263, 4.7368421052631575, 0.9592186808586121), - (0.7894736842105263, 5.0, 0.9683560729026794), - (1.0526315789473684, 1.0526315789473684, 0.2587200701236725), - (1.0526315789473684, 1.3157894736842104, 0.31228166818618774), - (1.0526315789473684, 1.5789473684210529, 0.37137657403945923), - (1.0526315789473684, 1.8421052631578947, 0.43458759784698486), - (1.0526315789473684, 2.1052631578947367, 0.5), - (1.0526315789473684, 2.3684210526315788, 0.5654124021530151), - (1.0526315789473684, 2.631578947368421, 0.628623366355896), - (1.0526315789473684, 2.8947368421052633, 0.6877182722091675), - (1.0526315789473684, 3.1578947368421053, 0.7412799000740051), - (1.0526315789473684, 3.421052631578948, 0.7884804010391235), - (1.0526315789473684, 3.684210526315789, 0.8290553689002991), - (1.0526315789473684, 3.947368421052632, 0.8631974458694458), - (1.0526315789473684, 4.2105263157894735, 0.8914136290550232), - (1.0526315789473684, 4.473684210526316, 0.9143873453140259), - (1.0526315789473684, 4.7368421052631575, 0.9328665137290955), - (1.0526315789473684, 5.0, 0.9475856423377991), - (1.3157894736842104, 1.3157894736842104, 0.21151967346668243), - (1.3157894736842104, 1.5789473684210529, 0.2587200999259949), - (1.3157894736842104, 1.8421052631578947, 0.31228169798851013), - (1.3157894736842104, 2.1052631578947367, 0.3713766038417816), - (1.3157894736842104, 2.3684210526315788, 0.43458759784698486), - (1.3157894736842104, 2.631578947368421, 0.5), - (1.3157894736842104, 2.8947368421052633, 0.5654124021530151), - (1.3157894736842104, 3.1578947368421053, 0.6286234855651855), - (1.3157894736842104, 3.421052631578948, 0.6877183318138123), - (1.3157894736842104, 3.684210526315789, 0.7412799000740051), - (1.3157894736842104, 3.947368421052632, 0.7884804010391235), - (1.3157894736842104, 4.2105263157894735, 0.8290553689002991), - (1.3157894736842104, 4.473684210526316, 0.8631975054740906), - (1.3157894736842104, 4.7368421052631575, 0.8914136290550232), - (1.3157894736842104, 5.0, 0.9143873453140259), - (1.5789473684210529, 1.5789473684210529, 0.17094460129737854), - (1.5789473684210529, 1.8421052631578947, 0.21151965856552124), - (1.5789473684210529, 2.1052631578947367, 0.2587200701236725), - (1.5789473684210529, 2.3684210526315788, 0.31228166818618774), - (1.5789473684210529, 2.631578947368421, 0.37137654423713684), - (1.5789473684210529, 2.8947368421052633, 0.4345875084400177), - (1.5789473684210529, 3.1578947368421053, 0.5), - (1.5789473684210529, 3.421052631578948, 0.5654124021530151), - (1.5789473684210529, 3.684210526315789, 0.6286234259605408), - (1.5789473684210529, 3.947368421052632, 0.6877183318138123), - (1.5789473684210529, 4.2105263157894735, 0.7412799000740051), - (1.5789473684210529, 4.473684210526316, 0.788480281829834), - (1.5789473684210529, 4.7368421052631575, 0.8290553689002991), - (1.5789473684210529, 5.0, 0.8631974458694458), - (1.8421052631578947, 1.8421052631578947, 0.13680249452590942), - (1.8421052631578947, 2.1052631578947367, 0.17094461619853973), - (1.8421052631578947, 2.3684210526315788, 0.21151967346668243), - (1.8421052631578947, 2.631578947368421, 0.2587200701236725), - (1.8421052631578947, 2.8947368421052633, 0.31228166818618774), - (1.8421052631578947, 3.1578947368421053, 0.3713766038417816), - (1.8421052631578947, 3.421052631578948, 0.43458759784698486), - (1.8421052631578947, 3.684210526315789, 0.5), - (1.8421052631578947, 3.947368421052632, 0.5654124021530151), - (1.8421052631578947, 4.2105263157894735, 0.6286234259605408), - (1.8421052631578947, 4.473684210526316, 0.6877183318138123), - (1.8421052631578947, 4.7368421052631575, 0.7412799000740051), - (1.8421052631578947, 5.0, 0.788480281829834), - (2.1052631578947367, 2.1052631578947367, 0.10858631134033203), - (2.1052631578947367, 2.3684210526315788, 0.13680247962474823), - (2.1052631578947367, 2.631578947368421, 0.17094458639621735), - (2.1052631578947367, 2.8947368421052633, 0.21151962876319885), - (2.1052631578947367, 3.1578947368421053, 0.2587200701236725), - (2.1052631578947367, 3.421052631578948, 0.31228166818618774), - (2.1052631578947367, 3.684210526315789, 0.37137654423713684), - (2.1052631578947367, 3.947368421052632, 0.4345875084400177), - (2.1052631578947367, 4.2105263157894735, 0.5), - (2.1052631578947367, 4.473684210526316, 0.5654124021530151), - (2.1052631578947367, 4.7368421052631575, 0.628623366355896), - (2.1052631578947367, 5.0, 0.6877182722091675), - (2.3684210526315788, 2.3684210526315788, 0.08561266213655472), - (2.3684210526315788, 2.631578947368421, 0.10858631134033203), - (2.3684210526315788, 2.8947368421052633, 0.13680247962474823), - (2.3684210526315788, 3.1578947368421053, 0.17094461619853973), - (2.3684210526315788, 3.421052631578948, 0.21151967346668243), - (2.3684210526315788, 3.684210526315789, 0.2587200701236725), - (2.3684210526315788, 3.947368421052632, 0.31228166818618774), - (2.3684210526315788, 4.2105263157894735, 0.3713766038417816), - (2.3684210526315788, 4.473684210526316, 0.43458759784698486), - (2.3684210526315788, 4.7368421052631575, 0.5), - (2.3684210526315788, 5.0, 0.5654124021530151), - (2.631578947368421, 2.631578947368421, 0.06713350117206573), - (2.631578947368421, 2.8947368421052633, 0.08561266213655472), - (2.631578947368421, 3.1578947368421053, 0.10858633369207382), - (2.631578947368421, 3.421052631578948, 0.13680250942707062), - (2.631578947368421, 3.684210526315789, 0.17094461619853973), - (2.631578947368421, 3.947368421052632, 0.21151967346668243), - (2.631578947368421, 4.2105263157894735, 0.25872012972831726), - (2.631578947368421, 4.473684210526316, 0.3122817277908325), - (2.631578947368421, 4.7368421052631575, 0.3713766038417816), - (2.631578947368421, 5.0, 0.43458759784698486), - (2.8947368421052633, 2.8947368421052633, 0.052414361387491226), - (2.8947368421052633, 3.1578947368421053, 0.06713351607322693), - (2.8947368421052633, 3.421052631578948, 0.08561268448829651), - (2.8947368421052633, 3.684210526315789, 0.10858633369207382), - (2.8947368421052633, 3.947368421052632, 0.13680250942707062), - (2.8947368421052633, 4.2105263157894735, 0.17094466090202332), - (2.8947368421052633, 4.473684210526316, 0.21151971817016602), - (2.8947368421052633, 4.7368421052631575, 0.25872012972831726), - (2.8947368421052633, 5.0, 0.3122817277908325), - (3.1578947368421053, 3.1578947368421053, 0.04078132286667824), - (3.1578947368421053, 3.421052631578948, 0.052414342761039734), - (3.1578947368421053, 3.684210526315789, 0.06713348627090454), - (3.1578947368421053, 3.947368421052632, 0.08561263978481293), - (3.1578947368421053, 4.2105263157894735, 0.10858631134033203), - (3.1578947368421053, 4.473684210526316, 0.13680247962474823), - (3.1578947368421053, 4.7368421052631575, 0.17094458639621735), - (3.1578947368421053, 5.0, 0.21151962876319885), - (3.421052631578948, 3.421052631578948, 0.031643956899642944), - (3.421052631578948, 3.684210526315789, 0.04078132286667824), - (3.421052631578948, 3.947368421052632, 0.052414342761039734), - (3.421052631578948, 4.2105263157894735, 0.06713350117206573), - (3.421052631578948, 4.473684210526316, 0.08561266213655472), - (3.421052631578948, 4.7368421052631575, 0.10858631134033203), - (3.421052631578948, 5.0, 0.13680247962474823), - (3.684210526315789, 3.684210526315789, 0.024501590058207512), - (3.684210526315789, 3.947368421052632, 0.031643956899642944), - (3.684210526315789, 4.2105263157894735, 0.04078133404254913), - (3.684210526315789, 4.473684210526316, 0.052414361387491226), - (3.684210526315789, 4.7368421052631575, 0.06713350117206573), - (3.684210526315789, 5.0, 0.08561266213655472), - (3.947368421052632, 3.947368421052632, 0.018939798697829247), - (3.947368421052632, 4.2105263157894735, 0.02450159564614296), - (3.947368421052632, 4.473684210526316, 0.03164396435022354), - (3.947368421052632, 4.7368421052631575, 0.04078133404254913), - (3.947368421052632, 5.0, 0.052414361387491226), - (4.2105263157894735, 4.2105263157894735, 0.01462159026414156), - (4.2105263157894735, 4.473684210526316, 0.0189397931098938), - (4.2105263157894735, 4.7368421052631575, 0.024501584470272064), - (4.2105263157894735, 5.0, 0.03164394944906235), - (4.473684210526316, 4.473684210526316, 0.011276605539023876), - (4.473684210526316, 4.7368421052631575, 0.01462159026414156), - (4.473684210526316, 5.0, 0.0189397931098938), - (4.7368421052631575, 4.7368421052631575, 0.008690104819834232), - (4.7368421052631575, 5.0, 0.011276605539023876), - (5.0, 5.0, 0.006692850962281227), - ] - ), - ) - - X, y = raw_data[["S1", "S2"]], raw_data["difference_detected"] - estimator = BMSRegressor(epochs=30) - estimator.fit(X, y) - # print(X_train) - # print(estimator.model_) - # print(estimator.predict(X_test)) - - -if __name__ == "__main__": - test_weber_model() diff --git a/tests/test_sklearn_darts.py b/tests/test_sklearn_darts.py deleted file mode 100644 index fb4d18f9c..000000000 --- a/tests/test_sklearn_darts.py +++ /dev/null @@ -1,315 +0,0 @@ -from copy import deepcopy - -import numpy as np -import pandas as pd -import pytest -import torch -from sklearn.model_selection import GridSearchCV, train_test_split - -from autora.skl.darts import ( - PRIMITIVES, - DARTSExecutionMonitor, - DARTSRegressor, - DARTSType, - ValueType, -) - - -@pytest.fixture -def seed(): - """ - Ensures that the results are the same each time the tests are run. - """ - torch.manual_seed(180) - return - - -def generate_noisy_constant_data( - const: float = 0.5, epsilon: float = 0.01, num: int = 1000, seed: int = 42 -): - X = np.expand_dims(np.linspace(start=0, stop=1, num=num), 1) - y = np.random.default_rng(seed).normal(loc=const, scale=epsilon, size=num) - return X, y, const, epsilon - - -def generate_constant_data(const: float = 0.5, num: int = 1000): - X = np.expand_dims(np.linspace(start=0, stop=1, num=num), 1) - y = const * np.ones(num) - return X, y, const - - -def generate_noisy_linear_data( - const: float = 0.5, - gradient=0.25, - epsilon: float = 0.01, - num: int = 1000, - seed: int = 42, - start: float = 0, - stop: float = 1, -): - X = np.expand_dims(np.linspace(start=start, stop=stop, num=num), 1) - y = ( - (gradient * X.ravel()) - + const - + np.random.default_rng(seed).normal(loc=0, scale=epsilon, size=num) - ) - return ( - X, - y, - const, - gradient, - epsilon, - ) - - -def test_constant_model(seed): - - X, y, const, epsilon = generate_noisy_constant_data() - - X_train, X_test, y_train, y_test = train_test_split( - X, y, test_size=0.2, random_state=42 - ) - - estimator = DARTSRegressor(num_graph_nodes=1) - - estimator.fit(X_train, y_train) - - assert estimator is not None - - for y_pred_i in np.nditer(estimator.predict(X_test)): - assert (const - (5.0 * epsilon)) <= y_pred_i <= (const + (5.0 * epsilon)) - - print(estimator.network_) - - -def test_enum_string_inputs(): - - X, y, const, epsilon = generate_noisy_constant_data() - - kwargs = dict( - num_graph_nodes=1, - max_epochs=1, - arch_updates_per_epoch=1, - param_updates_per_epoch=1, - ) - - DARTSRegressor(darts_type="fair", **kwargs).fit(X, y) - DARTSRegressor(darts_type=DARTSType.FAIR, **kwargs).fit(X, y) - DARTSRegressor(darts_type="original", **kwargs).fit(X, y) - DARTSRegressor(darts_type=DARTSType.ORIGINAL, **kwargs).fit(X, y) - - DARTSRegressor(output_type="probability", **kwargs).fit(X, y) - DARTSRegressor(output_type=ValueType.PROBABILITY, **kwargs).fit(X, y) - DARTSRegressor(output_type=ValueType.PROBABILITY_SAMPLE, **kwargs).fit(X, y) - DARTSRegressor(output_type="probability_distribution", **kwargs).fit(X, y) - DARTSRegressor(output_type=ValueType.PROBABILITY_DISTRIBUTION, **kwargs).fit(X, y) - with pytest.raises(NotImplementedError): - DARTSRegressor(output_type="class", **kwargs).fit(X, y) - with pytest.raises(NotImplementedError): - DARTSRegressor(output_type=ValueType.CLASS, **kwargs).fit(X, y) - - -def test_model_repr(): - - X, y, const, epsilon = generate_noisy_constant_data() - - kwargs = dict( - max_epochs=1, - arch_updates_per_epoch=1, - param_updates_per_epoch=1, - ) - - print(DARTSRegressor(num_graph_nodes=1, **kwargs).fit(X, y).model_repr()) - print(DARTSRegressor(num_graph_nodes=2, **kwargs).fit(X, y).model_repr()) - print(DARTSRegressor(num_graph_nodes=4, **kwargs).fit(X, y).model_repr()) - print(DARTSRegressor(num_graph_nodes=8, **kwargs).fit(X, y).model_repr()) - print(DARTSRegressor(num_graph_nodes=16, **kwargs).fit(X, y).model_repr()) - - -def test_primitive_selection(): - X, y, const, epsilon = generate_noisy_constant_data() - - kwargs = dict( - num_graph_nodes=1, - max_epochs=1, - arch_updates_per_epoch=1, - param_updates_per_epoch=1, - ) - - DARTSRegressor(primitives=["add", "subtract", "none"], **kwargs).fit(X, y) - DARTSRegressor(primitives=PRIMITIVES, **kwargs).fit(X, y) - with pytest.raises(NotImplementedError): - NotImplementedError, DARTSRegressor(primitives=["doesnt_exist"], **kwargs).fit( - X, y - ) - - -def test_fit_with_fixed_architecture(): - X, y, _, _, _ = generate_noisy_linear_data( - start=-5, stop=+5, const=10.0, gradient=20.0 - ) - X1, y1, _, _, _ = generate_noisy_linear_data( - start=-5, stop=+5, const=10.0, gradient=5.0 - ) - - # Initialize the fitter - regressor = DARTSRegressor( - primitives=["linear", "mult"], - num_graph_nodes=1, - ) - - # First fit: normal fitting - regressor.set_params( - max_epochs=500, - arch_updates_per_epoch=1, - param_updates_per_epoch=50, - param_updates_for_sampled_model=1000, - ) - regressor.fit(X, y) - network_weights_initial = deepcopy(regressor.network_.alphas_normal) - equation_initial = regressor.model_repr() - print(equation_initial) - - # Refit by setting epochs to one and arch updates to zero, and fit some different data - regressor.set_params( - max_epochs=0, - param_updates_for_sampled_model=1000, - ) - regressor.fit(X1, y1) - network_weights_refitted = deepcopy(regressor.network_.alphas_normal) - equation_refitted = regressor.model_repr() - print(equation_refitted) - - # Architecture weights should be the same - assert torch.all(network_weights_initial.eq(network_weights_refitted)) - - # ... but equations should be different - assert equation_initial != equation_refitted - - # Now refit using the "sampler". - regressor.set_params( - max_epochs=0, - param_updates_for_sampled_model=1000, - sampling_strategy="sample", - ) - regressor.fit(X1, y1) - equation_resampled = regressor.model_repr() - print(equation_resampled) - - # Now return to the original settings and recover the original results. - regressor.set_params( - max_epochs=0, - param_updates_for_sampled_model=1000, - sampling_strategy="max", - ) - regressor.fit(X, y) - network_weights_max_recovered = deepcopy(regressor.network_.alphas_normal) - equation_max_recovered = regressor.model_repr() - print(equation_max_recovered) - assert equation_initial == equation_max_recovered - assert torch.all(network_weights_initial.eq(network_weights_max_recovered)) - - -def test_metaparam_optimization(): - - X, y, const = generate_constant_data() - - X_train, X_test, y_train, y_test = train_test_split( - X, y, test_size=0.2, random_state=42 - ) - - estimator = GridSearchCV( - estimator=DARTSRegressor(), - cv=2, - param_grid=[ - { - "max_epochs": [1, 5], - "arch_updates_per_epoch": [5, 10], - "num_graph_nodes": [1, 2], - } - ], - ) - - estimator.fit(X_train, y_train) - - -def test_execution_monitor(): - - X, y, const, epsilon = generate_noisy_constant_data() - - kwargs = dict() - - execution_monitor_0 = DARTSExecutionMonitor() - - DARTSRegressor( - primitives=["add", "subtract", "none", "mult", "logistic"], - execution_monitor=execution_monitor_0.execution_monitor, - num_graph_nodes=3, - max_epochs=100, - param_updates_per_epoch=100, - **kwargs - ).fit(X, y) - execution_monitor_0.display() - - execution_monitor_1 = DARTSExecutionMonitor() - DARTSRegressor( - primitives=["add", "ln"], - num_graph_nodes=5, - max_epochs=100, - param_updates_per_epoch=100, - execution_monitor=execution_monitor_1.execution_monitor, - **kwargs - ).fit(X, y) - execution_monitor_1.display() - - execution_monitor_2 = DARTSExecutionMonitor() - DARTSRegressor( - primitives=["add", "subtract", "none", "mult", "logistic"], - execution_monitor=execution_monitor_2.execution_monitor, - num_graph_nodes=1, - max_epochs=100, - param_updates_per_epoch=100, - **kwargs - ).fit(X, y) - execution_monitor_2.display() - - -def test_label_getter(): - - X, y, _ = generate_constant_data(num=10) - df = pd.DataFrame( - { - "input_x1": X.ravel(), - "input_x2": X.ravel(), - "output_y1": y.ravel(), - "output_y2": y.ravel(), - } - ) - kwargs = dict(num_graph_nodes=1, max_epochs=0, param_updates_for_sampled_model=0) - - input_dataframe_single_column = df[["input_x1"]] - input_dataframe_multi_column = df[["input_x1", "input_x2"]] - - # The input "series" case is not supported – we enforce 2d inputs for the X values - - output_dataframe_single_column = df[["output_y1"]] - output_series_single_column = df["output_y1"] - output_dataframe_multi_column = df[["output_y1", "output_y2"]] - - estimator0 = DARTSRegressor(**kwargs).fit( - input_dataframe_single_column, output_dataframe_single_column - ) - assert estimator0._get_input_labels() == ("input_x1",) - assert estimator0._get_output_labels() == ("output_y1",) - - estimator0 = DARTSRegressor(**kwargs).fit( - input_dataframe_single_column, output_series_single_column - ) - assert estimator0._get_input_labels() == ("input_x1",) - assert estimator0._get_output_labels() == ("output_y1",) - - estimator1 = DARTSRegressor(**kwargs).fit( - input_dataframe_multi_column, output_dataframe_multi_column - ) - assert estimator1._get_input_labels() == ("input_x1", "input_x2") - assert estimator1._get_output_labels() == ("output_y1", "output_y2") diff --git a/tests/test_sklearn_pipeline.py b/tests/test_sklearn_pipeline.py deleted file mode 100644 index fa130fa5c..000000000 --- a/tests/test_sklearn_pipeline.py +++ /dev/null @@ -1,56 +0,0 @@ -import numpy as np -import sklearn.pipeline as skp -from sklearn.linear_model import LogisticRegression -from sklearn.preprocessing import StandardScaler - -from autora.cycle import Cycle -from autora.experimentalist.pipeline import Pipeline -from autora.experimentalist.sampler import random_sampler -from autora.variable import Variable, VariableCollection - - -def test_skpipe_theory_copy(): - """Checks that a deep copy is performed when the autora.Cycle is copying the theorist.""" - - X = np.linspace(0, 1, 10) - - # Variable Metadata - study_metadata = VariableCollection( - independent_variables=[ - Variable(name="x", units="cm", allowed_values=np.linspace(0, 1, 100)), - ], - dependent_variables=[Variable(name="class", allowed_values=[0, 1])], - ) - - # Theorist with skl Pipeline - clf = skp.Pipeline([("scaler", StandardScaler()), ("lr", LogisticRegression())]) - - # Experimentalist - experimentalist = Pipeline( - [ - ("pool", X), - ("sampler", random_sampler), - ], - params={ - "sampler": {"n": 15}, - }, - ) - - # Experiment Runner - def experiment_runner(xs): - y_return = np.where(xs > 0.5, 1, 0) - return y_return - - cycle = Cycle( - metadata=study_metadata, - theorist=clf, - experimentalist=experimentalist, - experiment_runner=experiment_runner, - ) - cycle.run(6) - - # Check that the memory space of all estimators are different - l_memory = [id(s["lr"]) for s in cycle.data.theories] - n_unique = len(np.unique(l_memory)) - n_theories = len(cycle.data.theories) - assert n_unique == n_theories diff --git a/tests/test_summed_dissimilarity_sampler.py b/tests/test_summed_dissimilarity_sampler.py deleted file mode 100644 index d67c0d52f..000000000 --- a/tests/test_summed_dissimilarity_sampler.py +++ /dev/null @@ -1,32 +0,0 @@ -import numpy as np - -from autora.experimentalist.sampler.dissimilarity import summed_dissimilarity_sampler - - -def test_dissimilarity_sampler_1D(): - - num_samples = 2 - - # define two matrices - matrix1 = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) - matrix2 = np.array([1, 2, 3]) - - # reorder matrix1 according to its distances to matrix2 - reordered_matrix1 = summed_dissimilarity_sampler(matrix1, matrix2, n=num_samples) - - assert reordered_matrix1.shape[0] == num_samples - assert reordered_matrix1.shape[1] == 1 - assert np.array_equal(reordered_matrix1, np.array([[10], [9]])) - - -def test_dissimilarity_sampler_ND(): - # define two matrices - matrix1 = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]]) - matrix2 = np.array([[1, 1, 1], [2, 2, 2], [3, 3, 3]]) - - # reorder matrix1 according to its distances to matrix2 - reordered_matrix1 = summed_dissimilarity_sampler(matrix1, matrix2, n=2) - - assert reordered_matrix1.shape[0] == 2 - assert reordered_matrix1.shape[1] == 3 - assert np.array_equal(reordered_matrix1, np.array([[10, 11, 12], [7, 8, 9]])) diff --git a/tests/test_synthetic_inventory.py b/tests/test_synthetic_inventory.py deleted file mode 100644 index 9070c6836..000000000 --- a/tests/test_synthetic_inventory.py +++ /dev/null @@ -1,22 +0,0 @@ -import autora.synthetic -from autora.synthetic.inventory import SyntheticExperimentCollection -from autora.variable import VariableCollection - - -def test_model_registration_retrieval(): - # We can register a model and retrieve it - autora.synthetic.register("empty", lambda: SyntheticExperimentCollection()) - empty = autora.synthetic.retrieve("empty") - assert empty.name is None - - # We can register another model and retrieve it as well - autora.synthetic.register( - "only_metadata", - lambda: SyntheticExperimentCollection(metadata=VariableCollection()), - ) - only_metadata = autora.synthetic.retrieve("only_metadata") - assert only_metadata.metadata is not None - - # We can still retrieve the first model, and it is equal to the first version - empty_copy = autora.synthetic.retrieve("empty") - assert empty_copy == empty diff --git a/tests/test_system.py b/tests/test_system.py deleted file mode 100644 index c1191b316..000000000 --- a/tests/test_system.py +++ /dev/null @@ -1,13 +0,0 @@ -import autora -import autora.skl.darts as skl_darts -import autora.theorist.darts as theorist_darts - - -def test_import(): - assert autora is not None - - assert skl_darts.DARTSRegressor is not None - assert skl_darts.DARTSExecutionMonitor is not None - - assert theorist_darts.Network is not None - assert theorist_darts.Architect is not None diff --git a/tests/test_uncertainty_sampler.py b/tests/test_uncertainty_sampler.py deleted file mode 100644 index 237c1a32c..000000000 --- a/tests/test_uncertainty_sampler.py +++ /dev/null @@ -1,128 +0,0 @@ -from math import log - -import numpy as np -import pandas as pd -import pytest -from sklearn.linear_model import LogisticRegression - -from autora.experimentalist.sampler import uncertainty_sampler - - -@pytest.fixture -def synthetic_lr_model(): - """ - Creates logistic regression classifier for 3 classes based on synthetic data. - """ - n = 100 - X = ([[1, 0, 0]] * n) + ([[0, 1, 0]] * n) + ([[0, 0, 1]] * n) - y = ([0] * n) + ([1] * n) + ([2] * n) - model = LogisticRegression() - model.fit(X, y) - return model - - -@pytest.fixture -def data_to_test(): - data = np.array( - [ - [1, 0, 0], - [0, 1, 0], - [0.8, 0.2, 0], - [0.7, 0.3, 0], - [0.6, 0.4, 0], - [0.5, 0.5, 0], - [0.4, 0.3, 0.2], # doesn't sum to 1 - [0.4, 0.4, 0.2], - ] - ) - return data - - -def test_uncertainty_least_confident(synthetic_lr_model, data_to_test): - # Import model and data - model = synthetic_lr_model - X = data_to_test - - # Run uncertainty sampler with least confident measure - samples = uncertainty_sampler(X, model, 5, measure="least_confident") - - assert np.array_equal( - samples, - np.array( - [ - # Least confident because 0.4s are equal - # and 0.2 is different again - [0.4, 0.4, 0.2], - [0.5, 0.5, 0], - [0.4, 0.3, 0.2], - [0.6, 0.4, 0], - # Most confident of the least-confident 5 because 0.7 is higher - # than all the other highest probabilities - [0.7, 0.3, 0], - ] - ), - ) - - -def test_uncertainty_margin(synthetic_lr_model, data_to_test): - model = synthetic_lr_model - X = data_to_test - - # Run uncertainty sampler with margin measure - samples = uncertainty_sampler(X, model, 5, measure="margin") - - assert np.array_equal( - samples, - np.array( - [ - [ - 0.4, - 0.4, - 0.2, - ], # For numerical reasons, this comes out first even though ... - [ - 0.5, - 0.5, - 0, - ], # ... the margin between class 0 and 1 in *this* case is also zero - [0.4, 0.3, 0.2], - [0.6, 0.4, 0], - [0.7, 0.3, 0], - ] - ), - ) - - -def test_uncertainty_entropy(synthetic_lr_model, data_to_test): - model = synthetic_lr_model - X = data_to_test - - # Run uncertainty sampler with margin measure - samples = uncertainty_sampler(X, model, 5, measure="entropy") - - # Manual Calculation - mat_prob = model.predict_proba(X) - l_entropy = [] - for l_prob in mat_prob: - l_entropy.append(-np.sum([s * log(s) for s in l_prob])) - s_entropy = pd.Series(l_entropy).sort_values(ascending=False) - idx = s_entropy.index.values[0:5] - manual_samples = X[idx] - - assert np.array_equal(samples, manual_samples) - - -def test_uncertainty_entropy_vs_margin(synthetic_lr_model, data_to_test): - """ - Test data should yield different results. Condition [0.4, 0.3, 0.2] should have the greatest - entropy but less margin than conditions [0.4, 0.4, 0.2] and [0.5, 0.5, 0. ]. - """ - model = synthetic_lr_model - X = data_to_test - - # Run uncertainty sampler with entropy and margin measures to compare - samples_entropy = uncertainty_sampler(X, model, 1, measure="entropy") - samples_margin = uncertainty_sampler(X, model, 2, measure="margin") - - assert np.array_equal(samples_entropy, np.array([[0.4, 0.3, 0.2]])) - assert np.array_equal(samples_margin, np.array([[0.4, 0.4, 0.2], [0.5, 0.5, 0.0]]))